dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318 /* -----------------------------------------------------------------------------
 319  * director_common.swg
 320  *
 321  * This file contains support for director classes which is common between
 322  * languages.
 323  * ----------------------------------------------------------------------------- */
 324
 325 /*
 326   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 327   'Swig' namespace. This could be useful for multi-modules projects.
 328 */
 329 #ifdef SWIG_DIRECTOR_STATIC
 330 /* Force anonymous (static) namespace */
 331 #define Swig
 332 #endif
 333 /* -----------------------------------------------------------------------------
 334  * director.swg
 335  *
 336  * This file contains support for director classes so that C# proxy
 337  * methods can be called from C++.
 338  * ----------------------------------------------------------------------------- */
 339
 340 #if defined(DEBUG_DIRECTOR_OWNED)
 341 #include <iostream>
 342 #endif
 343 #include <string>
 344 #include <exception>
 345
 346 namespace Swig {
 347   /* Director base class - not currently used in C# directors */
 348   class Director {
 349   };
 350
 351   /* Base class for director exceptions */
 352   class DirectorException : public std::exception {
 353   protected:
 354     std::string swig_msg;
 355
 356   public:
 357     DirectorException(const char *msg) : swig_msg(msg) {
 358     }
 359
 360     DirectorException(const std::string &msg) : swig_msg(msg) {
 361     }
 362
 363     virtual ~DirectorException() throw() {
 364     }
 365
 366     const char *what() const throw() {
 367       return swig_msg.c_str();
 368     }
 369   };
 370
 371   /* Pure virtual method exception */
 372   class DirectorPureVirtualException : public DirectorException {
 373   public:
 374     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 375     }
 376   };
 377 }
 378
 379
 380 void SWIG_CSharpException(int code, const char *msg) {
 381   if (code == SWIG_ValueError) {
 382     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 383     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 384   } else {
 385     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 386     switch(code) {
 387     case SWIG_MemoryError:
 388       exception_code = SWIG_CSharpOutOfMemoryException;
 389       break;
 390     case SWIG_IndexError:
 391       exception_code = SWIG_CSharpIndexOutOfRangeException;
 392       break;
 393     case SWIG_DivisionByZero:
 394       exception_code = SWIG_CSharpDivideByZeroException;
 395       break;
 396     case SWIG_IOError:
 397       exception_code = SWIG_CSharpIOException;
 398       break;
 399     case SWIG_OverflowError:
 400       exception_code = SWIG_CSharpOverflowException;
 401       break;
 402     case SWIG_RuntimeError:
 403     case SWIG_TypeError:
 404     case SWIG_SyntaxError:
 405     case SWIG_SystemError:
 406     case SWIG_UnknownError:
 407     default:
 408       exception_code = SWIG_CSharpApplicationException;
 409       break;
 410     }
 411     SWIG_CSharpSetPendingException(exception_code, msg);
 412   }
 413 }
 414
 415
 416 #include <stdexcept>
 417
 418
 419 #define SWIGSTDCALL
 420
 421 #include <time.h>
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429 #include <dali/devel-api/events/wheel-event-devel.h>
 430 #include <dali/devel-api/events/hover-event-devel.h>
 431 #include <dali/devel-api/events/touch-point.h>
 432
 433 #include <dali/public-api/math/matrix.h>
 434 #include <dali/public-api/math/matrix3.h>
 435 #include <dali/public-api/math/viewport.h>
 436 #include <dali/public-api/object/property-key.h>
 437 #include <dali/devel-api/object/csharp-type-info.h>
 438 #include <dali/devel-api/object/csharp-type-registry.h>
 439
 440 #include <dali/public-api/adaptor-framework/timer.h>
 441 #include <dali/public-api/adaptor-framework/style-change.h>
 442 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 443
 444 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 460 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 461 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 462
 463 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 464 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 465 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 466
 467 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 469 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 470
 471 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 472 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 473 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 474
 475 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 476
 477 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 478 #include <dali/devel-api/adaptor-framework/image-loading.h>
 479
 480 #include <dali/public-api/events/mouse-button.h>
 481
 482 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 483 #include "web-view-signal-converter.h"
 484
 485 #include <dali/integration-api/debug.h>
 486
 487 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 488
 489 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 490
 491 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 492
 493
 494 #include <dali/devel-api/update/frame-callback-interface.h>
 495 #include <dali/devel-api/update/update-proxy.h>
 496
 497
 498 // add here SWIG version check
 499
 500 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 501 // disable Swig-dependent warnings
 502
 503 // 'identifier1' has C-linkage specified,
 504 // but returns UDT 'identifier2' which is incompatible with C
 505 #pragma warning(disable: 4190)
 506
 507 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 508 #pragma warning(disable: 4800)
 509
 510 // debug info too long etc etc
 511 #pragma warning(disable: 4786)
 512 #endif
 513
 514
 515 #include <stdexcept>
 516
 517
 518 #include <string>
 519
 520
 521 #include <vector>
 522 #include <algorithm>
 523 #include <stdexcept>
 524
 525
 526 #include <map>
 527 #include <algorithm>
 528 #include <stdexcept>
 529
 530
 531 #include <utility>
 532
 533
 534 typedef float floatp;
 535
 536 SWIGINTERN floatp *new_floatp(){
 537   return new float();
 538 }
 539 SWIGINTERN void delete_floatp(floatp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void floatp_assign(floatp *self,float value){
 543   *self = value;
 544 }
 545 SWIGINTERN float floatp_value(floatp *self){
 546   return *self;
 547 }
 548 SWIGINTERN float *floatp_cast(floatp *self){
 549   return self;
 550 }
 551 SWIGINTERN floatp *floatp_frompointer(float *t){
 552   return (floatp *) t;
 553 }
 554
 555 typedef int intp;
 556
 557 SWIGINTERN intp *new_intp(){
 558   return new int();
 559 }
 560 SWIGINTERN void delete_intp(intp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void intp_assign(intp *self,int value){
 564   *self = value;
 565 }
 566 SWIGINTERN int intp_value(intp *self){
 567   return *self;
 568 }
 569 SWIGINTERN int *intp_cast(intp *self){
 570   return self;
 571 }
 572 SWIGINTERN intp *intp_frompointer(int *t){
 573   return (intp *) t;
 574 }
 575
 576 typedef double doublep;
 577
 578 SWIGINTERN doublep *new_doublep(){
 579   return new double();
 580 }
 581 SWIGINTERN void delete_doublep(doublep *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void doublep_assign(doublep *self,double value){
 585   *self = value;
 586 }
 587 SWIGINTERN double doublep_value(doublep *self){
 588   return *self;
 589 }
 590 SWIGINTERN double *doublep_cast(doublep *self){
 591   return self;
 592 }
 593 SWIGINTERN doublep *doublep_frompointer(double *t){
 594   return (doublep *) t;
 595 }
 596
 597 typedef unsigned int uintp;
 598
 599 SWIGINTERN uintp *new_uintp(){
 600   return new unsigned int();
 601 }
 602 SWIGINTERN void delete_uintp(uintp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned int uintp_value(uintp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 612   return self;
 613 }
 614 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 615   return (uintp *) t;
 616 }
 617
 618 typedef unsigned short ushortp;
 619
 620 SWIGINTERN ushortp *new_ushortp(){
 621   return new unsigned short();
 622 }
 623 SWIGINTERN void delete_ushortp(ushortp *self){
 624   if (self) delete self;
 625 }
 626 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 627   *self = value;
 628 }
 629 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 630   return *self;
 631 }
 632 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 633   return self;
 634 }
 635 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 636   return (ushortp *) t;
 637 }
 638
 639 unsigned int int_to_uint(int x) {
 640    return (unsigned int) x;
 641 }
 642
 643
 644 #define CALL_CATCH_EXCEPTION(ret)          \
 645          catch (std::out_of_range& e)            \
 646          {                                                                                                                                  \
 647              SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));   \
 648              return ret;\
 649           }                                                                                                                                 \
 650           catch (std::exception& e)                                                                                         \
 651           {                                                                                                                                 \
 652             SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));\
 653             return ret;\
 654           }                                                                                                                                 \
 655           catch (DaliException e)                                                                                            \
 656           {                                                                                                                                 \
 657             SWIG_CSharpException(SWIG_UnknownError, e.condition);                            \
 658             return ret;\
 659           }                                                                                                                                 \
 660           catch (...)                                                                                                                  \
 661           {                                                                                                                                 \
 662             SWIG_CSharpException(SWIG_UnknownError, "unknown error");                  \
 663             return ret;\
 664           }
 665
 666
 667
 668 using namespace Dali;
 669 using namespace Dali::Toolkit;
 670
 671 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 672 {
 673   bool result = false;
 674   try
 675   {
 676     // C++ code. DALi uses Handle <-> Body design pattern.
 677     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 678     // Handles in DALi can be converted into a boolean type
 679     // to check if the handle has a valid body attached to it.
 680     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 681     if( *self )
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   CALL_CATCH_EXCEPTION(false);
 691   return result;
 692 }
 693
 694 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 695 {
 696   bool result = false;
 697   try
 698   {
 699     // C++ code. Check if two handles reference the same implemtion
 700     if( *self == rhs)
 701     {
 702       result = true;
 703     }
 704     else
 705     {
 706       result = false;
 707     }
 708   }
 709   CALL_CATCH_EXCEPTION(false);
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 853           self->Disconnect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 876          return self->Empty();
 877       }
 878 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 879         return self->GetConnectionCount();
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 882         self->Connect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 885         self->Disconnect( func );
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 888         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg1, arg2 );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 892          return self->Empty();
 893       }
 894 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 895         return self->GetConnectionCount();
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 898         self->Connect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 901         self->Disconnect( func );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 904         return self->Emit( arg1, arg2 );
 905       }
 906 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 907          return self->Empty();
 908       }
 909 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 910         return self->GetConnectionCount();
 911       }
 912 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 913         self->Connect( func );
 914       }
 915 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 916         self->Disconnect( func );
 917       }
 918 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 919         return self->Emit( arg1, arg2 );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 922          return self->Empty();
 923       }
 924 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 925         return self->GetConnectionCount();
 926       }
 927 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 928         self->Connect( func );
 929       }
 930 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 931         self->Disconnect( func );
 932       }
 933 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 934         return self->Emit( arg1, arg2 );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 953          return self->Empty();
 954       }
 955 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 956         return self->GetConnectionCount();
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 959           self->Connect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 962           self->Disconnect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 969          return self->Empty();
 970       }
 971 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 972         return self->GetConnectionCount();
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 975           self->Connect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 978           self->Disconnect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 985          return self->Empty();
 986       }
 987 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 988         return self->GetConnectionCount();
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 991           self->Connect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 994           self->Disconnect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1007         self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1010         self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1013         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg1, arg2 );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1017          return self->Empty();
1018       }
1019 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1020         return self->GetConnectionCount();
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1023         self->Connect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1026         self->Disconnect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1039         self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1042         self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1049          return self->Empty();
1050       }
1051 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1052         return self->GetConnectionCount();
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1055           return self->Connect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1058           self->Disconnect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1061           self->Emit( arg1, arg3 );
1062       }
1063 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1064          return self->Empty();
1065       }
1066 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1067         return self->GetConnectionCount();
1068       }
1069 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1070           return self->Connect( func );
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1073           self->Disconnect( func );
1074       }
1075 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1076           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1077 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1078       }
1079
1080 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1087           self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1093           return self->Emit();
1094       }
1095
1096 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1097         std::vector< unsigned int >* pv = 0;
1098         if (capacity >= 0) {
1099           pv = new std::vector< unsigned int >();
1100           pv->reserve(capacity);
1101        } else {
1102           throw std::out_of_range("capacity");
1103        }
1104        return pv;
1105       }
1106 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1107         if (index>=0 && index<(int)self->size())
1108           return (*self)[index];
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1119         if (index>=0 && index<(int)self->size())
1120           (*self)[index] = val;
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1125         self->insert(self->end(), values.begin(), values.end());
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1128         if (index < 0)
1129           throw std::out_of_range("index");
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1133           throw std::invalid_argument("invalid range");
1134         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1137         if (index>=0 && index<(int)self->size()+1)
1138           self->insert(self->begin()+index, x);
1139         else
1140           throw std::out_of_range("index");
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, values.begin(), values.end());
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1149         if (index>=0 && index<(int)self->size())
1150           self->erase(self->begin() + index);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         self->erase(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         return new std::vector< unsigned int >(count, value);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1169         std::reverse(self->begin(), self->end());
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         std::reverse(self->begin()+index, self->begin()+index+count);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (index+values.size() > self->size())
1184           throw std::out_of_range("index");
1185         std::copy(values.begin(), values.end(), self->begin()+index);
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1188         return std::find(self->begin(), self->end(), value) != self->end();
1189       }
1190 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1191         int index = -1;
1192         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1193         if (it != self->end())
1194           index = (int)(it - self->begin());
1195         return index;
1196       }
1197 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1198         int index = -1;
1199         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1200         if (rit != self->rend())
1201           index = (int)(self->rend() - 1 - rit);
1202         return index;
1203       }
1204 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end()) {
1207           self->erase(it);
1208           return true;
1209         }
1210         return false;
1211       }
1212 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1213         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1214         if (capacity >= 0) {
1215           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1216           pv->reserve(capacity);
1217        } else {
1218           throw std::out_of_range("capacity");
1219        }
1220        return pv;
1221       }
1222 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1223         if (index>=0 && index<(int)self->size())
1224           return (*self)[index];
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1235         if (index>=0 && index<(int)self->size())
1236           (*self)[index] = val;
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1241         self->insert(self->end(), values.begin(), values.end());
1242       }
1243 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1244         if (index < 0)
1245           throw std::out_of_range("index");
1246         if (count < 0)
1247           throw std::out_of_range("count");
1248         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1249           throw std::invalid_argument("invalid range");
1250         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1251       }
1252 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1253         if (index>=0 && index<(int)self->size()+1)
1254           self->insert(self->begin()+index, x);
1255         else
1256           throw std::out_of_range("index");
1257       }
1258 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, values.begin(), values.end());
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1265         if (index>=0 && index<(int)self->size())
1266           self->erase(self->begin() + index);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         self->erase(self->begin()+index, self->begin()+index+count);
1278       }
1279 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1283       }
1284 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1285         std::reverse(self->begin(), self->end());
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         std::reverse(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (index+values.size() > self->size())
1300           throw std::out_of_range("index");
1301         std::copy(values.begin(), values.end(), self->begin()+index);
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1304         std::vector< Dali::Actor >* pv = 0;
1305         if (capacity >= 0) {
1306           pv = new std::vector< Dali::Actor >();
1307           pv->reserve(capacity);
1308        } else {
1309           throw std::out_of_range("capacity");
1310        }
1311        return pv;
1312       }
1313 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1314         if (index>=0 && index<(int)self->size())
1315           return (*self)[index];
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1326         if (index>=0 && index<(int)self->size())
1327           (*self)[index] = val;
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1332         self->insert(self->end(), values.begin(), values.end());
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1335         if (index < 0)
1336           throw std::out_of_range("index");
1337         if (count < 0)
1338           throw std::out_of_range("count");
1339         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1340           throw std::invalid_argument("invalid range");
1341         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1344         if (index>=0 && index<(int)self->size()+1)
1345           self->insert(self->begin()+index, x);
1346         else
1347           throw std::out_of_range("index");
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, values.begin(), values.end());
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1356         if (index>=0 && index<(int)self->size())
1357           self->erase(self->begin() + index);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         self->erase(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         return new std::vector< Dali::Actor >(count, value);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1376         std::reverse(self->begin(), self->end());
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1379         if (index < 0)
1380           throw std::out_of_range("index");
1381         if (count < 0)
1382           throw std::out_of_range("count");
1383         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1384           throw std::invalid_argument("invalid range");
1385         std::reverse(self->begin()+index, self->begin()+index+count);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (index+values.size() > self->size())
1391           throw std::out_of_range("index");
1392         std::copy(values.begin(), values.end(), self->begin()+index);
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1401           self->Connect( func );
1402       }
1403 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1404           self->Disconnect( func );
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1407           return self->Emit( arg );
1408       }
1409 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1410          return self->Empty();
1411       }
1412 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1413         return self->GetConnectionCount();
1414       }
1415 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1416         self->Connect( func );
1417       }
1418 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1419         self->Disconnect( func );
1420       }
1421 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1426          return self->Empty();
1427       }
1428 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1429         return self->GetConnectionCount();
1430       }
1431 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1432         self->Connect( func );
1433       }
1434 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1435         self->Disconnect( func );
1436       }
1437 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1448         self->Connect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1451         self->Disconnect( func );
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1464         self->Connect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1467         self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1480           self->Connect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1486           return self->Emit( arg );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1495           self->Connect( func );
1496       }
1497 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1505          return self->Empty();
1506       }
1507 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1508         return self->GetConnectionCount();
1509       }
1510 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1511           return self->Connect( func );
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1514           self->Disconnect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1527           self->Connect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1543           return self->Connect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1559           self->Connect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1569          return self->Empty();
1570       }
1571 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1572         return self->GetConnectionCount();
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1575           self->Connect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1578           self->Disconnect( func );
1579       }
1580 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584
1585
1586 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1587          return self->Empty();
1588       }
1589 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1590         return self->GetConnectionCount();
1591       }
1592 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1593         self->Connect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1596         self->Disconnect( func );
1597       }
1598 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1599         return self->Emit( arg1, arg2 );
1600       }
1601 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1602          return self->Empty();
1603       }
1604 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1605         return self->GetConnectionCount();
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1608           self->Connect( func );
1609       }
1610 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1611           self->Disconnect( func );
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1614           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1615 /*@SWIG@*/ self->Emit( arg );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1618          return self->Empty();
1619       }
1620 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1621         return self->GetConnectionCount();
1622       }
1623 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1624           self->Connect( func );
1625       }
1626 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1627           self->Disconnect( func );
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1630           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1631 /*@SWIG@*/ self->Emit( arg );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1634          return self->Empty();
1635       }
1636 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1637         return self->GetConnectionCount();
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1640         self->Connect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1643         self->Disconnect( func );
1644       }
1645 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1646         return self->Emit( arg1, arg2 );
1647       }
1648 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1649          return self->Empty();
1650       }
1651 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1652         return self->GetConnectionCount();
1653       }
1654 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1655         self->Connect( func );
1656       }
1657 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1658         self->Disconnect( func );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1661         return self->Emit( arg1, arg2 );
1662       }
1663
1664 /* ---------------------------------------------------
1665  * C++ director class methods
1666  * --------------------------------------------------- */
1667
1668 #include "dali_wrap.h"
1669
1670 /*
1671  *  Widget director
1672  */
1673 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1674   swig_init_callbacks();
1675 }
1676
1677 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1678 }
1679
1680 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1681   char * jcontentInfo = 0 ;
1682   void * jwindow  ;
1683
1684   if (!swig_callbackOnCreate) {
1685     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1686     return;
1687   } else {
1688     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1689     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1690     swig_callbackOnCreate(jcontentInfo, jwindow);
1691   }
1692 }
1693
1694 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1695   char * jcontentInfo = 0 ;
1696   int jtype  ;
1697
1698   if (!swig_callbackOnTerminate) {
1699     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1700     return;
1701   } else {
1702     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1703     jtype = (int)type;
1704     swig_callbackOnTerminate(jcontentInfo, jtype);
1705   }
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnPause() {
1709   if (!swig_callbackOnPause) {
1710     Dali::Internal::Adaptor::Widget::OnPause();
1711     return;
1712   } else {
1713     swig_callbackOnPause();
1714   }
1715 }
1716
1717 void SwigDirector_WidgetImpl::OnResume() {
1718   if (!swig_callbackOnResume) {
1719     Dali::Internal::Adaptor::Widget::OnResume();
1720     return;
1721   } else {
1722     swig_callbackOnResume();
1723   }
1724 }
1725
1726 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1727   void * jwindow  ;
1728
1729   if (!swig_callbackOnResize) {
1730     Dali::Internal::Adaptor::Widget::OnResize(window);
1731     return;
1732   } else {
1733     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1734     swig_callbackOnResize(jwindow);
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1739   char * jcontentInfo = 0 ;
1740   int jforce  ;
1741
1742   if (!swig_callbackOnUpdate) {
1743     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1744     return;
1745   } else {
1746     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1747     jforce = force;
1748     swig_callbackOnUpdate(jcontentInfo, jforce);
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1753   void * jslotObserver = 0 ;
1754   void * jcallback = 0 ;
1755
1756   if (!swig_callbackSignalConnected) {
1757     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1758     return;
1759   } else {
1760     jslotObserver = (void *) slotObserver;
1761     jcallback = (void *) callback;
1762     swig_callbackSignalConnected(jslotObserver, jcallback);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1767   void * jslotObserver = 0 ;
1768   void * jcallback = 0 ;
1769
1770   if (!swig_callbackSignalDisconnected) {
1771     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1772     return;
1773   } else {
1774     jslotObserver = (void *) slotObserver;
1775     jcallback = (void *) callback;
1776     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1777   }
1778 }
1779
1780 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1781
1782   swig_callbackOnCreate = callbackOnCreate;
1783   swig_callbackOnTerminate = callbackOnTerminate;
1784   swig_callbackOnPause = callbackOnPause;
1785   swig_callbackOnResume = callbackOnResume;
1786   swig_callbackOnResize = callbackOnResize;
1787   swig_callbackOnUpdate = callbackOnUpdate;
1788   swig_callbackSignalConnected = callbackSignalConnected;
1789   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1790 }
1791
1792 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1793   swig_callbackOnCreate = 0;
1794   swig_callbackOnTerminate = 0;
1795   swig_callbackOnPause = 0;
1796   swig_callbackOnResume = 0;
1797   swig_callbackOnResize = 0;
1798   swig_callbackOnUpdate = 0;
1799   swig_callbackSignalConnected = 0;
1800   swig_callbackSignalDisconnected = 0;
1801 }
1802
1803
1804 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1805   swig_init_callbacks();
1806 }
1807
1808 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1809
1810 }
1811
1812
1813 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1814   int jdepth  ;
1815
1816   if (!swig_callbackOnSceneConnection) {
1817     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1818     return;
1819   } else {
1820     jdepth = depth;
1821     swig_callbackOnSceneConnection(jdepth);
1822   }
1823 }
1824
1825 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1826   if (!swig_callbackOnSceneDisconnection) {
1827     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1828     return;
1829   } else {
1830     swig_callbackOnSceneDisconnection();
1831   }
1832 }
1833
1834 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1835   void * jchild = 0 ;
1836
1837   if (!swig_callbackOnChildAdd) {
1838     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1839     return;
1840   } else {
1841     jchild = (Dali::Actor *) &child;
1842     swig_callbackOnChildAdd(jchild);
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1847   void * jchild = 0 ;
1848
1849   if (!swig_callbackOnChildRemove) {
1850     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1851     return;
1852   } else {
1853     jchild = (Dali::Actor *) &child;
1854     swig_callbackOnChildRemove(jchild);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const 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::OnKeyEvent(Dali::KeyEvent const &event) {
1899   bool c_result = SwigValueInit< bool >() ;
1900   unsigned int jresult = 0 ;
1901   void * jarg0 = 0 ;
1902
1903   if (!swig_callbackOnKeyEvent) {
1904     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1905   } else {
1906     jarg0 = (Dali::KeyEvent *) &event;
1907     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1908     c_result = jresult ? true : false;
1909   }
1910   return c_result;
1911 }
1912
1913 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1914   void * jsize = 0 ;
1915   void * jcontainer = 0 ;
1916
1917   if (!swig_callbackOnRelayout) {
1918     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1919     return;
1920   } else {
1921     jsize = (Dali::Vector2 *) &size;
1922     jcontainer = (Dali::RelayoutContainer *) &container;
1923     swig_callbackOnRelayout(jsize, jcontainer);
1924   }
1925 }
1926
1927 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1928   int jpolicy  ;
1929   int jdimension  ;
1930
1931   if (!swig_callbackOnSetResizePolicy) {
1932     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1933     return;
1934   } else {
1935     jpolicy = (int)policy;
1936     jdimension = (int)dimension;
1937     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1938   }
1939 }
1940
1941 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1942   Dali::Vector3 c_result ;
1943   void * jresult = 0 ;
1944
1945   if (!swig_callbackGetNaturalSize) {
1946     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1947   } else {
1948     jresult = (void *) swig_callbackGetNaturalSize();
1949     if (!jresult) {
1950       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1951       return c_result;
1952     }
1953     c_result = *(Dali::Vector3 *)jresult;
1954   }
1955   return c_result;
1956 }
1957
1958 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1959   float c_result = SwigValueInit< float >() ;
1960   float jresult = 0 ;
1961   void * jchild = 0 ;
1962   int jdimension  ;
1963
1964   if (!swig_callbackCalculateChildSize) {
1965     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1966   } else {
1967     jchild = (Dali::Actor *) &child;
1968     jdimension = (int)dimension;
1969     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1970     c_result = (float)jresult;
1971   }
1972   return c_result;
1973 }
1974
1975 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1976   float c_result = SwigValueInit< float >() ;
1977   float jresult = 0 ;
1978   float jwidth  ;
1979
1980   if (!swig_callbackGetHeightForWidth) {
1981     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1982   } else {
1983     jwidth = width;
1984     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1985     c_result = (float)jresult;
1986   }
1987   return c_result;
1988 }
1989
1990 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1991   float c_result = SwigValueInit< float >() ;
1992   float jresult = 0 ;
1993   float jheight  ;
1994
1995   if (!swig_callbackGetWidthForHeight) {
1996     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1997   } else {
1998     jheight = height;
1999     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2000     c_result = (float)jresult;
2001   }
2002   return c_result;
2003 }
2004
2005 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2006   bool c_result = SwigValueInit< bool >() ;
2007   unsigned int jresult = 0 ;
2008   int jdimension  ;
2009
2010   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2011     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2012   } else {
2013     jdimension = (int)dimension;
2014     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2015     c_result = jresult ? true : false;
2016   }
2017   return c_result;
2018 }
2019
2020 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2021   int jdimension  ;
2022
2023   if (!swig_callbackOnCalculateRelayoutSize) {
2024     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2025     return;
2026   } else {
2027     jdimension = (int)dimension;
2028     swig_callbackOnCalculateRelayoutSize(jdimension);
2029   }
2030 }
2031
2032 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2033   float jsize  ;
2034   int jdimension  ;
2035
2036   if (!swig_callbackOnLayoutNegotiated) {
2037     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2038     return;
2039   } else {
2040     jsize = size;
2041     jdimension = (int)dimension;
2042     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2043   }
2044 }
2045
2046 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2047   return Dali::CustomActorImpl::GetExtension();
2048 }
2049
2050 void SwigDirector_ViewImpl::OnInitialize() {
2051   if (!swig_callbackOnInitialize) {
2052     Dali::Toolkit::Internal::Control::OnInitialize();
2053     return;
2054   } else {
2055     swig_callbackOnInitialize();
2056   }
2057 }
2058
2059 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2060   void * jstyleManager  ;
2061   int jchange  ;
2062
2063   if (!swig_callbackOnStyleChange) {
2064     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2065     return;
2066   } else {
2067     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2068     jchange = (int)change;
2069     swig_callbackOnStyleChange(jstyleManager, jchange);
2070   }
2071 }
2072
2073 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2074   bool c_result = SwigValueInit< bool >() ;
2075   unsigned int jresult = 0 ;
2076
2077   if (!swig_callbackOnAccessibilityActivated) {
2078     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2079   } else {
2080     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2081     c_result = jresult ? true : false;
2082   }
2083   return c_result;
2084 }
2085
2086 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2087   bool c_result = SwigValueInit< bool >() ;
2088   unsigned int jresult = 0 ;
2089   void * jgesture  ;
2090
2091   if (!swig_callbackOnAccessibilityPan) {
2092     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2093   } else {
2094     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2095     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2096     c_result = jresult ? true : false;
2097   }
2098   return c_result;
2099 }
2100
2101 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2102   bool c_result = SwigValueInit< bool >() ;
2103   unsigned int jresult = 0 ;
2104   unsigned int jisIncrease  ;
2105
2106   if (!swig_callbackOnAccessibilityValueChange) {
2107     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2108   } else {
2109     jisIncrease = isIncrease;
2110     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2111     c_result = jresult ? true : false;
2112   }
2113   return c_result;
2114 }
2115
2116 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2117   bool c_result = SwigValueInit< bool >() ;
2118   unsigned int jresult = 0 ;
2119
2120   if (!swig_callbackOnAccessibilityZoom) {
2121     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2122   } else {
2123     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2124     c_result = jresult ? true : false;
2125   }
2126   return c_result;
2127 }
2128
2129 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2130   if (!swig_callbackOnKeyInputFocusGained) {
2131     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2132     return;
2133   } else {
2134     swig_callbackOnKeyInputFocusGained();
2135   }
2136 }
2137
2138 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2139   if (!swig_callbackOnKeyInputFocusLost) {
2140     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2141     return;
2142   } else {
2143     swig_callbackOnKeyInputFocusLost();
2144   }
2145 }
2146
2147 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2148   Dali::Actor c_result ;
2149   void * jresult = 0 ;
2150   void * jcurrentFocusedActor  ;
2151   int jdirection  ;
2152   unsigned int jloopEnabled  ;
2153
2154   if (!swig_callbackGetNextKeyboardFocusableActor) {
2155     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2156   } else {
2157     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2158     jdirection = (int)direction;
2159     jloopEnabled = loopEnabled;
2160     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2161     if (!jresult) {
2162       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2163       return c_result;
2164     }
2165     c_result = *(Dali::Actor *)jresult;
2166   }
2167   return c_result;
2168 }
2169
2170 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2171   void * jcommitedFocusableActor  ;
2172
2173   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2174     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2175     return;
2176   } else {
2177     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2178     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2179   }
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185
2186   if (!swig_callbackOnKeyboardEnter) {
2187     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2188   } else {
2189     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2190     c_result = jresult ? true : false;
2191   }
2192   return c_result;
2193 }
2194
2195 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2196   void * jpinch = 0 ;
2197
2198   if (!swig_callbackOnPinch) {
2199     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2200     return;
2201   } else {
2202     jpinch = (Dali::PinchGesture *) &pinch;
2203     swig_callbackOnPinch(jpinch);
2204   }
2205 }
2206
2207 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2208   void * jpan = 0 ;
2209
2210   if (!swig_callbackOnPan) {
2211     Dali::Toolkit::Internal::Control::OnPan(pan);
2212     return;
2213   } else {
2214     jpan = (Dali::PanGesture *) &pan;
2215     swig_callbackOnPan(jpan);
2216   }
2217 }
2218
2219 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2220   void * jtap = 0 ;
2221
2222   if (!swig_callbackOnTap) {
2223     Dali::Toolkit::Internal::Control::OnTap(tap);
2224     return;
2225   } else {
2226     jtap = (Dali::TapGesture *) &tap;
2227     swig_callbackOnTap(jtap);
2228   }
2229 }
2230
2231 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2232   void * jlongPress = 0 ;
2233
2234   if (!swig_callbackOnLongPress) {
2235     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2236     return;
2237   } else {
2238     jlongPress = (Dali::LongPressGesture *) &longPress;
2239     swig_callbackOnLongPress(jlongPress);
2240   }
2241 }
2242
2243 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2244   void * jslotObserver = 0 ;
2245   void * jcallback = 0 ;
2246
2247   if (!swig_callbackSignalConnected) {
2248     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2249     return;
2250   } else {
2251     jslotObserver = (void *) slotObserver;
2252     jcallback = (void *) callback;
2253     swig_callbackSignalConnected(jslotObserver, jcallback);
2254   }
2255 }
2256
2257 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2258   void * jslotObserver = 0 ;
2259   void * jcallback = 0 ;
2260
2261   if (!swig_callbackSignalDisconnected) {
2262     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2263     return;
2264   } else {
2265     jslotObserver = (void *) slotObserver;
2266     jcallback = (void *) callback;
2267     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2268   }
2269 }
2270
2271 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2272   return Dali::Toolkit::Internal::Control::GetControlExtension();
2273 }
2274
2275 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_Callback9_t callbackOnKeyEvent, 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) {
2276   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2277   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2278   swig_callbackOnChildAdd = callbackOnChildAdd;
2279   swig_callbackOnChildRemove = callbackOnChildRemove;
2280   swig_callbackOnPropertySet = callbackOnPropertySet;
2281   swig_callbackOnSizeSet = callbackOnSizeSet;
2282   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2283   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2284   swig_callbackOnRelayout = callbackOnRelayout;
2285   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2286   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2287   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2288   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2289   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2290   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2291   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2292   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2293   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2294   swig_callbackOnInitialize = callbackOnInitialize;
2295   swig_callbackOnStyleChange = callbackOnStyleChange;
2296   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2297   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2298   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2299   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2300   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2301   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2302   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2303   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2304   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2305   swig_callbackOnPinch = callbackOnPinch;
2306   swig_callbackOnPan = callbackOnPan;
2307   swig_callbackOnTap = callbackOnTap;
2308   swig_callbackOnLongPress = callbackOnLongPress;
2309   swig_callbackSignalConnected = callbackSignalConnected;
2310   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2311 }
2312
2313 void SwigDirector_ViewImpl::swig_init_callbacks() {
2314   swig_callbackOnSceneConnection = 0;
2315   swig_callbackOnSceneDisconnection = 0;
2316   swig_callbackOnChildAdd = 0;
2317   swig_callbackOnChildRemove = 0;
2318   swig_callbackOnPropertySet = 0;
2319   swig_callbackOnSizeSet = 0;
2320   swig_callbackOnSizeAnimation = 0;
2321   swig_callbackOnKeyEvent = 0;
2322   swig_callbackOnRelayout = 0;
2323   swig_callbackOnSetResizePolicy = 0;
2324   swig_callbackGetNaturalSize = 0;
2325   swig_callbackCalculateChildSize = 0;
2326   swig_callbackGetHeightForWidth = 0;
2327   swig_callbackGetWidthForHeight = 0;
2328   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2329   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2330   swig_callbackOnCalculateRelayoutSize = 0;
2331   swig_callbackOnLayoutNegotiated = 0;
2332   swig_callbackOnInitialize = 0;
2333   swig_callbackOnStyleChange = 0;
2334   swig_callbackOnAccessibilityActivated = 0;
2335   swig_callbackOnAccessibilityPan = 0;
2336   swig_callbackOnAccessibilityValueChange = 0;
2337   swig_callbackOnAccessibilityZoom = 0;
2338   swig_callbackOnKeyInputFocusGained = 0;
2339   swig_callbackOnKeyInputFocusLost = 0;
2340   swig_callbackGetNextKeyboardFocusableActor = 0;
2341   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2342   swig_callbackOnKeyboardEnter = 0;
2343   swig_callbackOnPinch = 0;
2344   swig_callbackOnPan = 0;
2345   swig_callbackOnTap = 0;
2346   swig_callbackOnLongPress = 0;
2347   swig_callbackSignalConnected = 0;
2348   swig_callbackSignalDisconnected = 0;
2349 }
2350
2351 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2352   swig_init_callbacks();
2353 }
2354
2355 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2356
2357 }
2358
2359
2360 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2361   unsigned int c_result = SwigValueInit< unsigned int >() ;
2362   unsigned int jresult = 0 ;
2363
2364   if (!swig_callbackGetNumberOfItems) {
2365     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2366   } else {
2367     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2368     c_result = (unsigned int)jresult;
2369   }
2370   return c_result;
2371 }
2372
2373 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2374   Dali::Actor c_result ;
2375   void * jresult = 0 ;
2376   unsigned int jitemId  ;
2377
2378   if (!swig_callbackNewItem) {
2379     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2380   } else {
2381     jitemId = itemId;
2382     jresult = (void *) swig_callbackNewItem(jitemId);
2383     if (!jresult) {
2384       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2385       return c_result;
2386     }
2387     c_result = *(Dali::Actor *)jresult;
2388   }
2389   return c_result;
2390 }
2391
2392 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2393   unsigned int jitemId  ;
2394   void * jactor  ;
2395
2396   if (!swig_callbackItemReleased) {
2397     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2398     return;
2399   } else {
2400     jitemId = itemId;
2401     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2402     swig_callbackItemReleased(jitemId, jactor);
2403   }
2404 }
2405
2406 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2407   return Dali::Toolkit::ItemFactory::GetExtension();
2408 }
2409
2410 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2411   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2412   swig_callbackNewItem = callbackNewItem;
2413   swig_callbackItemReleased = callbackItemReleased;
2414 }
2415
2416 void SwigDirector_ItemFactory::swig_init_callbacks() {
2417   swig_callbackGetNumberOfItems = 0;
2418   swig_callbackNewItem = 0;
2419   swig_callbackItemReleased = 0;
2420 }
2421
2422 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2423   swig_init_callbacks();
2424 }
2425
2426 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2427
2428 }
2429
2430
2431 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2432   Dali::Actor c_result ;
2433   void * jresult = 0 ;
2434   void * jcurrent  ;
2435   void * jproposed  ;
2436   int jdirection  ;
2437
2438   if (!swig_callbackGetNextFocusableActor) {
2439     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2440   } else {
2441     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2442     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2443     jdirection = (int)direction;
2444     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2445     if (!jresult) {
2446       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__);
2447       return c_result;
2448     }
2449     c_result = *(Dali::Actor *)jresult;
2450   }
2451   return c_result;
2452 }
2453
2454 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2455   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2456 }
2457
2458 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2459   swig_callbackGetNextFocusableActor = 0;
2460 }
2461
2462 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2463   swig_callbackOnUpdate = 0;
2464 }
2465
2466 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2467
2468 }
2469
2470 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2471   swig_callbackOnUpdate = callbackUpdate;
2472 }
2473
2474
2475 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2476   void * jcurrent  ;
2477
2478   if (!swig_callbackOnUpdate) {
2479     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2480   } else {
2481     Dali::UpdateProxy* proxy = &updateProxy;
2482     jcurrent = (void *)proxy;
2483     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2484     if (!jcurrent) {
2485       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2486       return;
2487     }
2488   }
2489   return;
2490 }
2491
2492
2493 #ifdef __cplusplus
2494 extern "C" {
2495 #endif
2496
2497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2498   void * jresult ;
2499   floatp *result = 0 ;
2500
2501   {
2502     try {
2503       result = (floatp *)new_floatp();
2504     } CALL_CATCH_EXCEPTION(0);
2505   }
2506   jresult = (void *)result;
2507   return jresult;
2508 }
2509
2510
2511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2512   floatp *arg1 = (floatp *) 0 ;
2513
2514   arg1 = (floatp *)jarg1;
2515   {
2516     try {
2517       delete_floatp(arg1);
2518     } CALL_CATCH_EXCEPTION();
2519   }
2520
2521 }
2522
2523
2524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2525   floatp *arg1 = (floatp *) 0 ;
2526   float arg2 ;
2527
2528   arg1 = (floatp *)jarg1;
2529   arg2 = (float)jarg2;
2530   {
2531     try {
2532       floatp_assign(arg1,arg2);
2533     } CALL_CATCH_EXCEPTION();
2534   }
2535
2536 }
2537
2538
2539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2540   float jresult ;
2541   floatp *arg1 = (floatp *) 0 ;
2542   float result;
2543
2544   arg1 = (floatp *)jarg1;
2545   {
2546     try {
2547       result = (float)floatp_value(arg1);
2548     } CALL_CATCH_EXCEPTION(0);
2549   }
2550   jresult = result;
2551   return jresult;
2552 }
2553
2554
2555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2556   void * jresult ;
2557   floatp *arg1 = (floatp *) 0 ;
2558   float *result = 0 ;
2559
2560   arg1 = (floatp *)jarg1;
2561   {
2562     try {
2563       result = (float *)floatp_cast(arg1);
2564     } CALL_CATCH_EXCEPTION(0);
2565   }
2566
2567   jresult = (void *)result;
2568   return jresult;
2569 }
2570
2571
2572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2573   void * jresult ;
2574   float *arg1 = (float *) 0 ;
2575   floatp *result = 0 ;
2576
2577   arg1 = (float *)jarg1;
2578   {
2579     try {
2580       result = (floatp *)floatp_frompointer(arg1);
2581     } CALL_CATCH_EXCEPTION(0);
2582   }
2583
2584   jresult = (void *)result;
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2590   void * jresult ;
2591   intp *result = 0 ;
2592
2593   {
2594     try {
2595       result = (intp *)new_intp();
2596     } CALL_CATCH_EXCEPTION(0);
2597   }
2598
2599   jresult = (void *)result;
2600   return jresult;
2601 }
2602
2603
2604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2605   intp *arg1 = (intp *) 0 ;
2606
2607   arg1 = (intp *)jarg1;
2608   {
2609     try {
2610       delete_intp(arg1);
2611     } CALL_CATCH_EXCEPTION();
2612   }
2613
2614 }
2615
2616
2617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2618   intp *arg1 = (intp *) 0 ;
2619   int arg2 ;
2620
2621   arg1 = (intp *)jarg1;
2622   arg2 = (int)jarg2;
2623   {
2624     try {
2625       intp_assign(arg1,arg2);
2626     } CALL_CATCH_EXCEPTION();
2627   }
2628
2629 }
2630
2631
2632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2633   int jresult ;
2634   intp *arg1 = (intp *) 0 ;
2635   int result;
2636
2637   arg1 = (intp *)jarg1;
2638   {
2639     try {
2640       result = (int)intp_value(arg1);
2641     } CALL_CATCH_EXCEPTION(0);
2642   }
2643
2644   jresult = result;
2645   return jresult;
2646 }
2647
2648
2649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2650   void * jresult ;
2651   intp *arg1 = (intp *) 0 ;
2652   int *result = 0 ;
2653
2654   arg1 = (intp *)jarg1;
2655   {
2656     try {
2657       result = (int *)intp_cast(arg1);
2658     } CALL_CATCH_EXCEPTION(0);
2659   }
2660
2661   jresult = (void *)result;
2662   return jresult;
2663 }
2664
2665
2666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2667   void * jresult ;
2668   int *arg1 = (int *) 0 ;
2669   intp *result = 0 ;
2670
2671   arg1 = (int *)jarg1;
2672   {
2673     try {
2674       result = (intp *)intp_frompointer(arg1);
2675     } CALL_CATCH_EXCEPTION(0);
2676   }
2677
2678   jresult = (void *)result;
2679   return jresult;
2680 }
2681
2682
2683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2684   void * jresult ;
2685   doublep *result = 0 ;
2686
2687   {
2688     try {
2689       result = (doublep *)new_doublep();
2690     } CALL_CATCH_EXCEPTION(0);
2691   }
2692
2693   jresult = (void *)result;
2694   return jresult;
2695 }
2696
2697
2698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2699   doublep *arg1 = (doublep *) 0 ;
2700
2701   arg1 = (doublep *)jarg1;
2702   {
2703     try {
2704       delete_doublep(arg1);
2705     } CALL_CATCH_EXCEPTION();
2706   }
2707
2708 }
2709
2710
2711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2712   doublep *arg1 = (doublep *) 0 ;
2713   double arg2 ;
2714
2715   arg1 = (doublep *)jarg1;
2716   arg2 = (double)jarg2;
2717   {
2718     try {
2719       doublep_assign(arg1,arg2);
2720     } CALL_CATCH_EXCEPTION();
2721   }
2722
2723 }
2724
2725
2726 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2727   double jresult ;
2728   doublep *arg1 = (doublep *) 0 ;
2729   double result;
2730
2731   arg1 = (doublep *)jarg1;
2732   {
2733     try {
2734       result = (double)doublep_value(arg1);
2735     } CALL_CATCH_EXCEPTION(0);
2736   }
2737
2738   jresult = result;
2739   return jresult;
2740 }
2741
2742
2743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2744   void * jresult ;
2745   doublep *arg1 = (doublep *) 0 ;
2746   double *result = 0 ;
2747
2748   arg1 = (doublep *)jarg1;
2749   {
2750     try {
2751       result = (double *)doublep_cast(arg1);
2752     } CALL_CATCH_EXCEPTION(0);
2753   }
2754
2755   jresult = (void *)result;
2756   return jresult;
2757 }
2758
2759
2760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2761   void * jresult ;
2762   double *arg1 = (double *) 0 ;
2763   doublep *result = 0 ;
2764
2765   arg1 = (double *)jarg1;
2766   {
2767     try {
2768       result = (doublep *)doublep_frompointer(arg1);
2769     } CALL_CATCH_EXCEPTION(0);
2770   }
2771
2772   jresult = (void *)result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2778   void * jresult ;
2779   uintp *result = 0 ;
2780
2781   {
2782     try {
2783       result = (uintp *)new_uintp();
2784     } CALL_CATCH_EXCEPTION(0);
2785   }
2786
2787   jresult = (void *)result;
2788   return jresult;
2789 }
2790
2791
2792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2793   uintp *arg1 = (uintp *) 0 ;
2794
2795   arg1 = (uintp *)jarg1;
2796   {
2797     try {
2798       delete_uintp(arg1);
2799     } CALL_CATCH_EXCEPTION();
2800   }
2801
2802 }
2803
2804
2805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2806   uintp *arg1 = (uintp *) 0 ;
2807   unsigned int arg2 ;
2808
2809   arg1 = (uintp *)jarg1;
2810   arg2 = (unsigned int)jarg2;
2811   {
2812     try {
2813       uintp_assign(arg1,arg2);
2814     } CALL_CATCH_EXCEPTION();
2815   }
2816
2817 }
2818
2819
2820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2821   unsigned int jresult ;
2822   uintp *arg1 = (uintp *) 0 ;
2823   unsigned int result;
2824
2825   arg1 = (uintp *)jarg1;
2826   {
2827     try {
2828       result = (unsigned int)uintp_value(arg1);
2829     } CALL_CATCH_EXCEPTION(0);
2830   }
2831
2832   jresult = result;
2833   return jresult;
2834 }
2835
2836
2837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2838   void * jresult ;
2839   uintp *arg1 = (uintp *) 0 ;
2840   unsigned int *result = 0 ;
2841
2842   arg1 = (uintp *)jarg1;
2843   {
2844     try {
2845       result = (unsigned int *)uintp_cast(arg1);
2846     } CALL_CATCH_EXCEPTION(0);
2847   }
2848
2849   jresult = (void *)result;
2850   return jresult;
2851 }
2852
2853
2854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2855   void * jresult ;
2856   unsigned int *arg1 = (unsigned int *) 0 ;
2857   uintp *result = 0 ;
2858
2859   arg1 = (unsigned int *)jarg1;
2860   {
2861     try {
2862       result = (uintp *)uintp_frompointer(arg1);
2863     } CALL_CATCH_EXCEPTION(0);
2864   }
2865
2866   jresult = (void *)result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2872   void * jresult ;
2873   ushortp *result = 0 ;
2874
2875   {
2876     try {
2877       result = (ushortp *)new_ushortp();
2878     } CALL_CATCH_EXCEPTION(0);
2879   }
2880
2881   jresult = (void *)result;
2882   return jresult;
2883 }
2884
2885
2886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2887   ushortp *arg1 = (ushortp *) 0 ;
2888
2889   arg1 = (ushortp *)jarg1;
2890   {
2891     try {
2892       delete_ushortp(arg1);
2893     } CALL_CATCH_EXCEPTION();
2894   }
2895
2896 }
2897
2898
2899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2900   ushortp *arg1 = (ushortp *) 0 ;
2901   unsigned short arg2 ;
2902
2903   arg1 = (ushortp *)jarg1;
2904   arg2 = (unsigned short)jarg2;
2905   {
2906     try {
2907       ushortp_assign(arg1,arg2);
2908     } CALL_CATCH_EXCEPTION();
2909   }
2910
2911 }
2912
2913
2914 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2915   unsigned short jresult ;
2916   ushortp *arg1 = (ushortp *) 0 ;
2917   unsigned short result;
2918
2919   arg1 = (ushortp *)jarg1;
2920   {
2921     try {
2922       result = (unsigned short)ushortp_value(arg1);
2923     } CALL_CATCH_EXCEPTION(0);
2924   }
2925
2926   jresult = result;
2927   return jresult;
2928 }
2929
2930
2931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2932   void * jresult ;
2933   ushortp *arg1 = (ushortp *) 0 ;
2934   unsigned short *result = 0 ;
2935
2936   arg1 = (ushortp *)jarg1;
2937   {
2938     try {
2939       result = (unsigned short *)ushortp_cast(arg1);
2940     } CALL_CATCH_EXCEPTION(0);
2941   }
2942
2943   jresult = (void *)result;
2944   return jresult;
2945 }
2946
2947
2948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2949   void * jresult ;
2950   unsigned short *arg1 = (unsigned short *) 0 ;
2951   ushortp *result = 0 ;
2952
2953   arg1 = (unsigned short *)jarg1;
2954   {
2955     try {
2956       result = (ushortp *)ushortp_frompointer(arg1);
2957     } CALL_CATCH_EXCEPTION(0);
2958   }
2959
2960   jresult = (void *)result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2966   unsigned int jresult ;
2967   int arg1 ;
2968   unsigned int result;
2969
2970   arg1 = (int)jarg1;
2971   {
2972     try {
2973       result = (unsigned int)int_to_uint(arg1);
2974     } CALL_CATCH_EXCEPTION(0);
2975   }
2976
2977   jresult = result;
2978   return jresult;
2979 }
2980
2981
2982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2983   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2984
2985   arg1 = (Dali::RefObject *)jarg1;
2986   {
2987     try {
2988       (arg1)->Reference();
2989     } CALL_CATCH_EXCEPTION();
2990   }
2991
2992 }
2993
2994
2995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2996   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2997
2998   arg1 = (Dali::RefObject *)jarg1;
2999   {
3000     try {
3001       (arg1)->Unreference();
3002     } CALL_CATCH_EXCEPTION();
3003   }
3004
3005 }
3006
3007
3008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3009   int jresult ;
3010   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3011   int result;
3012
3013   arg1 = (Dali::RefObject *)jarg1;
3014   {
3015     try {
3016       result = (int)(arg1)->ReferenceCount();
3017     } CALL_CATCH_EXCEPTION(0);
3018   }
3019
3020   jresult = result;
3021   return jresult;
3022 }
3023
3024
3025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3026   void * jresult ;
3027   Dali::Any *result = 0 ;
3028
3029   {
3030     try {
3031       result = (Dali::Any *)new Dali::Any();
3032     } CALL_CATCH_EXCEPTION(0);
3033   }
3034
3035   jresult = (void *)result;
3036   return jresult;
3037 }
3038
3039
3040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3041   Dali::Any *arg1 = (Dali::Any *) 0 ;
3042
3043   arg1 = (Dali::Any *)jarg1;
3044   {
3045     try {
3046       delete arg1;
3047     } CALL_CATCH_EXCEPTION();
3048   }
3049
3050 }
3051
3052
3053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3054   char *arg1 = (char *) 0 ;
3055
3056   arg1 = (char *)jarg1;
3057   {
3058     try {
3059       Dali::Any::AssertAlways((char const *)arg1);
3060     } CALL_CATCH_EXCEPTION();
3061   }
3062
3063 }
3064
3065
3066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3067   void * jresult ;
3068   Dali::Any *arg1 = 0 ;
3069   Dali::Any *result = 0 ;
3070
3071   arg1 = (Dali::Any *)jarg1;
3072   if (!arg1) {
3073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3074     return 0;
3075   }
3076   {
3077     try {
3078       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3079     } CALL_CATCH_EXCEPTION(0);
3080   }
3081
3082   jresult = (void *)result;
3083   return jresult;
3084 }
3085
3086
3087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3088   void * jresult ;
3089   Dali::Any *arg1 = (Dali::Any *) 0 ;
3090   Dali::Any *arg2 = 0 ;
3091   Dali::Any *result = 0 ;
3092
3093   arg1 = (Dali::Any *)jarg1;
3094   arg2 = (Dali::Any *)jarg2;
3095   if (!arg2) {
3096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3097     return 0;
3098   }
3099   {
3100     try {
3101       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3102     } CALL_CATCH_EXCEPTION(0);
3103   }
3104
3105   jresult = (void *)result;
3106   return jresult;
3107 }
3108
3109
3110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3111   void * jresult ;
3112   Dali::Any *arg1 = (Dali::Any *) 0 ;
3113   std::type_info *result = 0 ;
3114
3115   arg1 = (Dali::Any *)jarg1;
3116   {
3117     try {
3118       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3119     } CALL_CATCH_EXCEPTION(0);
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3128   unsigned int jresult ;
3129   Dali::Any *arg1 = (Dali::Any *) 0 ;
3130   bool result;
3131
3132   arg1 = (Dali::Any *)jarg1;
3133   {
3134     try {
3135       result = (bool)((Dali::Any const *)arg1)->Empty();
3136     } CALL_CATCH_EXCEPTION(0);
3137   }
3138
3139   jresult = result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3145   void * jresult ;
3146   std::type_info *arg1 = 0 ;
3147   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3148   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3149   Dali::Any::AnyContainerBase *result = 0 ;
3150
3151   arg1 = (std::type_info *)jarg1;
3152   if (!arg1) {
3153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3154     return 0;
3155   }
3156   arg2 = (Dali::Any::CloneFunc)jarg2;
3157   arg3 = (Dali::Any::DeleteFunc)jarg3;
3158   {
3159     try {
3160       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3161     } CALL_CATCH_EXCEPTION(0);
3162   }
3163
3164   jresult = (void *)result;
3165   return jresult;
3166 }
3167
3168
3169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3170   void * jresult ;
3171   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3172   std::type_info *result = 0 ;
3173
3174   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3175   {
3176     try {
3177       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3178     } CALL_CATCH_EXCEPTION(0);
3179   }
3180
3181   jresult = (void *)result;
3182   return jresult;
3183 }
3184
3185
3186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3187   void * jresult ;
3188   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3189   ::std::type_info *result = 0 ;
3190
3191   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3192   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3193   jresult = (void *)result;
3194   return jresult;
3195 }
3196
3197
3198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3199   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3200   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3201
3202   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3203   arg2 = (Dali::Any::CloneFunc)jarg2;
3204   if (arg1) (arg1)->mCloneFunc = arg2;
3205 }
3206
3207
3208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3209   void * jresult ;
3210   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3211   Dali::Any::CloneFunc result;
3212
3213   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3214   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3215   jresult = (void *)result;
3216   return jresult;
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3221   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3222   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3223
3224   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3225   arg2 = (Dali::Any::DeleteFunc)jarg2;
3226   if (arg1) (arg1)->mDeleteFunc = arg2;
3227 }
3228
3229
3230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3231   void * jresult ;
3232   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3233   Dali::Any::DeleteFunc result;
3234
3235   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3236   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3237   jresult = (void *)result;
3238   return jresult;
3239 }
3240
3241
3242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3243   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3244
3245   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3246   {
3247     try {
3248       delete arg1;
3249     } CALL_CATCH_EXCEPTION();
3250   }
3251
3252 }
3253
3254
3255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3256   Dali::Any *arg1 = (Dali::Any *) 0 ;
3257   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3258
3259   arg1 = (Dali::Any *)jarg1;
3260   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3261   if (arg1) (arg1)->mContainer = arg2;
3262 }
3263
3264
3265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3266   void * jresult ;
3267   Dali::Any *arg1 = (Dali::Any *) 0 ;
3268   Dali::Any::AnyContainerBase *result = 0 ;
3269
3270   arg1 = (Dali::Any *)jarg1;
3271   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3272   jresult = (void *)result;
3273   return jresult;
3274 }
3275
3276
3277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3278   char *arg1 = (char *) 0 ;
3279   char *arg2 = (char *) 0 ;
3280
3281   arg1 = (char *)jarg1;
3282   arg2 = (char *)jarg2;
3283   {
3284     try {
3285       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3286     } CALL_CATCH_EXCEPTION();
3287   }
3288
3289 }
3290
3291
3292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3293   void * jresult ;
3294   char *arg1 = (char *) 0 ;
3295   char *arg2 = (char *) 0 ;
3296   Dali::DaliException *result = 0 ;
3297
3298   arg1 = (char *)jarg1;
3299   arg2 = (char *)jarg2;
3300   {
3301     try {
3302       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3303     } CALL_CATCH_EXCEPTION(0);
3304   }
3305
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3312   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3313   std::string arg2 = std::string(jarg2);
3314
3315   arg1 = (Dali::DaliException *)jarg1;
3316   {
3317     if (!arg2.empty()) {
3318       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3319     } else {
3320       arg1->location = 0;
3321     }
3322   }
3323 }
3324
3325 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3326   char * jresult ;
3327   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3328   char *result = 0 ;
3329
3330   arg1 = (Dali::DaliException *)jarg1;
3331   result = (char *) ((arg1)->location);
3332   jresult = SWIG_csharp_string_callback((const char *)result);
3333   return jresult;
3334 }
3335
3336
3337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3338   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3339   std::string arg2 = std::string(jarg2);
3340
3341   arg1 = (Dali::DaliException *)jarg1;
3342   {
3343     if (!arg2.empty()) {
3344       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3345     } else {
3346       arg1->condition = 0;
3347     }
3348   }
3349 }
3350
3351
3352 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3353   char * jresult ;
3354   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3355   char *result = 0 ;
3356
3357   arg1 = (Dali::DaliException *)jarg1;
3358   result = (char *) ((arg1)->condition);
3359   jresult = SWIG_csharp_string_callback((const char *)result);
3360   return jresult;
3361 }
3362
3363
3364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3365   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3366
3367   arg1 = (Dali::DaliException *)jarg1;
3368   {
3369     try {
3370       delete arg1;
3371     } CALL_CATCH_EXCEPTION();
3372   }
3373
3374 }
3375
3376
3377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3378   void * jresult ;
3379   Dali::Vector2 *result = 0 ;
3380
3381   {
3382     try {
3383       result = (Dali::Vector2 *)new Dali::Vector2();
3384     } CALL_CATCH_EXCEPTION(0);
3385   }
3386
3387   jresult = (void *)result;
3388   return jresult;
3389 }
3390
3391
3392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3393   void * jresult ;
3394   float arg1 ;
3395   float arg2 ;
3396   Dali::Vector2 *result = 0 ;
3397
3398   arg1 = (float)jarg1;
3399   arg2 = (float)jarg2;
3400   {
3401     try {
3402       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3403     } CALL_CATCH_EXCEPTION(0);
3404   }
3405
3406   jresult = (void *)result;
3407   return jresult;
3408 }
3409
3410
3411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3412   void * jresult ;
3413   float *arg1 = (float *) 0 ;
3414   Dali::Vector2 *result = 0 ;
3415
3416   arg1 = jarg1;
3417   {
3418     try {
3419       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3420     } CALL_CATCH_EXCEPTION(0);
3421   }
3422
3423   jresult = (void *)result;
3424
3425
3426   return jresult;
3427 }
3428
3429
3430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3431   void * jresult ;
3432   Dali::Vector3 *arg1 = 0 ;
3433   Dali::Vector2 *result = 0 ;
3434
3435   arg1 = (Dali::Vector3 *)jarg1;
3436   if (!arg1) {
3437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3438     return 0;
3439   }
3440   {
3441     try {
3442       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3443     } CALL_CATCH_EXCEPTION(0);
3444   }
3445
3446   jresult = (void *)result;
3447   return jresult;
3448 }
3449
3450
3451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3452   void * jresult ;
3453   Dali::Vector4 *arg1 = 0 ;
3454   Dali::Vector2 *result = 0 ;
3455
3456   arg1 = (Dali::Vector4 *)jarg1;
3457   if (!arg1) {
3458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3459     return 0;
3460   }
3461   {
3462     try {
3463       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3464     } CALL_CATCH_EXCEPTION(0);
3465   }
3466
3467   jresult = (void *)result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3473   void * jresult ;
3474   Dali::Vector2 *result = 0 ;
3475
3476   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3477   jresult = (void *)result;
3478   return jresult;
3479 }
3480
3481
3482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3483   void * jresult ;
3484   Dali::Vector2 *result = 0 ;
3485
3486   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3487   jresult = (void *)result;
3488   return jresult;
3489 }
3490
3491
3492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3493   void * jresult ;
3494   Dali::Vector2 *result = 0 ;
3495
3496   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3497   jresult = (void *)result;
3498   return jresult;
3499 }
3500
3501
3502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3503   void * jresult ;
3504   Dali::Vector2 *result = 0 ;
3505
3506   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3507   jresult = (void *)result;
3508   return jresult;
3509 }
3510
3511
3512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3513   void * jresult ;
3514   Dali::Vector2 *result = 0 ;
3515
3516   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3517   jresult = (void *)result;
3518   return jresult;
3519 }
3520
3521
3522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3523   void * jresult ;
3524   Dali::Vector2 *result = 0 ;
3525
3526   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3533   void * jresult ;
3534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3535   float *arg2 = (float *) 0 ;
3536   Dali::Vector2 *result = 0 ;
3537
3538   arg1 = (Dali::Vector2 *)jarg1;
3539   arg2 = jarg2;
3540   {
3541     try {
3542       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3543     } CALL_CATCH_EXCEPTION(0);
3544   }
3545
3546   jresult = (void *)result;
3547
3548
3549   return jresult;
3550 }
3551
3552
3553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3554   void * jresult ;
3555   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3556   Dali::Vector3 *arg2 = 0 ;
3557   Dali::Vector2 *result = 0 ;
3558
3559   arg1 = (Dali::Vector2 *)jarg1;
3560   arg2 = (Dali::Vector3 *)jarg2;
3561   if (!arg2) {
3562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3563     return 0;
3564   }
3565   {
3566     try {
3567       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3568     } CALL_CATCH_EXCEPTION(0);
3569   }
3570
3571   jresult = (void *)result;
3572   return jresult;
3573 }
3574
3575
3576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3577   void * jresult ;
3578   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3579   Dali::Vector4 *arg2 = 0 ;
3580   Dali::Vector2 *result = 0 ;
3581
3582   arg1 = (Dali::Vector2 *)jarg1;
3583   arg2 = (Dali::Vector4 *)jarg2;
3584   if (!arg2) {
3585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3586     return 0;
3587   }
3588   {
3589     try {
3590       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3591     } CALL_CATCH_EXCEPTION(0);
3592   }
3593
3594   jresult = (void *)result;
3595   return jresult;
3596 }
3597
3598
3599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3600   void * jresult ;
3601   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3602   Dali::Vector2 *arg2 = 0 ;
3603   Dali::Vector2 result;
3604
3605   arg1 = (Dali::Vector2 *)jarg1;
3606   arg2 = (Dali::Vector2 *)jarg2;
3607   if (!arg2) {
3608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3609     return 0;
3610   }
3611   {
3612     try {
3613       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3614     } CALL_CATCH_EXCEPTION(0);
3615   }
3616
3617   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3618   return jresult;
3619 }
3620
3621
3622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3623   void * jresult ;
3624   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3625   Dali::Vector2 *arg2 = 0 ;
3626   Dali::Vector2 *result = 0 ;
3627
3628   arg1 = (Dali::Vector2 *)jarg1;
3629   arg2 = (Dali::Vector2 *)jarg2;
3630   if (!arg2) {
3631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3632     return 0;
3633   }
3634   {
3635     try {
3636       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3637     } CALL_CATCH_EXCEPTION(0);
3638   }
3639
3640   jresult = (void *)result;
3641   return jresult;
3642 }
3643
3644
3645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3646   void * jresult ;
3647   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3648   Dali::Vector2 *arg2 = 0 ;
3649   Dali::Vector2 result;
3650
3651   arg1 = (Dali::Vector2 *)jarg1;
3652   arg2 = (Dali::Vector2 *)jarg2;
3653   if (!arg2) {
3654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3655     return 0;
3656   }
3657   {
3658     try {
3659       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3660     } CALL_CATCH_EXCEPTION(0);
3661   }
3662
3663   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3664   return jresult;
3665 }
3666
3667
3668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3669   void * jresult ;
3670   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3671   Dali::Vector2 *arg2 = 0 ;
3672   Dali::Vector2 *result = 0 ;
3673
3674   arg1 = (Dali::Vector2 *)jarg1;
3675   arg2 = (Dali::Vector2 *)jarg2;
3676   if (!arg2) {
3677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3678     return 0;
3679   }
3680   {
3681     try {
3682       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3683     } CALL_CATCH_EXCEPTION(0);
3684   }
3685
3686   jresult = (void *)result;
3687   return jresult;
3688 }
3689
3690
3691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3692   void * jresult ;
3693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3694   Dali::Vector2 *arg2 = 0 ;
3695   Dali::Vector2 result;
3696
3697   arg1 = (Dali::Vector2 *)jarg1;
3698   arg2 = (Dali::Vector2 *)jarg2;
3699   if (!arg2) {
3700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3701     return 0;
3702   }
3703   {
3704     try {
3705       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3706     } CALL_CATCH_EXCEPTION(0);
3707   }
3708
3709   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3710   return jresult;
3711 }
3712
3713
3714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3715   void * jresult ;
3716   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3717   float arg2 ;
3718   Dali::Vector2 result;
3719
3720   arg1 = (Dali::Vector2 *)jarg1;
3721   arg2 = (float)jarg2;
3722   {
3723     try {
3724       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3725     } CALL_CATCH_EXCEPTION(0);
3726   }
3727
3728   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3729   return jresult;
3730 }
3731
3732
3733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3734   void * jresult ;
3735   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3736   Dali::Vector2 *arg2 = 0 ;
3737   Dali::Vector2 *result = 0 ;
3738
3739   arg1 = (Dali::Vector2 *)jarg1;
3740   arg2 = (Dali::Vector2 *)jarg2;
3741   if (!arg2) {
3742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3743     return 0;
3744   }
3745   {
3746     try {
3747       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3748     } CALL_CATCH_EXCEPTION(0);
3749   }
3750
3751   jresult = (void *)result;
3752   return jresult;
3753 }
3754
3755
3756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3757   void * jresult ;
3758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3759   float arg2 ;
3760   Dali::Vector2 *result = 0 ;
3761
3762   arg1 = (Dali::Vector2 *)jarg1;
3763   arg2 = (float)jarg2;
3764   {
3765     try {
3766       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3767     } CALL_CATCH_EXCEPTION(0);
3768   }
3769
3770   jresult = (void *)result;
3771   return jresult;
3772 }
3773
3774
3775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3776   void * jresult ;
3777   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3778   Dali::Vector2 *arg2 = 0 ;
3779   Dali::Vector2 result;
3780
3781   arg1 = (Dali::Vector2 *)jarg1;
3782   arg2 = (Dali::Vector2 *)jarg2;
3783   if (!arg2) {
3784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3785     return 0;
3786   }
3787   {
3788     try {
3789       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3790     } CALL_CATCH_EXCEPTION(0);
3791   }
3792
3793   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3794   return jresult;
3795 }
3796
3797
3798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3799   void * jresult ;
3800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3801   float arg2 ;
3802   Dali::Vector2 result;
3803
3804   arg1 = (Dali::Vector2 *)jarg1;
3805   arg2 = (float)jarg2;
3806   {
3807     try {
3808       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3809     } CALL_CATCH_EXCEPTION(0);
3810   }
3811
3812   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3813   return jresult;
3814 }
3815
3816
3817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3818   void * jresult ;
3819   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3820   Dali::Vector2 *arg2 = 0 ;
3821   Dali::Vector2 *result = 0 ;
3822
3823   arg1 = (Dali::Vector2 *)jarg1;
3824   arg2 = (Dali::Vector2 *)jarg2;
3825   if (!arg2) {
3826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3827     return 0;
3828   }
3829   {
3830     try {
3831       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3832     } CALL_CATCH_EXCEPTION(0);
3833   }
3834
3835   jresult = (void *)result;
3836   return jresult;
3837 }
3838
3839
3840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3841   void * jresult ;
3842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3843   float arg2 ;
3844   Dali::Vector2 *result = 0 ;
3845
3846   arg1 = (Dali::Vector2 *)jarg1;
3847   arg2 = (float)jarg2;
3848   {
3849     try {
3850       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3851     } CALL_CATCH_EXCEPTION(0);
3852   }
3853
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3860   void * jresult ;
3861   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3862   Dali::Vector2 result;
3863
3864   arg1 = (Dali::Vector2 *)jarg1;
3865   {
3866     try {
3867       result = ((Dali::Vector2 const *)arg1)->operator -();
3868     } CALL_CATCH_EXCEPTION(0);
3869   }
3870
3871   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3872   return jresult;
3873 }
3874
3875
3876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3877   unsigned int jresult ;
3878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3879   Dali::Vector2 *arg2 = 0 ;
3880   bool result;
3881
3882   arg1 = (Dali::Vector2 *)jarg1;
3883   arg2 = (Dali::Vector2 *)jarg2;
3884   if (!arg2) {
3885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3886     return 0;
3887   }
3888   {
3889     try {
3890       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3891     } CALL_CATCH_EXCEPTION(0);
3892   }
3893
3894   jresult = result;
3895   return jresult;
3896 }
3897
3898
3899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3900   unsigned int jresult ;
3901   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3902   Dali::Vector2 *arg2 = 0 ;
3903   bool result;
3904
3905   arg1 = (Dali::Vector2 *)jarg1;
3906   arg2 = (Dali::Vector2 *)jarg2;
3907   if (!arg2) {
3908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3909     return 0;
3910   }
3911   {
3912     try {
3913       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3914     } CALL_CATCH_EXCEPTION(0);
3915   }
3916
3917   jresult = result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3923   float jresult ;
3924   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3925   unsigned int arg2 ;
3926   float *result = 0 ;
3927
3928   arg1 = (Dali::Vector2 *)jarg1;
3929   arg2 = (unsigned int)jarg2;
3930   {
3931     try {
3932       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3933     } CALL_CATCH_EXCEPTION(0);
3934   }
3935
3936   jresult = *result;
3937   return jresult;
3938 }
3939
3940
3941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3942   float jresult ;
3943   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3944   float result;
3945
3946   arg1 = (Dali::Vector2 *)jarg1;
3947   {
3948     try {
3949       result = (float)((Dali::Vector2 const *)arg1)->Length();
3950     } CALL_CATCH_EXCEPTION(0);
3951   }
3952
3953   jresult = result;
3954   return jresult;
3955 }
3956
3957
3958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3959   float jresult ;
3960   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3961   float result;
3962
3963   arg1 = (Dali::Vector2 *)jarg1;
3964   {
3965     try {
3966       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3967     } CALL_CATCH_EXCEPTION(0);
3968   }
3969
3970   jresult = result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3976   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3977
3978   arg1 = (Dali::Vector2 *)jarg1;
3979   {
3980     try {
3981       (arg1)->Normalize();
3982     } CALL_CATCH_EXCEPTION();
3983   }
3984
3985 }
3986
3987
3988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3989   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3990   Dali::Vector2 *arg2 = 0 ;
3991   Dali::Vector2 *arg3 = 0 ;
3992
3993   arg1 = (Dali::Vector2 *)jarg1;
3994   arg2 = (Dali::Vector2 *)jarg2;
3995   if (!arg2) {
3996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3997     return ;
3998   }
3999   arg3 = (Dali::Vector2 *)jarg3;
4000   if (!arg3) {
4001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4002     return ;
4003   }
4004   {
4005     try {
4006       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4007     } CALL_CATCH_EXCEPTION();
4008   }
4009
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4014   void * jresult ;
4015   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4016   float *result = 0 ;
4017
4018   arg1 = (Dali::Vector2 *)jarg1;
4019   {
4020     try {
4021       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4022     } CALL_CATCH_EXCEPTION(0);
4023   }
4024
4025   jresult = (void *)result;
4026   return jresult;
4027 }
4028
4029
4030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4031   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4032   float arg2 ;
4033
4034   arg1 = (Dali::Vector2 *)jarg1;
4035   arg2 = (float)jarg2;
4036   if (arg1) (arg1)->x = arg2;
4037 }
4038
4039
4040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4041   float jresult ;
4042   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4043   float result;
4044
4045   arg1 = (Dali::Vector2 *)jarg1;
4046   result = (float) ((arg1)->x);
4047   jresult = result;
4048   return jresult;
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4053   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4054   float arg2 ;
4055
4056   arg1 = (Dali::Vector2 *)jarg1;
4057   arg2 = (float)jarg2;
4058   if (arg1) (arg1)->width = arg2;
4059 }
4060
4061
4062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4063   float jresult ;
4064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4065   float result;
4066
4067   arg1 = (Dali::Vector2 *)jarg1;
4068   result = (float) ((arg1)->width);
4069   jresult = result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4075   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4076   float arg2 ;
4077
4078   arg1 = (Dali::Vector2 *)jarg1;
4079   arg2 = (float)jarg2;
4080   if (arg1) (arg1)->y = arg2;
4081 }
4082
4083
4084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4085   float jresult ;
4086   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4087   float result;
4088
4089   arg1 = (Dali::Vector2 *)jarg1;
4090   result = (float) ((arg1)->y);
4091   jresult = result;
4092   return jresult;
4093 }
4094
4095
4096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4098   float arg2 ;
4099
4100   arg1 = (Dali::Vector2 *)jarg1;
4101   arg2 = (float)jarg2;
4102   if (arg1) (arg1)->height = arg2;
4103 }
4104
4105
4106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4107   float jresult ;
4108   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4109   float result;
4110
4111   arg1 = (Dali::Vector2 *)jarg1;
4112   result = (float) ((arg1)->height);
4113   jresult = result;
4114   return jresult;
4115 }
4116
4117
4118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4119   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4120
4121   arg1 = (Dali::Vector2 *)jarg1;
4122   {
4123     try {
4124       delete arg1;
4125     } CALL_CATCH_EXCEPTION();
4126   }
4127
4128 }
4129
4130
4131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4132   void * jresult ;
4133   Dali::Vector2 *arg1 = 0 ;
4134   Dali::Vector2 *arg2 = 0 ;
4135   Dali::Vector2 result;
4136
4137   arg1 = (Dali::Vector2 *)jarg1;
4138   if (!arg1) {
4139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4140     return 0;
4141   }
4142   arg2 = (Dali::Vector2 *)jarg2;
4143   if (!arg2) {
4144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4145     return 0;
4146   }
4147   {
4148     try {
4149       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4150     } CALL_CATCH_EXCEPTION(0);
4151   }
4152
4153   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4154   return jresult;
4155 }
4156
4157
4158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4159   void * jresult ;
4160   Dali::Vector2 *arg1 = 0 ;
4161   Dali::Vector2 *arg2 = 0 ;
4162   Dali::Vector2 result;
4163
4164   arg1 = (Dali::Vector2 *)jarg1;
4165   if (!arg1) {
4166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4167     return 0;
4168   }
4169   arg2 = (Dali::Vector2 *)jarg2;
4170   if (!arg2) {
4171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4172     return 0;
4173   }
4174   {
4175     try {
4176       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4177     } CALL_CATCH_EXCEPTION(0);
4178   }
4179
4180   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4181   return jresult;
4182 }
4183
4184
4185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4186   void * jresult ;
4187   Dali::Vector2 *arg1 = 0 ;
4188   float *arg2 = 0 ;
4189   float *arg3 = 0 ;
4190   float temp2 ;
4191   float temp3 ;
4192   Dali::Vector2 result;
4193
4194   arg1 = (Dali::Vector2 *)jarg1;
4195   if (!arg1) {
4196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4197     return 0;
4198   }
4199   temp2 = (float)jarg2;
4200   arg2 = &temp2;
4201   temp3 = (float)jarg3;
4202   arg3 = &temp3;
4203   {
4204     try {
4205       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4206     } CALL_CATCH_EXCEPTION(0);
4207   }
4208
4209   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4210   return jresult;
4211 }
4212
4213
4214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4215   void * jresult ;
4216   Dali::Vector3 *result = 0 ;
4217
4218   {
4219     try {
4220       result = (Dali::Vector3 *)new Dali::Vector3();
4221     } CALL_CATCH_EXCEPTION(0);
4222   }
4223
4224   jresult = (void *)result;
4225   return jresult;
4226 }
4227
4228
4229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4230   void * jresult ;
4231   float arg1 ;
4232   float arg2 ;
4233   float arg3 ;
4234   Dali::Vector3 *result = 0 ;
4235
4236   arg1 = (float)jarg1;
4237   arg2 = (float)jarg2;
4238   arg3 = (float)jarg3;
4239   {
4240     try {
4241       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4242     } CALL_CATCH_EXCEPTION(0);
4243   }
4244
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4251   void * jresult ;
4252   float *arg1 = (float *) 0 ;
4253   Dali::Vector3 *result = 0 ;
4254
4255   arg1 = jarg1;
4256   {
4257     try {
4258       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4259     } CALL_CATCH_EXCEPTION(0);
4260   }
4261
4262   jresult = (void *)result;
4263
4264
4265   return jresult;
4266 }
4267
4268
4269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4270   void * jresult ;
4271   Dali::Vector2 *arg1 = 0 ;
4272   Dali::Vector3 *result = 0 ;
4273
4274   arg1 = (Dali::Vector2 *)jarg1;
4275   if (!arg1) {
4276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4277     return 0;
4278   }
4279   {
4280     try {
4281       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4282     } CALL_CATCH_EXCEPTION(0);
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4291   void * jresult ;
4292   Dali::Vector4 *arg1 = 0 ;
4293   Dali::Vector3 *result = 0 ;
4294
4295   arg1 = (Dali::Vector4 *)jarg1;
4296   if (!arg1) {
4297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4298     return 0;
4299   }
4300   {
4301     try {
4302       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4303     } CALL_CATCH_EXCEPTION(0);
4304   }
4305
4306   jresult = (void *)result;
4307   return jresult;
4308 }
4309
4310
4311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4312   void * jresult ;
4313   Dali::Vector3 *result = 0 ;
4314
4315   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4316   jresult = (void *)result;
4317   return jresult;
4318 }
4319
4320
4321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4322   void * jresult ;
4323   Dali::Vector3 *result = 0 ;
4324
4325   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4332   void * jresult ;
4333   Dali::Vector3 *result = 0 ;
4334
4335   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4336   jresult = (void *)result;
4337   return jresult;
4338 }
4339
4340
4341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4342   void * jresult ;
4343   Dali::Vector3 *result = 0 ;
4344
4345   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4346   jresult = (void *)result;
4347   return jresult;
4348 }
4349
4350
4351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4352   void * jresult ;
4353   Dali::Vector3 *result = 0 ;
4354
4355   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4356   jresult = (void *)result;
4357   return jresult;
4358 }
4359
4360
4361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4362   void * jresult ;
4363   Dali::Vector3 *result = 0 ;
4364
4365   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4366   jresult = (void *)result;
4367   return jresult;
4368 }
4369
4370
4371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4372   void * jresult ;
4373   Dali::Vector3 *result = 0 ;
4374
4375   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4376   jresult = (void *)result;
4377   return jresult;
4378 }
4379
4380
4381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4382   void * jresult ;
4383   Dali::Vector3 *result = 0 ;
4384
4385   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4386   jresult = (void *)result;
4387   return jresult;
4388 }
4389
4390
4391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4392   void * jresult ;
4393   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4394   float *arg2 = (float *) 0 ;
4395   Dali::Vector3 *result = 0 ;
4396
4397   arg1 = (Dali::Vector3 *)jarg1;
4398   arg2 = jarg2;
4399   {
4400     try {
4401       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4402     } CALL_CATCH_EXCEPTION(0);
4403   }
4404
4405   jresult = (void *)result;
4406
4407
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4413   void * jresult ;
4414   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4415   Dali::Vector2 *arg2 = 0 ;
4416   Dali::Vector3 *result = 0 ;
4417
4418   arg1 = (Dali::Vector3 *)jarg1;
4419   arg2 = (Dali::Vector2 *)jarg2;
4420   if (!arg2) {
4421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4422     return 0;
4423   }
4424   {
4425     try {
4426       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4427     } CALL_CATCH_EXCEPTION(0);
4428   }
4429
4430   jresult = (void *)result;
4431   return jresult;
4432 }
4433
4434
4435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4436   void * jresult ;
4437   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4438   Dali::Vector4 *arg2 = 0 ;
4439   Dali::Vector3 *result = 0 ;
4440
4441   arg1 = (Dali::Vector3 *)jarg1;
4442   arg2 = (Dali::Vector4 *)jarg2;
4443   if (!arg2) {
4444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4445     return 0;
4446   }
4447   {
4448     try {
4449       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4450     } CALL_CATCH_EXCEPTION(0);
4451   }
4452
4453   jresult = (void *)result;
4454   return jresult;
4455 }
4456
4457
4458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4459   void * jresult ;
4460   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4461   Dali::Vector3 *arg2 = 0 ;
4462   Dali::Vector3 result;
4463
4464   arg1 = (Dali::Vector3 *)jarg1;
4465   arg2 = (Dali::Vector3 *)jarg2;
4466   if (!arg2) {
4467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4468     return 0;
4469   }
4470   {
4471     try {
4472       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4473     } CALL_CATCH_EXCEPTION(0);
4474   }
4475
4476   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4477   return jresult;
4478 }
4479
4480
4481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4482   void * jresult ;
4483   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4484   Dali::Vector3 *arg2 = 0 ;
4485   Dali::Vector3 *result = 0 ;
4486
4487   arg1 = (Dali::Vector3 *)jarg1;
4488   arg2 = (Dali::Vector3 *)jarg2;
4489   if (!arg2) {
4490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4491     return 0;
4492   }
4493   {
4494     try {
4495       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4496     } CALL_CATCH_EXCEPTION(0);
4497   }
4498
4499   jresult = (void *)result;
4500   return jresult;
4501 }
4502
4503
4504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4505   void * jresult ;
4506   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4507   Dali::Vector3 *arg2 = 0 ;
4508   Dali::Vector3 result;
4509
4510   arg1 = (Dali::Vector3 *)jarg1;
4511   arg2 = (Dali::Vector3 *)jarg2;
4512   if (!arg2) {
4513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4514     return 0;
4515   }
4516   {
4517     try {
4518       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4519     } CALL_CATCH_EXCEPTION(0);
4520   }
4521
4522   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4523   return jresult;
4524 }
4525
4526
4527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4528   void * jresult ;
4529   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4530   Dali::Vector3 *arg2 = 0 ;
4531   Dali::Vector3 *result = 0 ;
4532
4533   arg1 = (Dali::Vector3 *)jarg1;
4534   arg2 = (Dali::Vector3 *)jarg2;
4535   if (!arg2) {
4536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4537     return 0;
4538   }
4539   {
4540     try {
4541       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4542     } CALL_CATCH_EXCEPTION(0);
4543   }
4544
4545   jresult = (void *)result;
4546   return jresult;
4547 }
4548
4549
4550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4551   void * jresult ;
4552   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4553   Dali::Vector3 *arg2 = 0 ;
4554   Dali::Vector3 result;
4555
4556   arg1 = (Dali::Vector3 *)jarg1;
4557   arg2 = (Dali::Vector3 *)jarg2;
4558   if (!arg2) {
4559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4560     return 0;
4561   }
4562   {
4563     try {
4564       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4565     } CALL_CATCH_EXCEPTION(0);
4566   }
4567
4568   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4569   return jresult;
4570 }
4571
4572
4573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4574   void * jresult ;
4575   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4576   float arg2 ;
4577   Dali::Vector3 result;
4578
4579   arg1 = (Dali::Vector3 *)jarg1;
4580   arg2 = (float)jarg2;
4581   {
4582     try {
4583       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4584     } CALL_CATCH_EXCEPTION(0);
4585   }
4586
4587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4588   return jresult;
4589 }
4590
4591
4592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4593   void * jresult ;
4594   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4595   Dali::Vector3 *arg2 = 0 ;
4596   Dali::Vector3 *result = 0 ;
4597
4598   arg1 = (Dali::Vector3 *)jarg1;
4599   arg2 = (Dali::Vector3 *)jarg2;
4600   if (!arg2) {
4601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4602     return 0;
4603   }
4604   {
4605     try {
4606       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4607     } CALL_CATCH_EXCEPTION(0);
4608   }
4609
4610   jresult = (void *)result;
4611   return jresult;
4612 }
4613
4614
4615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4616   void * jresult ;
4617   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4618   float arg2 ;
4619   Dali::Vector3 *result = 0 ;
4620
4621   arg1 = (Dali::Vector3 *)jarg1;
4622   arg2 = (float)jarg2;
4623   {
4624     try {
4625       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4626     } CALL_CATCH_EXCEPTION(0);
4627   }
4628
4629   jresult = (void *)result;
4630   return jresult;
4631 }
4632
4633
4634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4635   void * jresult ;
4636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4637   Dali::Quaternion *arg2 = 0 ;
4638   Dali::Vector3 *result = 0 ;
4639
4640   arg1 = (Dali::Vector3 *)jarg1;
4641   arg2 = (Dali::Quaternion *)jarg2;
4642   if (!arg2) {
4643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4644     return 0;
4645   }
4646   {
4647     try {
4648       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4649     } CALL_CATCH_EXCEPTION(0);
4650   }
4651
4652   jresult = (void *)result;
4653   return jresult;
4654 }
4655
4656
4657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4658   void * jresult ;
4659   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4660   Dali::Vector3 *arg2 = 0 ;
4661   Dali::Vector3 result;
4662
4663   arg1 = (Dali::Vector3 *)jarg1;
4664   arg2 = (Dali::Vector3 *)jarg2;
4665   if (!arg2) {
4666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4667     return 0;
4668   }
4669   {
4670     try {
4671       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4672     } CALL_CATCH_EXCEPTION(0);
4673   }
4674
4675   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4676   return jresult;
4677 }
4678
4679
4680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4681   void * jresult ;
4682   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4683   float arg2 ;
4684   Dali::Vector3 result;
4685
4686   arg1 = (Dali::Vector3 *)jarg1;
4687   arg2 = (float)jarg2;
4688   {
4689     try {
4690       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4691     } CALL_CATCH_EXCEPTION(0);
4692   }
4693
4694   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4695   return jresult;
4696 }
4697
4698
4699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4700   void * jresult ;
4701   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4702   Dali::Vector3 *arg2 = 0 ;
4703   Dali::Vector3 *result = 0 ;
4704
4705   arg1 = (Dali::Vector3 *)jarg1;
4706   arg2 = (Dali::Vector3 *)jarg2;
4707   if (!arg2) {
4708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4709     return 0;
4710   }
4711   {
4712     try {
4713       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4714     } CALL_CATCH_EXCEPTION(0);
4715   }
4716
4717   jresult = (void *)result;
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4723   void * jresult ;
4724   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4725   float arg2 ;
4726   Dali::Vector3 *result = 0 ;
4727
4728   arg1 = (Dali::Vector3 *)jarg1;
4729   arg2 = (float)jarg2;
4730   {
4731     try {
4732       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4733     } CALL_CATCH_EXCEPTION(0);
4734   }
4735
4736   jresult = (void *)result;
4737   return jresult;
4738 }
4739
4740
4741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4742   void * jresult ;
4743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4744   Dali::Vector3 result;
4745
4746   arg1 = (Dali::Vector3 *)jarg1;
4747   {
4748     try {
4749       result = ((Dali::Vector3 const *)arg1)->operator -();
4750     } CALL_CATCH_EXCEPTION(0);
4751   }
4752
4753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4754   return jresult;
4755 }
4756
4757
4758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4759   unsigned int jresult ;
4760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4761   Dali::Vector3 *arg2 = 0 ;
4762   bool result;
4763
4764   arg1 = (Dali::Vector3 *)jarg1;
4765   arg2 = (Dali::Vector3 *)jarg2;
4766   if (!arg2) {
4767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4768     return 0;
4769   }
4770   {
4771     try {
4772       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4773     } CALL_CATCH_EXCEPTION(0);
4774   }
4775
4776   jresult = result;
4777   return jresult;
4778 }
4779
4780
4781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4782   unsigned int jresult ;
4783   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4784   Dali::Vector3 *arg2 = 0 ;
4785   bool result;
4786
4787   arg1 = (Dali::Vector3 *)jarg1;
4788   arg2 = (Dali::Vector3 *)jarg2;
4789   if (!arg2) {
4790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4791     return 0;
4792   }
4793   {
4794     try {
4795       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4796     } CALL_CATCH_EXCEPTION(0);
4797   }
4798
4799   jresult = result;
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4805   float jresult ;
4806   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4807   unsigned int arg2 ;
4808   float *result = 0 ;
4809
4810   arg1 = (Dali::Vector3 *)jarg1;
4811   arg2 = (unsigned int)jarg2;
4812   {
4813     try {
4814       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4815     } CALL_CATCH_EXCEPTION(0);
4816   }
4817
4818   jresult = *result;
4819   return jresult;
4820 }
4821
4822
4823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4824   float jresult ;
4825   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4826   Dali::Vector3 *arg2 = 0 ;
4827   float result;
4828
4829   arg1 = (Dali::Vector3 *)jarg1;
4830   arg2 = (Dali::Vector3 *)jarg2;
4831   if (!arg2) {
4832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4833     return 0;
4834   }
4835   {
4836     try {
4837       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4838     } CALL_CATCH_EXCEPTION(0);
4839   }
4840
4841   jresult = result;
4842   return jresult;
4843 }
4844
4845
4846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4847   void * jresult ;
4848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4849   Dali::Vector3 *arg2 = 0 ;
4850   Dali::Vector3 result;
4851
4852   arg1 = (Dali::Vector3 *)jarg1;
4853   arg2 = (Dali::Vector3 *)jarg2;
4854   if (!arg2) {
4855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4856     return 0;
4857   }
4858   {
4859     try {
4860       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4861     } CALL_CATCH_EXCEPTION(0);
4862   }
4863
4864   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4865   return jresult;
4866 }
4867
4868
4869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4870   float jresult ;
4871   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4872   float result;
4873
4874   arg1 = (Dali::Vector3 *)jarg1;
4875   {
4876     try {
4877       result = (float)((Dali::Vector3 const *)arg1)->Length();
4878     } CALL_CATCH_EXCEPTION(0);
4879   }
4880
4881   jresult = result;
4882   return jresult;
4883 }
4884
4885
4886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4887   float jresult ;
4888   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4889   float result;
4890
4891   arg1 = (Dali::Vector3 *)jarg1;
4892   {
4893     try {
4894       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4895     } CALL_CATCH_EXCEPTION(0);
4896   }
4897
4898   jresult = result;
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4905
4906   arg1 = (Dali::Vector3 *)jarg1;
4907   {
4908     try {
4909       (arg1)->Normalize();
4910     } CALL_CATCH_EXCEPTION();
4911   }
4912
4913 }
4914
4915
4916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4918   Dali::Vector3 *arg2 = 0 ;
4919   Dali::Vector3 *arg3 = 0 ;
4920
4921   arg1 = (Dali::Vector3 *)jarg1;
4922   arg2 = (Dali::Vector3 *)jarg2;
4923   if (!arg2) {
4924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4925     return ;
4926   }
4927   arg3 = (Dali::Vector3 *)jarg3;
4928   if (!arg3) {
4929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4930     return ;
4931   }
4932   {
4933     try {
4934       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4935     } CALL_CATCH_EXCEPTION();
4936   }
4937
4938 }
4939
4940
4941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4942   void * jresult ;
4943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4944   float *result = 0 ;
4945
4946   arg1 = (Dali::Vector3 *)jarg1;
4947   {
4948     try {
4949       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4950     } CALL_CATCH_EXCEPTION(0);
4951   }
4952
4953   jresult = (void *)result;
4954   return jresult;
4955 }
4956
4957
4958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4959   void * jresult ;
4960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4961   Dali::Vector2 *result = 0 ;
4962
4963   arg1 = (Dali::Vector3 *)jarg1;
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4967     } CALL_CATCH_EXCEPTION(0);
4968   }
4969
4970   jresult = (void *)result;
4971   return jresult;
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4976   void * jresult ;
4977   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4978   Dali::Vector2 *result = 0 ;
4979
4980   arg1 = (Dali::Vector3 *)jarg1;
4981   {
4982     try {
4983       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4984     } CALL_CATCH_EXCEPTION(0);
4985   }
4986
4987   jresult = (void *)result;
4988   return jresult;
4989 }
4990
4991
4992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4993   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4994   float arg2 ;
4995
4996   arg1 = (Dali::Vector3 *)jarg1;
4997   arg2 = (float)jarg2;
4998   if (arg1) (arg1)->x = arg2;
4999 }
5000
5001
5002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
5003   float jresult ;
5004   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5005   float result;
5006
5007   arg1 = (Dali::Vector3 *)jarg1;
5008   result = (float) ((arg1)->x);
5009   jresult = result;
5010   return jresult;
5011 }
5012
5013
5014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
5015   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5016   float arg2 ;
5017
5018   arg1 = (Dali::Vector3 *)jarg1;
5019   arg2 = (float)jarg2;
5020   if (arg1) (arg1)->width = arg2;
5021 }
5022
5023
5024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
5025   float jresult ;
5026   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5027   float result;
5028
5029   arg1 = (Dali::Vector3 *)jarg1;
5030   result = (float) ((arg1)->width);
5031   jresult = result;
5032   return jresult;
5033 }
5034
5035
5036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
5037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5038   float arg2 ;
5039
5040   arg1 = (Dali::Vector3 *)jarg1;
5041   arg2 = (float)jarg2;
5042   if (arg1) (arg1)->r = arg2;
5043 }
5044
5045
5046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
5047   float jresult ;
5048   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5049   float result;
5050
5051   arg1 = (Dali::Vector3 *)jarg1;
5052   result = (float) ((arg1)->r);
5053   jresult = result;
5054   return jresult;
5055 }
5056
5057
5058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
5059   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5060   float arg2 ;
5061
5062   arg1 = (Dali::Vector3 *)jarg1;
5063   arg2 = (float)jarg2;
5064   if (arg1) (arg1)->y = arg2;
5065 }
5066
5067
5068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
5069   float jresult ;
5070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5071   float result;
5072
5073   arg1 = (Dali::Vector3 *)jarg1;
5074   result = (float) ((arg1)->y);
5075   jresult = result;
5076   return jresult;
5077 }
5078
5079
5080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
5081   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5082   float arg2 ;
5083
5084   arg1 = (Dali::Vector3 *)jarg1;
5085   arg2 = (float)jarg2;
5086   if (arg1) (arg1)->height = arg2;
5087 }
5088
5089
5090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
5091   float jresult ;
5092   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5093   float result;
5094
5095   arg1 = (Dali::Vector3 *)jarg1;
5096   result = (float) ((arg1)->height);
5097   jresult = result;
5098   return jresult;
5099 }
5100
5101
5102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5104   float arg2 ;
5105
5106   arg1 = (Dali::Vector3 *)jarg1;
5107   arg2 = (float)jarg2;
5108   if (arg1) (arg1)->g = arg2;
5109 }
5110
5111
5112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5113   float jresult ;
5114   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5115   float result;
5116
5117   arg1 = (Dali::Vector3 *)jarg1;
5118   result = (float) ((arg1)->g);
5119   jresult = result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
5125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5126   float arg2 ;
5127
5128   arg1 = (Dali::Vector3 *)jarg1;
5129   arg2 = (float)jarg2;
5130   if (arg1) (arg1)->z = arg2;
5131 }
5132
5133
5134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
5135   float jresult ;
5136   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5137   float result;
5138
5139   arg1 = (Dali::Vector3 *)jarg1;
5140   result = (float) ((arg1)->z);
5141   jresult = result;
5142   return jresult;
5143 }
5144
5145
5146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
5147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5148   float arg2 ;
5149
5150   arg1 = (Dali::Vector3 *)jarg1;
5151   arg2 = (float)jarg2;
5152   if (arg1) (arg1)->depth = arg2;
5153 }
5154
5155
5156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
5157   float jresult ;
5158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5159   float result;
5160
5161   arg1 = (Dali::Vector3 *)jarg1;
5162   result = (float) ((arg1)->depth);
5163   jresult = result;
5164   return jresult;
5165 }
5166
5167
5168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5170   float arg2 ;
5171
5172   arg1 = (Dali::Vector3 *)jarg1;
5173   arg2 = (float)jarg2;
5174   if (arg1) (arg1)->b = arg2;
5175 }
5176
5177
5178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5179   float jresult ;
5180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5181   float result;
5182
5183   arg1 = (Dali::Vector3 *)jarg1;
5184   result = (float) ((arg1)->b);
5185   jresult = result;
5186   return jresult;
5187 }
5188
5189
5190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5192
5193   arg1 = (Dali::Vector3 *)jarg1;
5194   {
5195     try {
5196       delete arg1;
5197     } CALL_CATCH_EXCEPTION();
5198   }
5199
5200 }
5201
5202
5203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5204   void * jresult ;
5205   Dali::Vector3 *arg1 = 0 ;
5206   Dali::Vector3 *arg2 = 0 ;
5207   Dali::Vector3 result;
5208
5209   arg1 = (Dali::Vector3 *)jarg1;
5210   if (!arg1) {
5211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5212     return 0;
5213   }
5214   arg2 = (Dali::Vector3 *)jarg2;
5215   if (!arg2) {
5216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5217     return 0;
5218   }
5219   {
5220     try {
5221       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5222     } CALL_CATCH_EXCEPTION(0);
5223   }
5224
5225   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5226   return jresult;
5227 }
5228
5229
5230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5231   void * jresult ;
5232   Dali::Vector3 *arg1 = 0 ;
5233   Dali::Vector3 *arg2 = 0 ;
5234   Dali::Vector3 result;
5235
5236   arg1 = (Dali::Vector3 *)jarg1;
5237   if (!arg1) {
5238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5239     return 0;
5240   }
5241   arg2 = (Dali::Vector3 *)jarg2;
5242   if (!arg2) {
5243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5244     return 0;
5245   }
5246   {
5247     try {
5248       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5249     } CALL_CATCH_EXCEPTION(0);
5250   }
5251
5252   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5253   return jresult;
5254 }
5255
5256
5257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5258   void * jresult ;
5259   Dali::Vector3 *arg1 = 0 ;
5260   float *arg2 = 0 ;
5261   float *arg3 = 0 ;
5262   float temp2 ;
5263   float temp3 ;
5264   Dali::Vector3 result;
5265
5266   arg1 = (Dali::Vector3 *)jarg1;
5267   if (!arg1) {
5268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5269     return 0;
5270   }
5271   temp2 = (float)jarg2;
5272   arg2 = &temp2;
5273   temp3 = (float)jarg3;
5274   arg3 = &temp3;
5275   {
5276     try {
5277       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5278     } CALL_CATCH_EXCEPTION(0);
5279   }
5280
5281   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5282   return jresult;
5283 }
5284
5285
5286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5287   void * jresult ;
5288   Dali::Vector4 *result = 0 ;
5289
5290   {
5291     try {
5292       result = (Dali::Vector4 *)new Dali::Vector4();
5293     } CALL_CATCH_EXCEPTION(0);
5294   }
5295
5296   jresult = (void *)result;
5297   return jresult;
5298 }
5299
5300
5301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5302   void * jresult ;
5303   float arg1 ;
5304   float arg2 ;
5305   float arg3 ;
5306   float arg4 ;
5307   Dali::Vector4 *result = 0 ;
5308
5309   arg1 = (float)jarg1;
5310   arg2 = (float)jarg2;
5311   arg3 = (float)jarg3;
5312   arg4 = (float)jarg4;
5313   {
5314     try {
5315       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5316     } CALL_CATCH_EXCEPTION(0);
5317   }
5318
5319   jresult = (void *)result;
5320   return jresult;
5321 }
5322
5323
5324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5325   void * jresult ;
5326   float *arg1 = (float *) 0 ;
5327   Dali::Vector4 *result = 0 ;
5328
5329   arg1 = jarg1;
5330   {
5331     try {
5332       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5333     } CALL_CATCH_EXCEPTION(0);
5334   }
5335
5336   jresult = (void *)result;
5337
5338
5339   return jresult;
5340 }
5341
5342
5343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5344   void * jresult ;
5345   Dali::Vector2 *arg1 = 0 ;
5346   Dali::Vector4 *result = 0 ;
5347
5348   arg1 = (Dali::Vector2 *)jarg1;
5349   if (!arg1) {
5350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5351     return 0;
5352   }
5353   {
5354     try {
5355       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5356     } CALL_CATCH_EXCEPTION(0);
5357   }
5358
5359   jresult = (void *)result;
5360   return jresult;
5361 }
5362
5363
5364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5365   void * jresult ;
5366   Dali::Vector3 *arg1 = 0 ;
5367   Dali::Vector4 *result = 0 ;
5368
5369   arg1 = (Dali::Vector3 *)jarg1;
5370   if (!arg1) {
5371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5372     return 0;
5373   }
5374   {
5375     try {
5376       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5377     } CALL_CATCH_EXCEPTION(0);
5378   }
5379
5380   jresult = (void *)result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5386   void * jresult ;
5387   Dali::Vector4 *result = 0 ;
5388
5389   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5390   jresult = (void *)result;
5391   return jresult;
5392 }
5393
5394
5395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5396   void * jresult ;
5397   Dali::Vector4 *result = 0 ;
5398
5399   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5400   jresult = (void *)result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5406   void * jresult ;
5407   Dali::Vector4 *result = 0 ;
5408
5409   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5410   jresult = (void *)result;
5411   return jresult;
5412 }
5413
5414
5415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5416   void * jresult ;
5417   Dali::Vector4 *result = 0 ;
5418
5419   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5420   jresult = (void *)result;
5421   return jresult;
5422 }
5423
5424
5425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5426   void * jresult ;
5427   Dali::Vector4 *result = 0 ;
5428
5429   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5430   jresult = (void *)result;
5431   return jresult;
5432 }
5433
5434
5435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5436   void * jresult ;
5437   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5438   float *arg2 = (float *) 0 ;
5439   Dali::Vector4 *result = 0 ;
5440
5441   arg1 = (Dali::Vector4 *)jarg1;
5442   arg2 = jarg2;
5443   {
5444     try {
5445       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5446     } CALL_CATCH_EXCEPTION(0);
5447   }
5448
5449   jresult = (void *)result;
5450
5451
5452   return jresult;
5453 }
5454
5455
5456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5457   void * jresult ;
5458   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5459   Dali::Vector2 *arg2 = 0 ;
5460   Dali::Vector4 *result = 0 ;
5461
5462   arg1 = (Dali::Vector4 *)jarg1;
5463   arg2 = (Dali::Vector2 *)jarg2;
5464   if (!arg2) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   {
5469     try {
5470       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5471     } CALL_CATCH_EXCEPTION(0);
5472   }
5473
5474   jresult = (void *)result;
5475   return jresult;
5476 }
5477
5478
5479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5480   void * jresult ;
5481   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5482   Dali::Vector3 *arg2 = 0 ;
5483   Dali::Vector4 *result = 0 ;
5484
5485   arg1 = (Dali::Vector4 *)jarg1;
5486   arg2 = (Dali::Vector3 *)jarg2;
5487   if (!arg2) {
5488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5489     return 0;
5490   }
5491   {
5492     try {
5493       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5494     } CALL_CATCH_EXCEPTION(0);
5495   }
5496
5497   jresult = (void *)result;
5498   return jresult;
5499 }
5500
5501
5502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5503   void * jresult ;
5504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5505   Dali::Vector4 *arg2 = 0 ;
5506   Dali::Vector4 result;
5507
5508   arg1 = (Dali::Vector4 *)jarg1;
5509   arg2 = (Dali::Vector4 *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5517     } CALL_CATCH_EXCEPTION(0);
5518   }
5519
5520   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5521   return jresult;
5522 }
5523
5524
5525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5526   void * jresult ;
5527   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5528   Dali::Vector4 *arg2 = 0 ;
5529   Dali::Vector4 *result = 0 ;
5530
5531   arg1 = (Dali::Vector4 *)jarg1;
5532   arg2 = (Dali::Vector4 *)jarg2;
5533   if (!arg2) {
5534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5535     return 0;
5536   }
5537   {
5538     try {
5539       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5540     } CALL_CATCH_EXCEPTION(0);
5541   }
5542
5543   jresult = (void *)result;
5544   return jresult;
5545 }
5546
5547
5548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5549   void * jresult ;
5550   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5551   Dali::Vector4 *arg2 = 0 ;
5552   Dali::Vector4 result;
5553
5554   arg1 = (Dali::Vector4 *)jarg1;
5555   arg2 = (Dali::Vector4 *)jarg2;
5556   if (!arg2) {
5557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5558     return 0;
5559   }
5560   {
5561     try {
5562       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5563     } CALL_CATCH_EXCEPTION(0);
5564   }
5565
5566   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5567   return jresult;
5568 }
5569
5570
5571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5572   void * jresult ;
5573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5574   Dali::Vector4 *arg2 = 0 ;
5575   Dali::Vector4 *result = 0 ;
5576
5577   arg1 = (Dali::Vector4 *)jarg1;
5578   arg2 = (Dali::Vector4 *)jarg2;
5579   if (!arg2) {
5580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5581     return 0;
5582   }
5583   {
5584     try {
5585       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5586     } CALL_CATCH_EXCEPTION(0);
5587   }
5588
5589   jresult = (void *)result;
5590   return jresult;
5591 }
5592
5593
5594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5595   void * jresult ;
5596   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5597   Dali::Vector4 *arg2 = 0 ;
5598   Dali::Vector4 result;
5599
5600   arg1 = (Dali::Vector4 *)jarg1;
5601   arg2 = (Dali::Vector4 *)jarg2;
5602   if (!arg2) {
5603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5604     return 0;
5605   }
5606   {
5607     try {
5608       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5609     } CALL_CATCH_EXCEPTION(0);
5610   }
5611
5612   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5618   void * jresult ;
5619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5620   float arg2 ;
5621   Dali::Vector4 result;
5622
5623   arg1 = (Dali::Vector4 *)jarg1;
5624   arg2 = (float)jarg2;
5625   {
5626     try {
5627       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5628     } CALL_CATCH_EXCEPTION(0);
5629   }
5630
5631   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5632   return jresult;
5633 }
5634
5635
5636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5637   void * jresult ;
5638   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5639   Dali::Vector4 *arg2 = 0 ;
5640   Dali::Vector4 *result = 0 ;
5641
5642   arg1 = (Dali::Vector4 *)jarg1;
5643   arg2 = (Dali::Vector4 *)jarg2;
5644   if (!arg2) {
5645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5646     return 0;
5647   }
5648   {
5649     try {
5650       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5651     } CALL_CATCH_EXCEPTION(0);
5652   }
5653
5654   jresult = (void *)result;
5655   return jresult;
5656 }
5657
5658
5659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5660   void * jresult ;
5661   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5662   float arg2 ;
5663   Dali::Vector4 *result = 0 ;
5664
5665   arg1 = (Dali::Vector4 *)jarg1;
5666   arg2 = (float)jarg2;
5667   {
5668     try {
5669       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5670     } CALL_CATCH_EXCEPTION(0);
5671   }
5672
5673   jresult = (void *)result;
5674   return jresult;
5675 }
5676
5677
5678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5679   void * jresult ;
5680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5681   Dali::Vector4 *arg2 = 0 ;
5682   Dali::Vector4 result;
5683
5684   arg1 = (Dali::Vector4 *)jarg1;
5685   arg2 = (Dali::Vector4 *)jarg2;
5686   if (!arg2) {
5687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5688     return 0;
5689   }
5690   {
5691     try {
5692       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5693     } CALL_CATCH_EXCEPTION(0);
5694   }
5695
5696   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5697   return jresult;
5698 }
5699
5700
5701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5702   void * jresult ;
5703   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5704   float arg2 ;
5705   Dali::Vector4 result;
5706
5707   arg1 = (Dali::Vector4 *)jarg1;
5708   arg2 = (float)jarg2;
5709   {
5710     try {
5711       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5712     } CALL_CATCH_EXCEPTION(0);
5713   }
5714
5715   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5716   return jresult;
5717 }
5718
5719
5720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5721   void * jresult ;
5722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5723   Dali::Vector4 *arg2 = 0 ;
5724   Dali::Vector4 *result = 0 ;
5725
5726   arg1 = (Dali::Vector4 *)jarg1;
5727   arg2 = (Dali::Vector4 *)jarg2;
5728   if (!arg2) {
5729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5730     return 0;
5731   }
5732   {
5733     try {
5734       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5735     } CALL_CATCH_EXCEPTION(0);
5736   }
5737
5738   jresult = (void *)result;
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5744   void * jresult ;
5745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5746   float arg2 ;
5747   Dali::Vector4 *result = 0 ;
5748
5749   arg1 = (Dali::Vector4 *)jarg1;
5750   arg2 = (float)jarg2;
5751   {
5752     try {
5753       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5754     } CALL_CATCH_EXCEPTION(0);
5755   }
5756
5757   jresult = (void *)result;
5758   return jresult;
5759 }
5760
5761
5762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5763   void * jresult ;
5764   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5765   Dali::Vector4 result;
5766
5767   arg1 = (Dali::Vector4 *)jarg1;
5768   {
5769     try {
5770       result = ((Dali::Vector4 const *)arg1)->operator -();
5771     } CALL_CATCH_EXCEPTION(0);
5772   }
5773
5774   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5780   unsigned int jresult ;
5781   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5782   Dali::Vector4 *arg2 = 0 ;
5783   bool result;
5784
5785   arg1 = (Dali::Vector4 *)jarg1;
5786   arg2 = (Dali::Vector4 *)jarg2;
5787   if (!arg2) {
5788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5789     return 0;
5790   }
5791   {
5792     try {
5793       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5794     } CALL_CATCH_EXCEPTION(0);
5795   }
5796
5797   jresult = result;
5798   return jresult;
5799 }
5800
5801
5802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5803   unsigned int jresult ;
5804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5805   Dali::Vector4 *arg2 = 0 ;
5806   bool result;
5807
5808   arg1 = (Dali::Vector4 *)jarg1;
5809   arg2 = (Dali::Vector4 *)jarg2;
5810   if (!arg2) {
5811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5812     return 0;
5813   }
5814   {
5815     try {
5816       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5817     } CALL_CATCH_EXCEPTION(0);
5818   }
5819
5820   jresult = result;
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5826   float jresult ;
5827   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5828   unsigned int arg2 ;
5829   float *result = 0 ;
5830
5831   arg1 = (Dali::Vector4 *)jarg1;
5832   arg2 = (unsigned int)jarg2;
5833   {
5834     try {
5835       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5836     } CALL_CATCH_EXCEPTION(0);
5837   }
5838
5839   jresult = *result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5845   float jresult ;
5846   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5847   Dali::Vector3 *arg2 = 0 ;
5848   float result;
5849
5850   arg1 = (Dali::Vector4 *)jarg1;
5851   arg2 = (Dali::Vector3 *)jarg2;
5852   if (!arg2) {
5853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5854     return 0;
5855   }
5856   {
5857     try {
5858       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5859     } CALL_CATCH_EXCEPTION(0);
5860   }
5861
5862   jresult = result;
5863   return jresult;
5864 }
5865
5866
5867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5868   float jresult ;
5869   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5870   Dali::Vector4 *arg2 = 0 ;
5871   float result;
5872
5873   arg1 = (Dali::Vector4 *)jarg1;
5874   arg2 = (Dali::Vector4 *)jarg2;
5875   if (!arg2) {
5876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5877     return 0;
5878   }
5879   {
5880     try {
5881       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5882     } CALL_CATCH_EXCEPTION(0);
5883   }
5884
5885   jresult = result;
5886   return jresult;
5887 }
5888
5889
5890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5891   float jresult ;
5892   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5893   Dali::Vector4 *arg2 = 0 ;
5894   float result;
5895
5896   arg1 = (Dali::Vector4 *)jarg1;
5897   arg2 = (Dali::Vector4 *)jarg2;
5898   if (!arg2) {
5899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5900     return 0;
5901   }
5902   {
5903     try {
5904       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5905     } CALL_CATCH_EXCEPTION(0);
5906   }
5907
5908   jresult = result;
5909   return jresult;
5910 }
5911
5912
5913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5914   void * jresult ;
5915   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5916   Dali::Vector4 *arg2 = 0 ;
5917   Dali::Vector4 result;
5918
5919   arg1 = (Dali::Vector4 *)jarg1;
5920   arg2 = (Dali::Vector4 *)jarg2;
5921   if (!arg2) {
5922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5923     return 0;
5924   }
5925   {
5926     try {
5927       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5928     } CALL_CATCH_EXCEPTION(0);
5929   }
5930
5931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5932   return jresult;
5933 }
5934
5935
5936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5937   float jresult ;
5938   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5939   float result;
5940
5941   arg1 = (Dali::Vector4 *)jarg1;
5942   {
5943     try {
5944       result = (float)((Dali::Vector4 const *)arg1)->Length();
5945     } CALL_CATCH_EXCEPTION(0);
5946   }
5947
5948   jresult = result;
5949   return jresult;
5950 }
5951
5952
5953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5954   float jresult ;
5955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5956   float result;
5957
5958   arg1 = (Dali::Vector4 *)jarg1;
5959   {
5960     try {
5961       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5962     } CALL_CATCH_EXCEPTION(0);
5963   }
5964
5965   jresult = result;
5966   return jresult;
5967 }
5968
5969
5970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5971   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5972
5973   arg1 = (Dali::Vector4 *)jarg1;
5974   {
5975     try {
5976       (arg1)->Normalize();
5977     } CALL_CATCH_EXCEPTION();
5978   }
5979
5980 }
5981
5982
5983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5984   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5985   Dali::Vector4 *arg2 = 0 ;
5986   Dali::Vector4 *arg3 = 0 ;
5987
5988   arg1 = (Dali::Vector4 *)jarg1;
5989   arg2 = (Dali::Vector4 *)jarg2;
5990   if (!arg2) {
5991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5992     return ;
5993   }
5994   arg3 = (Dali::Vector4 *)jarg3;
5995   if (!arg3) {
5996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5997     return ;
5998   }
5999   {
6000     try {
6001       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
6002     } CALL_CATCH_EXCEPTION();
6003   }
6004
6005 }
6006
6007
6008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
6009   void * jresult ;
6010   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6011   float *result = 0 ;
6012
6013   arg1 = (Dali::Vector4 *)jarg1;
6014   {
6015     try {
6016       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
6017     } CALL_CATCH_EXCEPTION(0);
6018   }
6019
6020   jresult = (void *)result;
6021   return jresult;
6022 }
6023
6024
6025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
6026   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6027   float arg2 ;
6028
6029   arg1 = (Dali::Vector4 *)jarg1;
6030   arg2 = (float)jarg2;
6031   if (arg1) (arg1)->x = arg2;
6032 }
6033
6034
6035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
6036   float jresult ;
6037   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6038   float result;
6039
6040   arg1 = (Dali::Vector4 *)jarg1;
6041   result = (float) ((arg1)->x);
6042   jresult = result;
6043   return jresult;
6044 }
6045
6046
6047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
6048   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6049   float arg2 ;
6050
6051   arg1 = (Dali::Vector4 *)jarg1;
6052   arg2 = (float)jarg2;
6053   if (arg1) (arg1)->r = arg2;
6054 }
6055
6056
6057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
6058   float jresult ;
6059   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6060   float result;
6061
6062   arg1 = (Dali::Vector4 *)jarg1;
6063   result = (float) ((arg1)->r);
6064   jresult = result;
6065   return jresult;
6066 }
6067
6068
6069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
6070   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6071   float arg2 ;
6072
6073   arg1 = (Dali::Vector4 *)jarg1;
6074   arg2 = (float)jarg2;
6075   if (arg1) (arg1)->s = arg2;
6076 }
6077
6078
6079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
6080   float jresult ;
6081   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6082   float result;
6083
6084   arg1 = (Dali::Vector4 *)jarg1;
6085   result = (float) ((arg1)->s);
6086   jresult = result;
6087   return jresult;
6088 }
6089
6090
6091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
6092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6093   float arg2 ;
6094
6095   arg1 = (Dali::Vector4 *)jarg1;
6096   arg2 = (float)jarg2;
6097   if (arg1) (arg1)->y = arg2;
6098 }
6099
6100
6101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
6102   float jresult ;
6103   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6104   float result;
6105
6106   arg1 = (Dali::Vector4 *)jarg1;
6107   result = (float) ((arg1)->y);
6108   jresult = result;
6109   return jresult;
6110 }
6111
6112
6113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6114   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6115   float arg2 ;
6116
6117   arg1 = (Dali::Vector4 *)jarg1;
6118   arg2 = (float)jarg2;
6119   if (arg1) (arg1)->g = arg2;
6120 }
6121
6122
6123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6124   float jresult ;
6125   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6126   float result;
6127
6128   arg1 = (Dali::Vector4 *)jarg1;
6129   result = (float) ((arg1)->g);
6130   jresult = result;
6131   return jresult;
6132 }
6133
6134
6135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6137   float arg2 ;
6138
6139   arg1 = (Dali::Vector4 *)jarg1;
6140   arg2 = (float)jarg2;
6141   if (arg1) (arg1)->t = arg2;
6142 }
6143
6144
6145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6146   float jresult ;
6147   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6148   float result;
6149
6150   arg1 = (Dali::Vector4 *)jarg1;
6151   result = (float) ((arg1)->t);
6152   jresult = result;
6153   return jresult;
6154 }
6155
6156
6157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
6158   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6159   float arg2 ;
6160
6161   arg1 = (Dali::Vector4 *)jarg1;
6162   arg2 = (float)jarg2;
6163   if (arg1) (arg1)->z = arg2;
6164 }
6165
6166
6167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
6168   float jresult ;
6169   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6170   float result;
6171
6172   arg1 = (Dali::Vector4 *)jarg1;
6173   result = (float) ((arg1)->z);
6174   jresult = result;
6175   return jresult;
6176 }
6177
6178
6179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6180   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6181   float arg2 ;
6182
6183   arg1 = (Dali::Vector4 *)jarg1;
6184   arg2 = (float)jarg2;
6185   if (arg1) (arg1)->b = arg2;
6186 }
6187
6188
6189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6190   float jresult ;
6191   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6192   float result;
6193
6194   arg1 = (Dali::Vector4 *)jarg1;
6195   result = (float) ((arg1)->b);
6196   jresult = result;
6197   return jresult;
6198 }
6199
6200
6201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6202   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6203   float arg2 ;
6204
6205   arg1 = (Dali::Vector4 *)jarg1;
6206   arg2 = (float)jarg2;
6207   if (arg1) (arg1)->p = arg2;
6208 }
6209
6210
6211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6212   float jresult ;
6213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6214   float result;
6215
6216   arg1 = (Dali::Vector4 *)jarg1;
6217   result = (float) ((arg1)->p);
6218   jresult = result;
6219   return jresult;
6220 }
6221
6222
6223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6224   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6225   float arg2 ;
6226
6227   arg1 = (Dali::Vector4 *)jarg1;
6228   arg2 = (float)jarg2;
6229   if (arg1) (arg1)->w = arg2;
6230 }
6231
6232
6233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6234   float jresult ;
6235   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6236   float result;
6237
6238   arg1 = (Dali::Vector4 *)jarg1;
6239   result = (float) ((arg1)->w);
6240   jresult = result;
6241   return jresult;
6242 }
6243
6244
6245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6246   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6247   float arg2 ;
6248
6249   arg1 = (Dali::Vector4 *)jarg1;
6250   arg2 = (float)jarg2;
6251   if (arg1) (arg1)->a = arg2;
6252 }
6253
6254
6255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6256   float jresult ;
6257   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6258   float result;
6259
6260   arg1 = (Dali::Vector4 *)jarg1;
6261   result = (float) ((arg1)->a);
6262   jresult = result;
6263   return jresult;
6264 }
6265
6266
6267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6268   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6269   float arg2 ;
6270
6271   arg1 = (Dali::Vector4 *)jarg1;
6272   arg2 = (float)jarg2;
6273   if (arg1) (arg1)->q = arg2;
6274 }
6275
6276
6277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6278   float jresult ;
6279   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6280   float result;
6281
6282   arg1 = (Dali::Vector4 *)jarg1;
6283   result = (float) ((arg1)->q);
6284   jresult = result;
6285   return jresult;
6286 }
6287
6288
6289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6290   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6291
6292   arg1 = (Dali::Vector4 *)jarg1;
6293   {
6294     try {
6295       delete arg1;
6296     } CALL_CATCH_EXCEPTION();
6297   }
6298
6299 }
6300
6301
6302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6303   void * jresult ;
6304   Dali::Vector4 *arg1 = 0 ;
6305   Dali::Vector4 *arg2 = 0 ;
6306   Dali::Vector4 result;
6307
6308   arg1 = (Dali::Vector4 *)jarg1;
6309   if (!arg1) {
6310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6311     return 0;
6312   }
6313   arg2 = (Dali::Vector4 *)jarg2;
6314   if (!arg2) {
6315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6316     return 0;
6317   }
6318   {
6319     try {
6320       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6321     } CALL_CATCH_EXCEPTION(0);
6322   }
6323
6324   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6330   void * jresult ;
6331   Dali::Vector4 *arg1 = 0 ;
6332   Dali::Vector4 *arg2 = 0 ;
6333   Dali::Vector4 result;
6334
6335   arg1 = (Dali::Vector4 *)jarg1;
6336   if (!arg1) {
6337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6338     return 0;
6339   }
6340   arg2 = (Dali::Vector4 *)jarg2;
6341   if (!arg2) {
6342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6343     return 0;
6344   }
6345   {
6346     try {
6347       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6348     } CALL_CATCH_EXCEPTION(0);
6349   }
6350
6351   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6352   return jresult;
6353 }
6354
6355
6356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6357   void * jresult ;
6358   Dali::Vector4 *arg1 = 0 ;
6359   float *arg2 = 0 ;
6360   float *arg3 = 0 ;
6361   float temp2 ;
6362   float temp3 ;
6363   Dali::Vector4 result;
6364
6365   arg1 = (Dali::Vector4 *)jarg1;
6366   if (!arg1) {
6367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6368     return 0;
6369   }
6370   temp2 = (float)jarg2;
6371   arg2 = &temp2;
6372   temp3 = (float)jarg3;
6373   arg3 = &temp3;
6374   {
6375     try {
6376       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6377     } CALL_CATCH_EXCEPTION(0);
6378   }
6379
6380   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6381   return jresult;
6382 }
6383
6384
6385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6386   void * jresult ;
6387   Dali::Uint16Pair *result = 0 ;
6388
6389   {
6390     try {
6391       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6392     } CALL_CATCH_EXCEPTION(0);
6393   }
6394
6395   jresult = (void *)result;
6396   return jresult;
6397 }
6398
6399
6400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6401   void * jresult ;
6402   uint32_t arg1 ;
6403   uint32_t arg2 ;
6404   Dali::Uint16Pair *result = 0 ;
6405
6406   arg1 = (uint32_t)jarg1;
6407   arg2 = (uint32_t)jarg2;
6408   {
6409     try {
6410       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6411     } CALL_CATCH_EXCEPTION(0);
6412   }
6413
6414   jresult = (void *)result;
6415   return jresult;
6416 }
6417
6418
6419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6420   void * jresult ;
6421   Dali::Uint16Pair *arg1 = 0 ;
6422   Dali::Uint16Pair *result = 0 ;
6423
6424   arg1 = (Dali::Uint16Pair *)jarg1;
6425   if (!arg1) {
6426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6427     return 0;
6428   }
6429   {
6430     try {
6431       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6432     } CALL_CATCH_EXCEPTION(0);
6433   }
6434
6435   jresult = (void *)result;
6436   return jresult;
6437 }
6438
6439
6440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6441   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6442   uint16_t arg2 ;
6443
6444   arg1 = (Dali::Uint16Pair *)jarg1;
6445   arg2 = (uint16_t)jarg2;
6446   {
6447     try {
6448       (arg1)->SetWidth(arg2);
6449     } CALL_CATCH_EXCEPTION();
6450   }
6451
6452 }
6453
6454
6455 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6456   unsigned short jresult ;
6457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6458   uint16_t result;
6459
6460   arg1 = (Dali::Uint16Pair *)jarg1;
6461   {
6462     try {
6463       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6464     } CALL_CATCH_EXCEPTION(0);
6465   }
6466
6467   jresult = result;
6468   return jresult;
6469 }
6470
6471
6472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6473   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6474   uint16_t arg2 ;
6475
6476   arg1 = (Dali::Uint16Pair *)jarg1;
6477   arg2 = (uint16_t)jarg2;
6478   {
6479     try {
6480       (arg1)->SetHeight(arg2);
6481     } CALL_CATCH_EXCEPTION();
6482   }
6483
6484 }
6485
6486
6487 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6488   unsigned short jresult ;
6489   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6490   uint16_t result;
6491
6492   arg1 = (Dali::Uint16Pair *)jarg1;
6493   {
6494     try {
6495       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6496     } CALL_CATCH_EXCEPTION(0);
6497   }
6498
6499   jresult = result;
6500   return jresult;
6501 }
6502
6503
6504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6505   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6506   uint16_t arg2 ;
6507
6508   arg1 = (Dali::Uint16Pair *)jarg1;
6509   arg2 = (uint16_t)jarg2;
6510   {
6511     try {
6512       (arg1)->SetX(arg2);
6513     } CALL_CATCH_EXCEPTION();
6514   }
6515
6516 }
6517
6518
6519 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6520   unsigned short jresult ;
6521   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6522   uint16_t result;
6523
6524   arg1 = (Dali::Uint16Pair *)jarg1;
6525   {
6526     try {
6527       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6528     } CALL_CATCH_EXCEPTION(0);
6529   }
6530
6531   jresult = result;
6532   return jresult;
6533 }
6534
6535
6536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6537   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6538   uint16_t arg2 ;
6539
6540   arg1 = (Dali::Uint16Pair *)jarg1;
6541   arg2 = (uint16_t)jarg2;
6542   {
6543     try {
6544       (arg1)->SetY(arg2);
6545     } CALL_CATCH_EXCEPTION();
6546   }
6547
6548 }
6549
6550
6551 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6552   unsigned short jresult ;
6553   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6554   uint16_t result;
6555
6556   arg1 = (Dali::Uint16Pair *)jarg1;
6557   {
6558     try {
6559       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6560     } CALL_CATCH_EXCEPTION(0);
6561   }
6562
6563   jresult = result;
6564   return jresult;
6565 }
6566
6567
6568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6569   void * jresult ;
6570   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6571   Dali::Uint16Pair *arg2 = 0 ;
6572   Dali::Uint16Pair *result = 0 ;
6573
6574   arg1 = (Dali::Uint16Pair *)jarg1;
6575   arg2 = (Dali::Uint16Pair *)jarg2;
6576   if (!arg2) {
6577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6578     return 0;
6579   }
6580   {
6581     try {
6582       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6583     } CALL_CATCH_EXCEPTION(0);
6584   }
6585
6586   jresult = (void *)result;
6587   return jresult;
6588 }
6589
6590
6591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6592   unsigned int jresult ;
6593   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6594   Dali::Uint16Pair *arg2 = 0 ;
6595   bool result;
6596
6597   arg1 = (Dali::Uint16Pair *)jarg1;
6598   arg2 = (Dali::Uint16Pair *)jarg2;
6599   if (!arg2) {
6600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6601     return 0;
6602   }
6603   {
6604     try {
6605       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6606     } CALL_CATCH_EXCEPTION(0);
6607   }
6608
6609   jresult = result;
6610   return jresult;
6611 }
6612
6613
6614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6615   unsigned int jresult ;
6616   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6617   Dali::Uint16Pair *arg2 = 0 ;
6618   bool result;
6619
6620   arg1 = (Dali::Uint16Pair *)jarg1;
6621   arg2 = (Dali::Uint16Pair *)jarg2;
6622   if (!arg2) {
6623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6624     return 0;
6625   }
6626   {
6627     try {
6628       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6629     } CALL_CATCH_EXCEPTION(0);
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6638   unsigned int jresult ;
6639   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6640   Dali::Uint16Pair *arg2 = 0 ;
6641   bool result;
6642
6643   arg1 = (Dali::Uint16Pair *)jarg1;
6644   arg2 = (Dali::Uint16Pair *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6652     } CALL_CATCH_EXCEPTION(0);
6653   }
6654
6655   jresult = result;
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6661   unsigned int jresult ;
6662   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6663   Dali::Uint16Pair *arg2 = 0 ;
6664   bool result;
6665
6666   arg1 = (Dali::Uint16Pair *)jarg1;
6667   arg2 = (Dali::Uint16Pair *)jarg2;
6668   if (!arg2) {
6669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6670     return 0;
6671   }
6672   {
6673     try {
6674       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6675     } CALL_CATCH_EXCEPTION(0);
6676   }
6677
6678   jresult = result;
6679   return jresult;
6680 }
6681
6682
6683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6684   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6685
6686   arg1 = (Dali::Uint16Pair *)jarg1;
6687   {
6688     try {
6689       delete arg1;
6690     } CALL_CATCH_EXCEPTION();
6691   }
6692
6693 }
6694
6695
6696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6697   void * jresult ;
6698   Dali::Degree *result = 0 ;
6699
6700   {
6701     try {
6702       result = (Dali::Degree *)new Dali::Degree();
6703     } CALL_CATCH_EXCEPTION(0);
6704   }
6705
6706   jresult = (void *)result;
6707   return jresult;
6708 }
6709
6710
6711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6712   void * jresult ;
6713   float arg1 ;
6714   Dali::Degree *result = 0 ;
6715
6716   arg1 = (float)jarg1;
6717   {
6718     try {
6719       result = (Dali::Degree *)new Dali::Degree(arg1);
6720     } CALL_CATCH_EXCEPTION(0);
6721   }
6722
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6729   void * jresult ;
6730   Dali::Radian arg1 ;
6731   Dali::Radian *argp1 ;
6732   Dali::Degree *result = 0 ;
6733
6734   argp1 = (Dali::Radian *)jarg1;
6735   if (!argp1) {
6736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6737     return 0;
6738   }
6739   arg1 = *argp1;
6740   {
6741     try {
6742       result = (Dali::Degree *)new Dali::Degree(arg1);
6743     } CALL_CATCH_EXCEPTION(0);
6744   }
6745
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6752   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6753   float arg2 ;
6754
6755   arg1 = (Dali::Degree *)jarg1;
6756   arg2 = (float)jarg2;
6757   if (arg1) (arg1)->degree = arg2;
6758 }
6759
6760
6761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6762   float jresult ;
6763   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6764   float result;
6765
6766   arg1 = (Dali::Degree *)jarg1;
6767   result = (float) ((arg1)->degree);
6768   jresult = result;
6769   return jresult;
6770 }
6771
6772
6773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6774   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6775
6776   arg1 = (Dali::Degree *)jarg1;
6777   {
6778     try {
6779       delete arg1;
6780     } CALL_CATCH_EXCEPTION();
6781   }
6782
6783 }
6784
6785
6786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6787   void * jresult ;
6788   Dali::Radian *result = 0 ;
6789
6790   result = (Dali::Radian *)&Dali::ANGLE_360;
6791   jresult = (void *)result;
6792   return jresult;
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6797   void * jresult ;
6798   Dali::Radian *result = 0 ;
6799
6800   result = (Dali::Radian *)&Dali::ANGLE_315;
6801   jresult = (void *)result;
6802   return jresult;
6803 }
6804
6805
6806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6807   void * jresult ;
6808   Dali::Radian *result = 0 ;
6809
6810   result = (Dali::Radian *)&Dali::ANGLE_270;
6811   jresult = (void *)result;
6812   return jresult;
6813 }
6814
6815
6816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6817   void * jresult ;
6818   Dali::Radian *result = 0 ;
6819
6820   result = (Dali::Radian *)&Dali::ANGLE_225;
6821   jresult = (void *)result;
6822   return jresult;
6823 }
6824
6825
6826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6827   void * jresult ;
6828   Dali::Radian *result = 0 ;
6829
6830   result = (Dali::Radian *)&Dali::ANGLE_180;
6831   jresult = (void *)result;
6832   return jresult;
6833 }
6834
6835
6836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6837   void * jresult ;
6838   Dali::Radian *result = 0 ;
6839
6840   result = (Dali::Radian *)&Dali::ANGLE_135;
6841   jresult = (void *)result;
6842   return jresult;
6843 }
6844
6845
6846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6847   void * jresult ;
6848   Dali::Radian *result = 0 ;
6849
6850   result = (Dali::Radian *)&Dali::ANGLE_120;
6851   jresult = (void *)result;
6852   return jresult;
6853 }
6854
6855
6856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6857   void * jresult ;
6858   Dali::Radian *result = 0 ;
6859
6860   result = (Dali::Radian *)&Dali::ANGLE_90;
6861   jresult = (void *)result;
6862   return jresult;
6863 }
6864
6865
6866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6867   void * jresult ;
6868   Dali::Radian *result = 0 ;
6869
6870   result = (Dali::Radian *)&Dali::ANGLE_60;
6871   jresult = (void *)result;
6872   return jresult;
6873 }
6874
6875
6876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6877   void * jresult ;
6878   Dali::Radian *result = 0 ;
6879
6880   result = (Dali::Radian *)&Dali::ANGLE_45;
6881   jresult = (void *)result;
6882   return jresult;
6883 }
6884
6885
6886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6887   void * jresult ;
6888   Dali::Radian *result = 0 ;
6889
6890   result = (Dali::Radian *)&Dali::ANGLE_30;
6891   jresult = (void *)result;
6892   return jresult;
6893 }
6894
6895
6896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6897   void * jresult ;
6898   Dali::Radian *result = 0 ;
6899
6900   result = (Dali::Radian *)&Dali::ANGLE_0;
6901   jresult = (void *)result;
6902   return jresult;
6903 }
6904
6905
6906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6907   unsigned int jresult ;
6908   Dali::Degree *arg1 = 0 ;
6909   Dali::Degree *arg2 = 0 ;
6910   bool result;
6911
6912   arg1 = (Dali::Degree *)jarg1;
6913   if (!arg1) {
6914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6915     return 0;
6916   }
6917   arg2 = (Dali::Degree *)jarg2;
6918   if (!arg2) {
6919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6920     return 0;
6921   }
6922   {
6923     try {
6924       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6925     } CALL_CATCH_EXCEPTION(0);
6926   }
6927
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6934   unsigned int jresult ;
6935   Dali::Degree *arg1 = 0 ;
6936   Dali::Degree *arg2 = 0 ;
6937   bool result;
6938
6939   arg1 = (Dali::Degree *)jarg1;
6940   if (!arg1) {
6941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6942     return 0;
6943   }
6944   arg2 = (Dali::Degree *)jarg2;
6945   if (!arg2) {
6946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6947     return 0;
6948   }
6949   {
6950     try {
6951       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6952     } CALL_CATCH_EXCEPTION(0);
6953   }
6954
6955   jresult = result;
6956   return jresult;
6957 }
6958
6959
6960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6961   void * jresult ;
6962   Dali::Degree arg1 ;
6963   float arg2 ;
6964   float arg3 ;
6965   Dali::Degree *argp1 ;
6966   Dali::Degree result;
6967
6968   argp1 = (Dali::Degree *)jarg1;
6969   if (!argp1) {
6970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6971     return 0;
6972   }
6973   arg1 = *argp1;
6974   arg2 = (float)jarg2;
6975   arg3 = (float)jarg3;
6976   {
6977     try {
6978       result = Dali::Clamp(arg1,arg2,arg3);
6979     } CALL_CATCH_EXCEPTION(0);
6980   }
6981
6982   jresult = new Dali::Degree((const Dali::Degree &)result);
6983   return jresult;
6984 }
6985
6986
6987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6988   void * jresult ;
6989   Dali::Radian *result = 0 ;
6990
6991   {
6992     try {
6993       result = (Dali::Radian *)new Dali::Radian();
6994     } CALL_CATCH_EXCEPTION(0);
6995   }
6996
6997   jresult = (void *)result;
6998   return jresult;
6999 }
7000
7001
7002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
7003   void * jresult ;
7004   float arg1 ;
7005   Dali::Radian *result = 0 ;
7006
7007   arg1 = (float)jarg1;
7008   {
7009     try {
7010       result = (Dali::Radian *)new Dali::Radian(arg1);
7011     } CALL_CATCH_EXCEPTION(0);
7012   }
7013
7014   jresult = (void *)result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
7020   void * jresult ;
7021   Dali::Degree arg1 ;
7022   Dali::Degree *argp1 ;
7023   Dali::Radian *result = 0 ;
7024
7025   argp1 = (Dali::Degree *)jarg1;
7026   if (!argp1) {
7027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7028     return 0;
7029   }
7030   arg1 = *argp1;
7031   {
7032     try {
7033       result = (Dali::Radian *)new Dali::Radian(arg1);
7034     } CALL_CATCH_EXCEPTION(0);
7035   }
7036
7037   jresult = (void *)result;
7038   return jresult;
7039 }
7040
7041
7042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
7043   void * jresult ;
7044   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7045   float arg2 ;
7046   Dali::Radian *result = 0 ;
7047
7048   arg1 = (Dali::Radian *)jarg1;
7049   arg2 = (float)jarg2;
7050   {
7051     try {
7052       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7053     } CALL_CATCH_EXCEPTION(0);
7054   }
7055
7056   jresult = (void *)result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
7062   void * jresult ;
7063   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7064   Dali::Degree arg2 ;
7065   Dali::Degree *argp2 ;
7066   Dali::Radian *result = 0 ;
7067
7068   arg1 = (Dali::Radian *)jarg1;
7069   argp2 = (Dali::Degree *)jarg2;
7070   if (!argp2) {
7071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7072     return 0;
7073   }
7074   arg2 = *argp2;
7075   {
7076     try {
7077       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7078     } CALL_CATCH_EXCEPTION(0);
7079   }
7080
7081   jresult = (void *)result;
7082   return jresult;
7083 }
7084
7085
7086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
7087   float jresult ;
7088   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7089   float result;
7090
7091   arg1 = (Dali::Radian *)jarg1;
7092   {
7093     try {
7094       result = (float)((Dali::Radian const *)arg1)->operator float();
7095     } CALL_CATCH_EXCEPTION(0);
7096   }
7097
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
7104   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7105   float arg2 ;
7106
7107   arg1 = (Dali::Radian *)jarg1;
7108   arg2 = (float)jarg2;
7109   if (arg1) (arg1)->radian = arg2;
7110 }
7111
7112
7113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
7114   float jresult ;
7115   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7116   float result;
7117
7118   arg1 = (Dali::Radian *)jarg1;
7119   result = (float) ((arg1)->radian);
7120   jresult = result;
7121   return jresult;
7122 }
7123
7124
7125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
7126   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7127
7128   arg1 = (Dali::Radian *)jarg1;
7129   {
7130     try {
7131       delete arg1;
7132     } CALL_CATCH_EXCEPTION();
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7139   unsigned int jresult ;
7140   Dali::Radian arg1 ;
7141   Dali::Radian arg2 ;
7142   Dali::Radian *argp1 ;
7143   Dali::Radian *argp2 ;
7144   bool result;
7145
7146   argp1 = (Dali::Radian *)jarg1;
7147   if (!argp1) {
7148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7149     return 0;
7150   }
7151   arg1 = *argp1;
7152   argp2 = (Dali::Radian *)jarg2;
7153   if (!argp2) {
7154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7155     return 0;
7156   }
7157   arg2 = *argp2;
7158   {
7159     try {
7160       result = (bool)Dali::operator ==(arg1,arg2);
7161     } CALL_CATCH_EXCEPTION(0);
7162   }
7163
7164   jresult = result;
7165   return jresult;
7166 }
7167
7168
7169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7170   unsigned int jresult ;
7171   Dali::Radian arg1 ;
7172   Dali::Radian arg2 ;
7173   Dali::Radian *argp1 ;
7174   Dali::Radian *argp2 ;
7175   bool result;
7176
7177   argp1 = (Dali::Radian *)jarg1;
7178   if (!argp1) {
7179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7180     return 0;
7181   }
7182   arg1 = *argp1;
7183   argp2 = (Dali::Radian *)jarg2;
7184   if (!argp2) {
7185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7186     return 0;
7187   }
7188   arg2 = *argp2;
7189   {
7190     try {
7191       result = (bool)Dali::operator !=(arg1,arg2);
7192     } CALL_CATCH_EXCEPTION(0);
7193   }
7194
7195   jresult = result;
7196   return jresult;
7197 }
7198
7199
7200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7201   unsigned int jresult ;
7202   Dali::Radian arg1 ;
7203   Dali::Degree arg2 ;
7204   Dali::Radian *argp1 ;
7205   Dali::Degree *argp2 ;
7206   bool result;
7207
7208   argp1 = (Dali::Radian *)jarg1;
7209   if (!argp1) {
7210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7211     return 0;
7212   }
7213   arg1 = *argp1;
7214   argp2 = (Dali::Degree *)jarg2;
7215   if (!argp2) {
7216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7217     return 0;
7218   }
7219   arg2 = *argp2;
7220   {
7221     try {
7222       result = (bool)Dali::operator ==(arg1,arg2);
7223     } CALL_CATCH_EXCEPTION(0);
7224   }
7225
7226   jresult = result;
7227   return jresult;
7228 }
7229
7230
7231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7232   unsigned int jresult ;
7233   Dali::Radian arg1 ;
7234   Dali::Degree arg2 ;
7235   Dali::Radian *argp1 ;
7236   Dali::Degree *argp2 ;
7237   bool result;
7238
7239   argp1 = (Dali::Radian *)jarg1;
7240   if (!argp1) {
7241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7242     return 0;
7243   }
7244   arg1 = *argp1;
7245   argp2 = (Dali::Degree *)jarg2;
7246   if (!argp2) {
7247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7248     return 0;
7249   }
7250   arg2 = *argp2;
7251   {
7252     try {
7253       result = (bool)Dali::operator !=(arg1,arg2);
7254     } CALL_CATCH_EXCEPTION(0);
7255   }
7256
7257   jresult = result;
7258   return jresult;
7259 }
7260
7261
7262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7263   unsigned int jresult ;
7264   Dali::Degree arg1 ;
7265   Dali::Radian arg2 ;
7266   Dali::Degree *argp1 ;
7267   Dali::Radian *argp2 ;
7268   bool result;
7269
7270   argp1 = (Dali::Degree *)jarg1;
7271   if (!argp1) {
7272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7273     return 0;
7274   }
7275   arg1 = *argp1;
7276   argp2 = (Dali::Radian *)jarg2;
7277   if (!argp2) {
7278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7279     return 0;
7280   }
7281   arg2 = *argp2;
7282   {
7283     try {
7284       result = (bool)Dali::operator ==(arg1,arg2);
7285     } CALL_CATCH_EXCEPTION(0);
7286   }
7287
7288   jresult = result;
7289   return jresult;
7290 }
7291
7292
7293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7294   unsigned int jresult ;
7295   Dali::Degree arg1 ;
7296   Dali::Radian arg2 ;
7297   Dali::Degree *argp1 ;
7298   Dali::Radian *argp2 ;
7299   bool result;
7300
7301   argp1 = (Dali::Degree *)jarg1;
7302   if (!argp1) {
7303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7304     return 0;
7305   }
7306   arg1 = *argp1;
7307   argp2 = (Dali::Radian *)jarg2;
7308   if (!argp2) {
7309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7310     return 0;
7311   }
7312   arg2 = *argp2;
7313   {
7314     try {
7315       result = (bool)Dali::operator !=(arg1,arg2);
7316     } CALL_CATCH_EXCEPTION(0);
7317   }
7318
7319   jresult = result;
7320   return jresult;
7321 }
7322
7323
7324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7325   unsigned int jresult ;
7326   Dali::Radian arg1 ;
7327   Dali::Radian arg2 ;
7328   Dali::Radian *argp1 ;
7329   Dali::Radian *argp2 ;
7330   bool result;
7331
7332   argp1 = (Dali::Radian *)jarg1;
7333   if (!argp1) {
7334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7335     return 0;
7336   }
7337   arg1 = *argp1;
7338   argp2 = (Dali::Radian *)jarg2;
7339   if (!argp2) {
7340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7341     return 0;
7342   }
7343   arg2 = *argp2;
7344   {
7345     try {
7346       result = (bool)Dali::operator >(arg1,arg2);
7347     } CALL_CATCH_EXCEPTION(0);
7348   }
7349
7350   jresult = result;
7351   return jresult;
7352 }
7353
7354
7355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7356   unsigned int jresult ;
7357   Dali::Radian arg1 ;
7358   Dali::Degree arg2 ;
7359   Dali::Radian *argp1 ;
7360   Dali::Degree *argp2 ;
7361   bool result;
7362
7363   argp1 = (Dali::Radian *)jarg1;
7364   if (!argp1) {
7365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7366     return 0;
7367   }
7368   arg1 = *argp1;
7369   argp2 = (Dali::Degree *)jarg2;
7370   if (!argp2) {
7371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7372     return 0;
7373   }
7374   arg2 = *argp2;
7375   {
7376     try {
7377       result = (bool)Dali::operator >(arg1,arg2);
7378     } CALL_CATCH_EXCEPTION(0);
7379   }
7380
7381   jresult = result;
7382   return jresult;
7383 }
7384
7385
7386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7387   unsigned int jresult ;
7388   Dali::Degree arg1 ;
7389   Dali::Radian arg2 ;
7390   Dali::Degree *argp1 ;
7391   Dali::Radian *argp2 ;
7392   bool result;
7393
7394   argp1 = (Dali::Degree *)jarg1;
7395   if (!argp1) {
7396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7397     return 0;
7398   }
7399   arg1 = *argp1;
7400   argp2 = (Dali::Radian *)jarg2;
7401   if (!argp2) {
7402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7403     return 0;
7404   }
7405   arg2 = *argp2;
7406   {
7407     try {
7408       result = (bool)Dali::operator >(arg1,arg2);
7409     } CALL_CATCH_EXCEPTION(0);
7410   }
7411
7412   jresult = result;
7413   return jresult;
7414 }
7415
7416
7417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7418   unsigned int jresult ;
7419   Dali::Radian arg1 ;
7420   Dali::Radian arg2 ;
7421   Dali::Radian *argp1 ;
7422   Dali::Radian *argp2 ;
7423   bool result;
7424
7425   argp1 = (Dali::Radian *)jarg1;
7426   if (!argp1) {
7427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7428     return 0;
7429   }
7430   arg1 = *argp1;
7431   argp2 = (Dali::Radian *)jarg2;
7432   if (!argp2) {
7433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7434     return 0;
7435   }
7436   arg2 = *argp2;
7437   {
7438     try {
7439       result = (bool)Dali::operator <(arg1,arg2);
7440     } CALL_CATCH_EXCEPTION(0);
7441   }
7442
7443   jresult = result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7449   unsigned int jresult ;
7450   Dali::Radian arg1 ;
7451   Dali::Degree arg2 ;
7452   Dali::Radian *argp1 ;
7453   Dali::Degree *argp2 ;
7454   bool result;
7455
7456   argp1 = (Dali::Radian *)jarg1;
7457   if (!argp1) {
7458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7459     return 0;
7460   }
7461   arg1 = *argp1;
7462   argp2 = (Dali::Degree *)jarg2;
7463   if (!argp2) {
7464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7465     return 0;
7466   }
7467   arg2 = *argp2;
7468   {
7469     try {
7470       result = (bool)Dali::operator <(arg1,arg2);
7471     } CALL_CATCH_EXCEPTION(0);
7472   }
7473
7474   jresult = result;
7475   return jresult;
7476 }
7477
7478
7479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7480   unsigned int jresult ;
7481   Dali::Degree arg1 ;
7482   Dali::Radian arg2 ;
7483   Dali::Degree *argp1 ;
7484   Dali::Radian *argp2 ;
7485   bool result;
7486
7487   argp1 = (Dali::Degree *)jarg1;
7488   if (!argp1) {
7489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7490     return 0;
7491   }
7492   arg1 = *argp1;
7493   argp2 = (Dali::Radian *)jarg2;
7494   if (!argp2) {
7495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7496     return 0;
7497   }
7498   arg2 = *argp2;
7499   {
7500     try {
7501       result = (bool)Dali::operator <(arg1,arg2);
7502     } CALL_CATCH_EXCEPTION(0);
7503   }
7504
7505   jresult = result;
7506   return jresult;
7507 }
7508
7509
7510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7511   void * jresult ;
7512   Dali::Radian arg1 ;
7513   float arg2 ;
7514   Dali::Radian *argp1 ;
7515   Dali::Radian result;
7516
7517   argp1 = (Dali::Radian *)jarg1;
7518   if (!argp1) {
7519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7520     return 0;
7521   }
7522   arg1 = *argp1;
7523   arg2 = (float)jarg2;
7524   {
7525     try {
7526       result = Dali::operator *(arg1,arg2);
7527     } CALL_CATCH_EXCEPTION(0);
7528   }
7529
7530   jresult = new Dali::Radian((const Dali::Radian &)result);
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7536   void * jresult ;
7537   Dali::Radian arg1 ;
7538   Dali::Radian *argp1 ;
7539   Dali::Radian result;
7540
7541   argp1 = (Dali::Radian *)jarg1;
7542   if (!argp1) {
7543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7544     return 0;
7545   }
7546   arg1 = *argp1;
7547   {
7548     try {
7549       result = Dali::operator -(arg1);
7550     } CALL_CATCH_EXCEPTION(0);
7551   }
7552
7553   jresult = new Dali::Radian((const Dali::Radian &)result);
7554   return jresult;
7555 }
7556
7557
7558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7559   void * jresult ;
7560   Dali::Radian arg1 ;
7561   float arg2 ;
7562   float arg3 ;
7563   Dali::Radian *argp1 ;
7564   Dali::Radian result;
7565
7566   argp1 = (Dali::Radian *)jarg1;
7567   if (!argp1) {
7568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7569     return 0;
7570   }
7571   arg1 = *argp1;
7572   arg2 = (float)jarg2;
7573   arg3 = (float)jarg3;
7574   {
7575     try {
7576       result = Dali::Clamp(arg1,arg2,arg3);
7577     } CALL_CATCH_EXCEPTION(0);
7578   }
7579
7580   jresult = new Dali::Radian((const Dali::Radian &)result);
7581   return jresult;
7582 }
7583
7584
7585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
7586   void * jresult ;
7587   Dali::Quaternion *result = 0 ;
7588
7589   {
7590     try {
7591       result = (Dali::Quaternion *)new Dali::Quaternion();
7592     } CALL_CATCH_EXCEPTION(0);
7593   }
7594
7595   jresult = (void *)result;
7596   return jresult;
7597 }
7598
7599
7600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
7601   void * jresult ;
7602   Dali::Radian arg1 ;
7603   Dali::Vector3 *arg2 = 0 ;
7604   Dali::Radian *argp1 ;
7605   Dali::Quaternion *result = 0 ;
7606
7607   argp1 = (Dali::Radian *)jarg1;
7608   if (!argp1) {
7609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7610     return 0;
7611   }
7612   arg1 = *argp1;
7613   arg2 = (Dali::Vector3 *)jarg2;
7614   if (!arg2) {
7615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7616     return 0;
7617   }
7618   {
7619     try {
7620       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
7621     } CALL_CATCH_EXCEPTION(0);
7622   }
7623
7624   jresult = (void *)result;
7625   return jresult;
7626 }
7627
7628
7629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
7630   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7631
7632   arg1 = (Dali::Quaternion *)jarg1;
7633   {
7634     try {
7635       delete arg1;
7636     } CALL_CATCH_EXCEPTION();
7637   }
7638
7639 }
7640
7641
7642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
7643   void * jresult ;
7644   Dali::Quaternion *result = 0 ;
7645
7646   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
7647   jresult = (void *)result;
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
7653   unsigned int jresult ;
7654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7655   bool result;
7656
7657   arg1 = (Dali::Quaternion *)jarg1;
7658   {
7659     try {
7660       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
7661     } CALL_CATCH_EXCEPTION(0);
7662   }
7663
7664   jresult = result;
7665   return jresult;
7666 }
7667
7668
7669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
7670   unsigned int jresult ;
7671   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7672   Dali::Vector3 *arg2 = 0 ;
7673   Dali::Radian *arg3 = 0 ;
7674   bool result;
7675
7676   arg1 = (Dali::Quaternion *)jarg1;
7677   arg2 = (Dali::Vector3 *)jarg2;
7678   if (!arg2) {
7679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7680     return 0;
7681   }
7682   arg3 = (Dali::Radian *)jarg3;
7683   if (!arg3) {
7684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
7685     return 0;
7686   }
7687   {
7688     try {
7689       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
7690     } CALL_CATCH_EXCEPTION(0);
7691   }
7692
7693   jresult = result;
7694   return jresult;
7695 }
7696
7697
7698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
7699   void * jresult ;
7700   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7701   Dali::Quaternion *arg2 = 0 ;
7702   Dali::Quaternion result;
7703
7704   arg1 = (Dali::Quaternion *)jarg1;
7705   arg2 = (Dali::Quaternion *)jarg2;
7706   if (!arg2) {
7707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7708     return 0;
7709   }
7710   {
7711     try {
7712       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
7713     } CALL_CATCH_EXCEPTION(0);
7714   }
7715
7716   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7717   return jresult;
7718 }
7719
7720
7721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7722   void * jresult ;
7723   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7724   Dali::Quaternion *arg2 = 0 ;
7725   Dali::Quaternion result;
7726
7727   arg1 = (Dali::Quaternion *)jarg1;
7728   arg2 = (Dali::Quaternion *)jarg2;
7729   if (!arg2) {
7730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7731     return 0;
7732   }
7733   {
7734     try {
7735       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
7736     } CALL_CATCH_EXCEPTION(0);
7737   }
7738
7739   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7740   return jresult;
7741 }
7742
7743
7744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7745   void * jresult ;
7746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7747   Dali::Quaternion *arg2 = 0 ;
7748   Dali::Quaternion result;
7749
7750   arg1 = (Dali::Quaternion *)jarg1;
7751   arg2 = (Dali::Quaternion *)jarg2;
7752   if (!arg2) {
7753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7754     return 0;
7755   }
7756   {
7757     try {
7758       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
7759     } CALL_CATCH_EXCEPTION(0);
7760   }
7761
7762   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
7768   void * jresult ;
7769   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7770   Dali::Vector3 *arg2 = 0 ;
7771   Dali::Vector3 result;
7772
7773   arg1 = (Dali::Quaternion *)jarg1;
7774   arg2 = (Dali::Vector3 *)jarg2;
7775   if (!arg2) {
7776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7777     return 0;
7778   }
7779   {
7780     try {
7781       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
7782     } CALL_CATCH_EXCEPTION(0);
7783   }
7784
7785   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7786   return jresult;
7787 }
7788
7789
7790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
7791   void * jresult ;
7792   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7793   Dali::Quaternion *arg2 = 0 ;
7794   Dali::Quaternion result;
7795
7796   arg1 = (Dali::Quaternion *)jarg1;
7797   arg2 = (Dali::Quaternion *)jarg2;
7798   if (!arg2) {
7799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7800     return 0;
7801   }
7802   {
7803     try {
7804       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
7805     } CALL_CATCH_EXCEPTION(0);
7806   }
7807
7808   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
7814   void * jresult ;
7815   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7816   float arg2 ;
7817   Dali::Quaternion result;
7818
7819   arg1 = (Dali::Quaternion *)jarg1;
7820   arg2 = (float)jarg2;
7821   {
7822     try {
7823       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
7824     } CALL_CATCH_EXCEPTION(0);
7825   }
7826
7827   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7828   return jresult;
7829 }
7830
7831
7832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
7833   void * jresult ;
7834   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7835   float arg2 ;
7836   Dali::Quaternion result;
7837
7838   arg1 = (Dali::Quaternion *)jarg1;
7839   arg2 = (float)jarg2;
7840   {
7841     try {
7842       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
7843     } CALL_CATCH_EXCEPTION(0);
7844   }
7845
7846   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7847   return jresult;
7848 }
7849
7850
7851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
7852   void * jresult ;
7853   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7854   Dali::Quaternion result;
7855
7856   arg1 = (Dali::Quaternion *)jarg1;
7857   {
7858     try {
7859       result = ((Dali::Quaternion const *)arg1)->operator -();
7860     } CALL_CATCH_EXCEPTION(0);
7861   }
7862
7863   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7864   return jresult;
7865 }
7866
7867
7868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
7869   void * jresult ;
7870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7871   Dali::Quaternion *arg2 = 0 ;
7872   Dali::Quaternion *result = 0 ;
7873
7874   arg1 = (Dali::Quaternion *)jarg1;
7875   arg2 = (Dali::Quaternion *)jarg2;
7876   if (!arg2) {
7877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7878     return 0;
7879   }
7880   {
7881     try {
7882       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
7883     } CALL_CATCH_EXCEPTION(0);
7884   }
7885
7886   jresult = (void *)result;
7887   return jresult;
7888 }
7889
7890
7891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
7892   void * jresult ;
7893   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7894   Dali::Quaternion *arg2 = 0 ;
7895   Dali::Quaternion *result = 0 ;
7896
7897   arg1 = (Dali::Quaternion *)jarg1;
7898   arg2 = (Dali::Quaternion *)jarg2;
7899   if (!arg2) {
7900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7901     return 0;
7902   }
7903   {
7904     try {
7905       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
7906     } CALL_CATCH_EXCEPTION(0);
7907   }
7908
7909   jresult = (void *)result;
7910   return jresult;
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7915   void * jresult ;
7916   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7917   Dali::Quaternion *arg2 = 0 ;
7918   Dali::Quaternion *result = 0 ;
7919
7920   arg1 = (Dali::Quaternion *)jarg1;
7921   arg2 = (Dali::Quaternion *)jarg2;
7922   if (!arg2) {
7923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7924     return 0;
7925   }
7926   {
7927     try {
7928       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
7929     } CALL_CATCH_EXCEPTION(0);
7930   }
7931
7932   jresult = (void *)result;
7933   return jresult;
7934 }
7935
7936
7937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7938   void * jresult ;
7939   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7940   float arg2 ;
7941   Dali::Quaternion *result = 0 ;
7942
7943   arg1 = (Dali::Quaternion *)jarg1;
7944   arg2 = (float)jarg2;
7945   {
7946     try {
7947       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
7948     } CALL_CATCH_EXCEPTION(0);
7949   }
7950
7951   jresult = (void *)result;
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7959   float arg2 ;
7960   Dali::Quaternion *result = 0 ;
7961
7962   arg1 = (Dali::Quaternion *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
7967     } CALL_CATCH_EXCEPTION(0);
7968   }
7969
7970   jresult = (void *)result;
7971   return jresult;
7972 }
7973
7974
7975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
7976   unsigned int jresult ;
7977   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7978   Dali::Quaternion *arg2 = 0 ;
7979   bool result;
7980
7981   arg1 = (Dali::Quaternion *)jarg1;
7982   arg2 = (Dali::Quaternion *)jarg2;
7983   if (!arg2) {
7984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7985     return 0;
7986   }
7987   {
7988     try {
7989       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
7990     } CALL_CATCH_EXCEPTION(0);
7991   }
7992
7993   jresult = result;
7994   return jresult;
7995 }
7996
7997
7998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
7999   unsigned int jresult ;
8000   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8001   Dali::Quaternion *arg2 = 0 ;
8002   bool result;
8003
8004   arg1 = (Dali::Quaternion *)jarg1;
8005   arg2 = (Dali::Quaternion *)jarg2;
8006   if (!arg2) {
8007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8008     return 0;
8009   }
8010   {
8011     try {
8012       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
8013     } CALL_CATCH_EXCEPTION(0);
8014   }
8015
8016   jresult = result;
8017   return jresult;
8018 }
8019
8020
8021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
8022   float jresult ;
8023   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8024   float result;
8025
8026   arg1 = (Dali::Quaternion *)jarg1;
8027   {
8028     try {
8029       result = (float)((Dali::Quaternion const *)arg1)->Length();
8030     } CALL_CATCH_EXCEPTION(0);
8031   }
8032
8033   jresult = result;
8034   return jresult;
8035 }
8036
8037
8038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
8039   float jresult ;
8040   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8041   float result;
8042
8043   arg1 = (Dali::Quaternion *)jarg1;
8044   {
8045     try {
8046       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
8047     } CALL_CATCH_EXCEPTION(0);
8048   }
8049
8050   jresult = result;
8051   return jresult;
8052 }
8053
8054
8055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
8056   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8057
8058   arg1 = (Dali::Quaternion *)jarg1;
8059   {
8060     try {
8061       (arg1)->Normalize();
8062     } CALL_CATCH_EXCEPTION();
8063   }
8064
8065 }
8066
8067
8068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
8069   void * jresult ;
8070   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8071   Dali::Quaternion result;
8072
8073   arg1 = (Dali::Quaternion *)jarg1;
8074   {
8075     try {
8076       result = ((Dali::Quaternion const *)arg1)->Normalized();
8077     } CALL_CATCH_EXCEPTION(0);
8078   }
8079
8080   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8081   return jresult;
8082 }
8083
8084
8085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
8086   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8087
8088   arg1 = (Dali::Quaternion *)jarg1;
8089   {
8090     try {
8091       (arg1)->Conjugate();
8092     } CALL_CATCH_EXCEPTION();
8093   }
8094
8095 }
8096
8097
8098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
8099   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8100
8101   arg1 = (Dali::Quaternion *)jarg1;
8102   {
8103     try {
8104       (arg1)->Invert();
8105     } CALL_CATCH_EXCEPTION();
8106   }
8107
8108 }
8109
8110
8111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
8112   void * jresult ;
8113   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8114   Dali::Quaternion result;
8115
8116   arg1 = (Dali::Quaternion *)jarg1;
8117   {
8118     try {
8119       result = ((Dali::Quaternion const *)arg1)->Log();
8120     } CALL_CATCH_EXCEPTION(0);
8121   }
8122
8123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8124   return jresult;
8125 }
8126
8127
8128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
8129   void * jresult ;
8130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8131   Dali::Quaternion result;
8132
8133   arg1 = (Dali::Quaternion *)jarg1;
8134   {
8135     try {
8136       result = ((Dali::Quaternion const *)arg1)->Exp();
8137     } CALL_CATCH_EXCEPTION(0);
8138   }
8139
8140   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8141   return jresult;
8142 }
8143
8144
8145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
8146   float jresult ;
8147   Dali::Quaternion *arg1 = 0 ;
8148   Dali::Quaternion *arg2 = 0 ;
8149   float result;
8150
8151   arg1 = (Dali::Quaternion *)jarg1;
8152   if (!arg1) {
8153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8154     return 0;
8155   }
8156   arg2 = (Dali::Quaternion *)jarg2;
8157   if (!arg2) {
8158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8159     return 0;
8160   }
8161   {
8162     try {
8163       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8164     } CALL_CATCH_EXCEPTION(0);
8165   }
8166
8167   jresult = result;
8168   return jresult;
8169 }
8170
8171
8172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
8173   void * jresult ;
8174   Dali::Quaternion *arg1 = 0 ;
8175   Dali::Quaternion *arg2 = 0 ;
8176   float arg3 ;
8177   Dali::Quaternion result;
8178
8179   arg1 = (Dali::Quaternion *)jarg1;
8180   if (!arg1) {
8181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8182     return 0;
8183   }
8184   arg2 = (Dali::Quaternion *)jarg2;
8185   if (!arg2) {
8186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8187     return 0;
8188   }
8189   arg3 = (float)jarg3;
8190   {
8191     try {
8192       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8193     } CALL_CATCH_EXCEPTION(0);
8194   }
8195
8196   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8197   return jresult;
8198 }
8199
8200
8201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
8202   void * jresult ;
8203   Dali::Quaternion *arg1 = 0 ;
8204   Dali::Quaternion *arg2 = 0 ;
8205   float arg3 ;
8206   Dali::Quaternion result;
8207
8208   arg1 = (Dali::Quaternion *)jarg1;
8209   if (!arg1) {
8210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8211     return 0;
8212   }
8213   arg2 = (Dali::Quaternion *)jarg2;
8214   if (!arg2) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8216     return 0;
8217   }
8218   arg3 = (float)jarg3;
8219   {
8220     try {
8221       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8222     } CALL_CATCH_EXCEPTION(0);
8223   }
8224
8225   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8226   return jresult;
8227 }
8228
8229
8230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
8231   void * jresult ;
8232   Dali::Quaternion *arg1 = 0 ;
8233   Dali::Quaternion *arg2 = 0 ;
8234   float arg3 ;
8235   Dali::Quaternion result;
8236
8237   arg1 = (Dali::Quaternion *)jarg1;
8238   if (!arg1) {
8239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8240     return 0;
8241   }
8242   arg2 = (Dali::Quaternion *)jarg2;
8243   if (!arg2) {
8244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8245     return 0;
8246   }
8247   arg3 = (float)jarg3;
8248   {
8249     try {
8250       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8251     } CALL_CATCH_EXCEPTION(0);
8252   }
8253
8254   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8255   return jresult;
8256 }
8257
8258
8259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
8260   void * jresult ;
8261   Dali::Quaternion *arg1 = 0 ;
8262   Dali::Quaternion *arg2 = 0 ;
8263   Dali::Quaternion *arg3 = 0 ;
8264   Dali::Quaternion *arg4 = 0 ;
8265   float arg5 ;
8266   Dali::Quaternion result;
8267
8268   arg1 = (Dali::Quaternion *)jarg1;
8269   if (!arg1) {
8270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8271     return 0;
8272   }
8273   arg2 = (Dali::Quaternion *)jarg2;
8274   if (!arg2) {
8275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8276     return 0;
8277   }
8278   arg3 = (Dali::Quaternion *)jarg3;
8279   if (!arg3) {
8280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8281     return 0;
8282   }
8283   arg4 = (Dali::Quaternion *)jarg4;
8284   if (!arg4) {
8285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8286     return 0;
8287   }
8288   arg5 = (float)jarg5;
8289   {
8290     try {
8291       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
8292     } CALL_CATCH_EXCEPTION(0);
8293   }
8294
8295   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8296   return jresult;
8297 }
8298
8299
8300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
8301   float jresult ;
8302   Dali::Quaternion *arg1 = 0 ;
8303   Dali::Quaternion *arg2 = 0 ;
8304   float result;
8305
8306   arg1 = (Dali::Quaternion *)jarg1;
8307   if (!arg1) {
8308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8309     return 0;
8310   }
8311   arg2 = (Dali::Quaternion *)jarg2;
8312   if (!arg2) {
8313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8314     return 0;
8315   }
8316   {
8317     try {
8318       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8319     } CALL_CATCH_EXCEPTION(0);
8320   }
8321
8322   jresult = result;
8323   return jresult;
8324 }
8325
8326
8327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
8328   void * jresult ;
8329   Dali::Matrix *result = 0 ;
8330
8331   {
8332     try {
8333       result = (Dali::Matrix *)new Dali::Matrix();
8334     } CALL_CATCH_EXCEPTION(0);
8335   }
8336
8337   jresult = (void *)result;
8338   return jresult;
8339 }
8340
8341
8342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
8343   void * jresult ;
8344   bool arg1 ;
8345   Dali::Matrix *result = 0 ;
8346
8347   arg1 = jarg1 ? true : false;
8348   {
8349     try {
8350       result = (Dali::Matrix *)new Dali::Matrix(arg1);
8351     } CALL_CATCH_EXCEPTION(0);
8352   }
8353
8354   jresult = (void *)result;
8355   return jresult;
8356 }
8357
8358
8359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
8360   void * jresult ;
8361   float *arg1 = (float *) 0 ;
8362   Dali::Matrix *result = 0 ;
8363
8364   arg1 = jarg1;
8365   {
8366     try {
8367       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
8368     } CALL_CATCH_EXCEPTION(0);
8369   }
8370
8371   jresult = (void *)result;
8372
8373
8374   return jresult;
8375 }
8376
8377
8378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
8379   void * jresult ;
8380   Dali::Quaternion *arg1 = 0 ;
8381   Dali::Matrix *result = 0 ;
8382
8383   arg1 = (Dali::Quaternion *)jarg1;
8384   if (!arg1) {
8385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8386     return 0;
8387   }
8388   {
8389     try {
8390       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
8391     } CALL_CATCH_EXCEPTION(0);
8392   }
8393
8394   jresult = (void *)result;
8395   return jresult;
8396 }
8397
8398
8399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
8400   void * jresult ;
8401   Dali::Matrix *arg1 = 0 ;
8402   Dali::Matrix *result = 0 ;
8403
8404   arg1 = (Dali::Matrix *)jarg1;
8405   if (!arg1) {
8406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8407     return 0;
8408   }
8409   {
8410     try {
8411       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
8412     } CALL_CATCH_EXCEPTION(0);
8413   }
8414
8415   jresult = (void *)result;
8416   return jresult;
8417 }
8418
8419
8420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
8421   void * jresult ;
8422   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8423   Dali::Matrix *arg2 = 0 ;
8424   Dali::Matrix *result = 0 ;
8425
8426   arg1 = (Dali::Matrix *)jarg1;
8427   arg2 = (Dali::Matrix *)jarg2;
8428   if (!arg2) {
8429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8430     return 0;
8431   }
8432   {
8433     try {
8434       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8435     } CALL_CATCH_EXCEPTION(0);
8436   }
8437
8438   jresult = (void *)result;
8439   return jresult;
8440 }
8441
8442
8443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
8444   void * jresult ;
8445   Dali::Matrix *result = 0 ;
8446
8447   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
8448   jresult = (void *)result;
8449   return jresult;
8450 }
8451
8452
8453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
8454   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8455
8456   arg1 = (Dali::Matrix *)jarg1;
8457   {
8458     try {
8459       (arg1)->SetIdentity();
8460     } CALL_CATCH_EXCEPTION();
8461   }
8462
8463 }
8464
8465
8466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
8467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8468   Dali::Vector3 *arg2 = 0 ;
8469
8470   arg1 = (Dali::Matrix *)jarg1;
8471   arg2 = (Dali::Vector3 *)jarg2;
8472   if (!arg2) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8474     return ;
8475   }
8476   {
8477     try {
8478       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
8479     } CALL_CATCH_EXCEPTION();
8480   }
8481
8482 }
8483
8484
8485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
8486   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8487   Dali::Matrix *arg2 = 0 ;
8488
8489   arg1 = (Dali::Matrix *)jarg1;
8490   arg2 = (Dali::Matrix *)jarg2;
8491   if (!arg2) {
8492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8493     return ;
8494   }
8495   {
8496     try {
8497       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
8498     } CALL_CATCH_EXCEPTION();
8499   }
8500
8501 }
8502
8503
8504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
8505   unsigned int jresult ;
8506   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8507   bool result;
8508
8509   arg1 = (Dali::Matrix *)jarg1;
8510   {
8511     try {
8512       result = (bool)(arg1)->Invert();
8513     } CALL_CATCH_EXCEPTION(0);
8514   }
8515
8516   jresult = result;
8517   return jresult;
8518 }
8519
8520
8521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
8522   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8523
8524   arg1 = (Dali::Matrix *)jarg1;
8525   {
8526     try {
8527       (arg1)->Transpose();
8528     } CALL_CATCH_EXCEPTION();
8529   }
8530
8531 }
8532
8533
8534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
8535   void * jresult ;
8536   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8537   Dali::Vector3 result;
8538
8539   arg1 = (Dali::Matrix *)jarg1;
8540   {
8541     try {
8542       result = ((Dali::Matrix const *)arg1)->GetXAxis();
8543     } CALL_CATCH_EXCEPTION(0);
8544   }
8545
8546   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8547   return jresult;
8548 }
8549
8550
8551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
8552   void * jresult ;
8553   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8554   Dali::Vector3 result;
8555
8556   arg1 = (Dali::Matrix *)jarg1;
8557   {
8558     try {
8559       result = ((Dali::Matrix const *)arg1)->GetYAxis();
8560     } CALL_CATCH_EXCEPTION(0);
8561   }
8562
8563   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8564   return jresult;
8565 }
8566
8567
8568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(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)->GetZAxis();
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_SetXAxis(void * jarg1, void * jarg2) {
8586   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8587   Dali::Vector3 *arg2 = 0 ;
8588
8589   arg1 = (Dali::Matrix *)jarg1;
8590   arg2 = (Dali::Vector3 *)jarg2;
8591   if (!arg2) {
8592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8593     return ;
8594   }
8595   {
8596     try {
8597       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
8598     } CALL_CATCH_EXCEPTION();
8599   }
8600
8601 }
8602
8603
8604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
8605   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8606   Dali::Vector3 *arg2 = 0 ;
8607
8608   arg1 = (Dali::Matrix *)jarg1;
8609   arg2 = (Dali::Vector3 *)jarg2;
8610   if (!arg2) {
8611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8612     return ;
8613   }
8614   {
8615     try {
8616       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
8617     } CALL_CATCH_EXCEPTION();
8618   }
8619
8620 }
8621
8622
8623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
8624   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8625   Dali::Vector3 *arg2 = 0 ;
8626
8627   arg1 = (Dali::Matrix *)jarg1;
8628   arg2 = (Dali::Vector3 *)jarg2;
8629   if (!arg2) {
8630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8631     return ;
8632   }
8633   {
8634     try {
8635       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
8636     } CALL_CATCH_EXCEPTION();
8637   }
8638
8639 }
8640
8641
8642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
8643   void * jresult ;
8644   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8645   Dali::Vector4 *result = 0 ;
8646
8647   arg1 = (Dali::Matrix *)jarg1;
8648   {
8649     try {
8650       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
8651     } CALL_CATCH_EXCEPTION(0);
8652   }
8653
8654   jresult = (void *)result;
8655   return jresult;
8656 }
8657
8658
8659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
8660   void * jresult ;
8661   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8662   Dali::Vector3 *result = 0 ;
8663
8664   arg1 = (Dali::Matrix *)jarg1;
8665   {
8666     try {
8667       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
8668     } CALL_CATCH_EXCEPTION(0);
8669   }
8670
8671   jresult = (void *)result;
8672   return jresult;
8673 }
8674
8675
8676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
8677   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8678   Dali::Vector4 *arg2 = 0 ;
8679
8680   arg1 = (Dali::Matrix *)jarg1;
8681   arg2 = (Dali::Vector4 *)jarg2;
8682   if (!arg2) {
8683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8684     return ;
8685   }
8686   {
8687     try {
8688       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
8689     } CALL_CATCH_EXCEPTION();
8690   }
8691
8692 }
8693
8694
8695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
8696   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8697   Dali::Vector3 *arg2 = 0 ;
8698
8699   arg1 = (Dali::Matrix *)jarg1;
8700   arg2 = (Dali::Vector3 *)jarg2;
8701   if (!arg2) {
8702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8703     return ;
8704   }
8705   {
8706     try {
8707       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
8708     } CALL_CATCH_EXCEPTION();
8709   }
8710
8711 }
8712
8713
8714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
8715   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8716
8717   arg1 = (Dali::Matrix *)jarg1;
8718   {
8719     try {
8720       (arg1)->OrthoNormalize();
8721     } CALL_CATCH_EXCEPTION();
8722   }
8723
8724 }
8725
8726
8727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
8728   void * jresult ;
8729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8730   float *result = 0 ;
8731
8732   arg1 = (Dali::Matrix *)jarg1;
8733   {
8734     try {
8735       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
8736     } CALL_CATCH_EXCEPTION(0);
8737   }
8738
8739   jresult = (void *)result;
8740   return jresult;
8741 }
8742
8743
8744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
8745   Dali::Matrix *arg1 = 0 ;
8746   Dali::Matrix *arg2 = 0 ;
8747   Dali::Matrix *arg3 = 0 ;
8748
8749   arg1 = (Dali::Matrix *)jarg1;
8750   if (!arg1) {
8751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8752     return ;
8753   }
8754   arg2 = (Dali::Matrix *)jarg2;
8755   if (!arg2) {
8756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8757     return ;
8758   }
8759   arg3 = (Dali::Matrix *)jarg3;
8760   if (!arg3) {
8761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8762     return ;
8763   }
8764   {
8765     try {
8766       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
8767     } CALL_CATCH_EXCEPTION();
8768   }
8769
8770 }
8771
8772
8773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
8774   Dali::Matrix *arg1 = 0 ;
8775   Dali::Matrix *arg2 = 0 ;
8776   Dali::Quaternion *arg3 = 0 ;
8777
8778   arg1 = (Dali::Matrix *)jarg1;
8779   if (!arg1) {
8780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8781     return ;
8782   }
8783   arg2 = (Dali::Matrix *)jarg2;
8784   if (!arg2) {
8785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8786     return ;
8787   }
8788   arg3 = (Dali::Quaternion *)jarg3;
8789   if (!arg3) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8791     return ;
8792   }
8793   {
8794     try {
8795       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
8796     } CALL_CATCH_EXCEPTION();
8797   }
8798
8799 }
8800
8801
8802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
8803   void * jresult ;
8804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8805   Dali::Vector4 *arg2 = 0 ;
8806   Dali::Vector4 result;
8807
8808   arg1 = (Dali::Matrix *)jarg1;
8809   arg2 = (Dali::Vector4 *)jarg2;
8810   if (!arg2) {
8811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8812     return 0;
8813   }
8814   {
8815     try {
8816       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
8817     } CALL_CATCH_EXCEPTION(0);
8818   }
8819
8820   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8826   unsigned int jresult ;
8827   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8828   Dali::Matrix *arg2 = 0 ;
8829   bool result;
8830
8831   arg1 = (Dali::Matrix *)jarg1;
8832   arg2 = (Dali::Matrix *)jarg2;
8833   if (!arg2) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8835     return 0;
8836   }
8837   {
8838     try {
8839       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8840     } CALL_CATCH_EXCEPTION(0);
8841   }
8842
8843   jresult = result;
8844   return jresult;
8845 }
8846
8847
8848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8849   unsigned int jresult ;
8850   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8851   Dali::Matrix *arg2 = 0 ;
8852   bool result;
8853
8854   arg1 = (Dali::Matrix *)jarg1;
8855   arg2 = (Dali::Matrix *)jarg2;
8856   if (!arg2) {
8857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8858     return 0;
8859   }
8860   {
8861     try {
8862       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8863     } CALL_CATCH_EXCEPTION(0);
8864   }
8865
8866   jresult = result;
8867   return jresult;
8868 }
8869
8870
8871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8872   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8873   Dali::Vector3 *arg2 = 0 ;
8874   Dali::Quaternion *arg3 = 0 ;
8875   Dali::Vector3 *arg4 = 0 ;
8876
8877   arg1 = (Dali::Matrix *)jarg1;
8878   arg2 = (Dali::Vector3 *)jarg2;
8879   if (!arg2) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8881     return ;
8882   }
8883   arg3 = (Dali::Quaternion *)jarg3;
8884   if (!arg3) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8886     return ;
8887   }
8888   arg4 = (Dali::Vector3 *)jarg4;
8889   if (!arg4) {
8890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8891     return ;
8892   }
8893   {
8894     try {
8895       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8896     } CALL_CATCH_EXCEPTION();
8897   }
8898
8899 }
8900
8901
8902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8904   Dali::Vector3 *arg2 = 0 ;
8905   Dali::Quaternion *arg3 = 0 ;
8906   Dali::Vector3 *arg4 = 0 ;
8907
8908   arg1 = (Dali::Matrix *)jarg1;
8909   arg2 = (Dali::Vector3 *)jarg2;
8910   if (!arg2) {
8911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8912     return ;
8913   }
8914   arg3 = (Dali::Quaternion *)jarg3;
8915   if (!arg3) {
8916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8917     return ;
8918   }
8919   arg4 = (Dali::Vector3 *)jarg4;
8920   if (!arg4) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8922     return ;
8923   }
8924   {
8925     try {
8926       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8927     } CALL_CATCH_EXCEPTION();
8928   }
8929
8930 }
8931
8932
8933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8935   Dali::Vector3 *arg2 = 0 ;
8936   Dali::Vector3 *arg3 = 0 ;
8937   Dali::Vector3 *arg4 = 0 ;
8938   Dali::Vector3 *arg5 = 0 ;
8939
8940   arg1 = (Dali::Matrix *)jarg1;
8941   arg2 = (Dali::Vector3 *)jarg2;
8942   if (!arg2) {
8943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8944     return ;
8945   }
8946   arg3 = (Dali::Vector3 *)jarg3;
8947   if (!arg3) {
8948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8949     return ;
8950   }
8951   arg4 = (Dali::Vector3 *)jarg4;
8952   if (!arg4) {
8953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8954     return ;
8955   }
8956   arg5 = (Dali::Vector3 *)jarg5;
8957   if (!arg5) {
8958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8959     return ;
8960   }
8961   {
8962     try {
8963       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8964     } CALL_CATCH_EXCEPTION();
8965   }
8966
8967 }
8968
8969
8970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8971   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8972   Dali::Vector3 *arg2 = 0 ;
8973   Dali::Quaternion *arg3 = 0 ;
8974   Dali::Vector3 *arg4 = 0 ;
8975
8976   arg1 = (Dali::Matrix *)jarg1;
8977   arg2 = (Dali::Vector3 *)jarg2;
8978   if (!arg2) {
8979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8980     return ;
8981   }
8982   arg3 = (Dali::Quaternion *)jarg3;
8983   if (!arg3) {
8984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8985     return ;
8986   }
8987   arg4 = (Dali::Vector3 *)jarg4;
8988   if (!arg4) {
8989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8990     return ;
8991   }
8992   {
8993     try {
8994       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8995     } CALL_CATCH_EXCEPTION();
8996   }
8997
8998 }
8999
9000
9001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
9002   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9003
9004   arg1 = (Dali::Matrix *)jarg1;
9005   {
9006     try {
9007       delete arg1;
9008     } CALL_CATCH_EXCEPTION();
9009   }
9010
9011 }
9012
9013
9014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
9015   void * jresult ;
9016   Dali::Matrix3 *result = 0 ;
9017
9018   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
9019   jresult = (void *)result;
9020   return jresult;
9021 }
9022
9023
9024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
9025   void * jresult ;
9026   Dali::Matrix3 *result = 0 ;
9027
9028   {
9029     try {
9030       result = (Dali::Matrix3 *)new Dali::Matrix3();
9031     } CALL_CATCH_EXCEPTION(0);
9032   }
9033
9034   jresult = (void *)result;
9035   return jresult;
9036 }
9037
9038
9039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
9040   void * jresult ;
9041   Dali::Matrix3 *arg1 = 0 ;
9042   Dali::Matrix3 *result = 0 ;
9043
9044   arg1 = (Dali::Matrix3 *)jarg1;
9045   if (!arg1) {
9046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9047     return 0;
9048   }
9049   {
9050     try {
9051       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
9052     } CALL_CATCH_EXCEPTION(0);
9053   }
9054
9055   jresult = (void *)result;
9056   return jresult;
9057 }
9058
9059
9060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
9061   void * jresult ;
9062   Dali::Matrix *arg1 = 0 ;
9063   Dali::Matrix3 *result = 0 ;
9064
9065   arg1 = (Dali::Matrix *)jarg1;
9066   if (!arg1) {
9067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9068     return 0;
9069   }
9070   {
9071     try {
9072       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
9073     } CALL_CATCH_EXCEPTION(0);
9074   }
9075
9076   jresult = (void *)result;
9077   return jresult;
9078 }
9079
9080
9081 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) {
9082   void * jresult ;
9083   float arg1 ;
9084   float arg2 ;
9085   float arg3 ;
9086   float arg4 ;
9087   float arg5 ;
9088   float arg6 ;
9089   float arg7 ;
9090   float arg8 ;
9091   float arg9 ;
9092   Dali::Matrix3 *result = 0 ;
9093
9094   arg1 = (float)jarg1;
9095   arg2 = (float)jarg2;
9096   arg3 = (float)jarg3;
9097   arg4 = (float)jarg4;
9098   arg5 = (float)jarg5;
9099   arg6 = (float)jarg6;
9100   arg7 = (float)jarg7;
9101   arg8 = (float)jarg8;
9102   arg9 = (float)jarg9;
9103   {
9104     try {
9105       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
9106     } CALL_CATCH_EXCEPTION(0);
9107   }
9108
9109   jresult = (void *)result;
9110   return jresult;
9111 }
9112
9113
9114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
9115   void * jresult ;
9116   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9117   Dali::Matrix3 *arg2 = 0 ;
9118   Dali::Matrix3 *result = 0 ;
9119
9120   arg1 = (Dali::Matrix3 *)jarg1;
9121   arg2 = (Dali::Matrix3 *)jarg2;
9122   if (!arg2) {
9123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9124     return 0;
9125   }
9126   {
9127     try {
9128       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
9129     } CALL_CATCH_EXCEPTION(0);
9130   }
9131
9132   jresult = (void *)result;
9133   return jresult;
9134 }
9135
9136
9137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
9138   void * jresult ;
9139   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9140   Dali::Matrix *arg2 = 0 ;
9141   Dali::Matrix3 *result = 0 ;
9142
9143   arg1 = (Dali::Matrix3 *)jarg1;
9144   arg2 = (Dali::Matrix *)jarg2;
9145   if (!arg2) {
9146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9147     return 0;
9148   }
9149   {
9150     try {
9151       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
9152     } CALL_CATCH_EXCEPTION(0);
9153   }
9154
9155   jresult = (void *)result;
9156   return jresult;
9157 }
9158
9159
9160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
9161   unsigned int jresult ;
9162   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9163   Dali::Matrix3 *arg2 = 0 ;
9164   bool result;
9165
9166   arg1 = (Dali::Matrix3 *)jarg1;
9167   arg2 = (Dali::Matrix3 *)jarg2;
9168   if (!arg2) {
9169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9170     return 0;
9171   }
9172   {
9173     try {
9174       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
9175     } CALL_CATCH_EXCEPTION(0);
9176   }
9177
9178   jresult = result;
9179   return jresult;
9180 }
9181
9182
9183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
9184   unsigned int jresult ;
9185   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9186   Dali::Matrix3 *arg2 = 0 ;
9187   bool result;
9188
9189   arg1 = (Dali::Matrix3 *)jarg1;
9190   arg2 = (Dali::Matrix3 *)jarg2;
9191   if (!arg2) {
9192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9193     return 0;
9194   }
9195   {
9196     try {
9197       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
9198     } CALL_CATCH_EXCEPTION(0);
9199   }
9200
9201   jresult = result;
9202   return jresult;
9203 }
9204
9205
9206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
9207   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9208
9209   arg1 = (Dali::Matrix3 *)jarg1;
9210   {
9211     try {
9212       delete arg1;
9213     } CALL_CATCH_EXCEPTION();
9214   }
9215
9216 }
9217
9218
9219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
9220   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9221
9222   arg1 = (Dali::Matrix3 *)jarg1;
9223   {
9224     try {
9225       (arg1)->SetIdentity();
9226     } CALL_CATCH_EXCEPTION();
9227   }
9228
9229 }
9230
9231
9232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
9233   void * jresult ;
9234   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9235   float *result = 0 ;
9236
9237   arg1 = (Dali::Matrix3 *)jarg1;
9238   {
9239     try {
9240       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
9241     } CALL_CATCH_EXCEPTION(0);
9242   }
9243
9244   jresult = (void *)result;
9245   return jresult;
9246 }
9247
9248
9249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
9250   unsigned int jresult ;
9251   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9252   bool result;
9253
9254   arg1 = (Dali::Matrix3 *)jarg1;
9255   {
9256     try {
9257       result = (bool)(arg1)->Invert();
9258     } CALL_CATCH_EXCEPTION(0);
9259   }
9260
9261   jresult = result;
9262   return jresult;
9263 }
9264
9265
9266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
9267   unsigned int jresult ;
9268   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9269   bool result;
9270
9271   arg1 = (Dali::Matrix3 *)jarg1;
9272   {
9273     try {
9274       result = (bool)(arg1)->Transpose();
9275     } CALL_CATCH_EXCEPTION(0);
9276   }
9277
9278   jresult = result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
9284   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9285   float arg2 ;
9286
9287   arg1 = (Dali::Matrix3 *)jarg1;
9288   arg2 = (float)jarg2;
9289   {
9290     try {
9291       (arg1)->Scale(arg2);
9292     } CALL_CATCH_EXCEPTION();
9293   }
9294
9295 }
9296
9297
9298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
9299   float jresult ;
9300   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9301   float result;
9302
9303   arg1 = (Dali::Matrix3 *)jarg1;
9304   {
9305     try {
9306       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
9307     } CALL_CATCH_EXCEPTION(0);
9308   }
9309
9310   jresult = result;
9311   return jresult;
9312 }
9313
9314
9315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
9316   unsigned int jresult ;
9317   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9318   bool result;
9319
9320   arg1 = (Dali::Matrix3 *)jarg1;
9321   {
9322     try {
9323       result = (bool)(arg1)->ScaledInverseTranspose();
9324     } CALL_CATCH_EXCEPTION(0);
9325   }
9326
9327   jresult = result;
9328   return jresult;
9329 }
9330
9331
9332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
9333   Dali::Matrix3 *arg1 = 0 ;
9334   Dali::Matrix3 *arg2 = 0 ;
9335   Dali::Matrix3 *arg3 = 0 ;
9336
9337   arg1 = (Dali::Matrix3 *)jarg1;
9338   if (!arg1) {
9339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
9340     return ;
9341   }
9342   arg2 = (Dali::Matrix3 *)jarg2;
9343   if (!arg2) {
9344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9345     return ;
9346   }
9347   arg3 = (Dali::Matrix3 *)jarg3;
9348   if (!arg3) {
9349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9350     return ;
9351   }
9352   {
9353     try {
9354       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
9355     } CALL_CATCH_EXCEPTION();
9356   }
9357
9358 }
9359
9360
9361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
9362   float jresult ;
9363   float arg1 ;
9364   float arg2 ;
9365   float result;
9366
9367   arg1 = (float)jarg1;
9368   arg2 = (float)jarg2;
9369   {
9370     try {
9371       result = (float)Dali::Random::Range(arg1,arg2);
9372     } CALL_CATCH_EXCEPTION(0);
9373   }
9374
9375   jresult = result;
9376   return jresult;
9377 }
9378
9379
9380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
9381   void * jresult ;
9382   Dali::Vector4 result;
9383
9384   {
9385     try {
9386       result = Dali::Random::Axis();
9387     } CALL_CATCH_EXCEPTION(0);
9388   }
9389
9390   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
9391   return jresult;
9392 }
9393
9394
9395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
9396   void * jresult ;
9397   Dali::AngleAxis *result = 0 ;
9398
9399   {
9400     try {
9401       result = (Dali::AngleAxis *)new Dali::AngleAxis();
9402     } CALL_CATCH_EXCEPTION(0);
9403   }
9404
9405   jresult = (void *)result;
9406   return jresult;
9407 }
9408
9409
9410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
9411   void * jresult ;
9412   Dali::Radian arg1 ;
9413   Dali::Vector3 *arg2 = 0 ;
9414   Dali::Radian *argp1 ;
9415   Dali::AngleAxis *result = 0 ;
9416
9417   argp1 = (Dali::Radian *)jarg1;
9418   if (!argp1) {
9419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9420     return 0;
9421   }
9422   arg1 = *argp1;
9423   arg2 = (Dali::Vector3 *)jarg2;
9424   if (!arg2) {
9425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9426     return 0;
9427   }
9428   {
9429     try {
9430       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
9431     } CALL_CATCH_EXCEPTION(0);
9432   }
9433
9434   jresult = (void *)result;
9435   return jresult;
9436 }
9437
9438
9439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
9440   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9441   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
9442
9443   arg1 = (Dali::AngleAxis *)jarg1;
9444   arg2 = (Dali::Radian *)jarg2;
9445   if (arg1) (arg1)->angle = *arg2;
9446 }
9447
9448
9449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
9450   void * jresult ;
9451   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9452   Dali::Radian *result = 0 ;
9453
9454   arg1 = (Dali::AngleAxis *)jarg1;
9455   result = (Dali::Radian *)& ((arg1)->angle);
9456   jresult = (void *)result;
9457   return jresult;
9458 }
9459
9460
9461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
9462   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9463   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
9464
9465   arg1 = (Dali::AngleAxis *)jarg1;
9466   arg2 = (Dali::Vector3 *)jarg2;
9467   if (arg1) (arg1)->axis = *arg2;
9468 }
9469
9470
9471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
9472   void * jresult ;
9473   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9474   Dali::Vector3 *result = 0 ;
9475
9476   arg1 = (Dali::AngleAxis *)jarg1;
9477   result = (Dali::Vector3 *)& ((arg1)->axis);
9478   jresult = (void *)result;
9479   return jresult;
9480 }
9481
9482
9483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
9484   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9485
9486   arg1 = (Dali::AngleAxis *)jarg1;
9487   {
9488     try {
9489       delete arg1;
9490     } CALL_CATCH_EXCEPTION();
9491   }
9492
9493 }
9494
9495
9496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9497   unsigned int jresult ;
9498   Dali::AngleAxis *arg1 = 0 ;
9499   Dali::AngleAxis *arg2 = 0 ;
9500   bool result;
9501
9502   arg1 = (Dali::AngleAxis *)jarg1;
9503   if (!arg1) {
9504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9505     return 0;
9506   }
9507   arg2 = (Dali::AngleAxis *)jarg2;
9508   if (!arg2) {
9509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9510     return 0;
9511   }
9512   {
9513     try {
9514       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9515     } CALL_CATCH_EXCEPTION(0);
9516   }
9517
9518   jresult = result;
9519   return jresult;
9520 }
9521
9522
9523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9524   unsigned int jresult ;
9525   unsigned int arg1 ;
9526   unsigned int result;
9527
9528   arg1 = (unsigned int)jarg1;
9529   {
9530     try {
9531       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9532     } CALL_CATCH_EXCEPTION(0);
9533   }
9534
9535   jresult = result;
9536   return jresult;
9537 }
9538
9539
9540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9541   unsigned int jresult ;
9542   unsigned int arg1 ;
9543   bool result;
9544
9545   arg1 = (unsigned int)jarg1;
9546   {
9547     try {
9548       result = (bool)Dali::IsPowerOfTwo(arg1);
9549     } CALL_CATCH_EXCEPTION(0);
9550   }
9551
9552   jresult = result;
9553   return jresult;
9554 }
9555
9556
9557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9558   float jresult ;
9559   float arg1 ;
9560   float arg2 ;
9561   float result;
9562
9563   arg1 = (float)jarg1;
9564   arg2 = (float)jarg2;
9565   {
9566     try {
9567       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9568     } CALL_CATCH_EXCEPTION(0);
9569   }
9570
9571   jresult = result;
9572   return jresult;
9573 }
9574
9575
9576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9577   unsigned int jresult ;
9578   float arg1 ;
9579   bool result;
9580
9581   arg1 = (float)jarg1;
9582   {
9583     try {
9584       result = (bool)Dali::EqualsZero(arg1);
9585     } CALL_CATCH_EXCEPTION(0);
9586   }
9587
9588   jresult = result;
9589   return jresult;
9590 }
9591
9592
9593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9594   unsigned int jresult ;
9595   float arg1 ;
9596   float arg2 ;
9597   bool result;
9598
9599   arg1 = (float)jarg1;
9600   arg2 = (float)jarg2;
9601   {
9602     try {
9603       result = (bool)Dali::Equals(arg1,arg2);
9604     } CALL_CATCH_EXCEPTION(0);
9605   }
9606
9607   jresult = result;
9608   return jresult;
9609 }
9610
9611
9612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9613   unsigned int jresult ;
9614   float arg1 ;
9615   float arg2 ;
9616   float arg3 ;
9617   bool result;
9618
9619   arg1 = (float)jarg1;
9620   arg2 = (float)jarg2;
9621   arg3 = (float)jarg3;
9622   {
9623     try {
9624       result = (bool)Dali::Equals(arg1,arg2,arg3);
9625     } CALL_CATCH_EXCEPTION(0);
9626   }
9627
9628   jresult = result;
9629   return jresult;
9630 }
9631
9632
9633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9634   float jresult ;
9635   float arg1 ;
9636   int arg2 ;
9637   float result;
9638
9639   arg1 = (float)jarg1;
9640   arg2 = (int)jarg2;
9641   {
9642     try {
9643       result = (float)Dali::Round(arg1,arg2);
9644     } CALL_CATCH_EXCEPTION(0);
9645   }
9646
9647   jresult = result;
9648   return jresult;
9649 }
9650
9651
9652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9653   float jresult ;
9654   float arg1 ;
9655   float arg2 ;
9656   float arg3 ;
9657   float result;
9658
9659   arg1 = (float)jarg1;
9660   arg2 = (float)jarg2;
9661   arg3 = (float)jarg3;
9662   {
9663     try {
9664       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9665     } CALL_CATCH_EXCEPTION(0);
9666   }
9667
9668   jresult = result;
9669   return jresult;
9670 }
9671
9672
9673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9674   float jresult ;
9675   float arg1 ;
9676   float arg2 ;
9677   float arg3 ;
9678   float arg4 ;
9679   float result;
9680
9681   arg1 = (float)jarg1;
9682   arg2 = (float)jarg2;
9683   arg3 = (float)jarg3;
9684   arg4 = (float)jarg4;
9685   {
9686     try {
9687       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9688     } CALL_CATCH_EXCEPTION(0);
9689   }
9690
9691   jresult = result;
9692   return jresult;
9693 }
9694
9695
9696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9697   int jresult ;
9698   int result;
9699
9700   result = (int)(int)Dali::Property::INVALID_INDEX;
9701   jresult = result;
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9707   int jresult ;
9708   int result;
9709
9710   result = (int)(int)Dali::Property::INVALID_KEY;
9711   jresult = result;
9712   return jresult;
9713 }
9714
9715
9716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9717   int jresult ;
9718   int result;
9719
9720   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9721   jresult = result;
9722   return jresult;
9723 }
9724
9725
9726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9727   void * jresult ;
9728   Dali::Handle *arg1 = 0 ;
9729   Dali::Property::Index arg2 ;
9730   Dali::Property *result = 0 ;
9731
9732   arg1 = (Dali::Handle *)jarg1;
9733   if (!arg1) {
9734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9735     return 0;
9736   }
9737   arg2 = (Dali::Property::Index)jarg2;
9738   {
9739     try {
9740       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9741     } CALL_CATCH_EXCEPTION(0);
9742   }
9743
9744   jresult = (void *)result;
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9750   void * jresult ;
9751   Dali::Handle *arg1 = 0 ;
9752   Dali::Property::Index arg2 ;
9753   int arg3 ;
9754   Dali::Property *result = 0 ;
9755
9756   arg1 = (Dali::Handle *)jarg1;
9757   if (!arg1) {
9758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9759     return 0;
9760   }
9761   arg2 = (Dali::Property::Index)jarg2;
9762   arg3 = (int)jarg3;
9763   {
9764     try {
9765       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9766     } CALL_CATCH_EXCEPTION(0);
9767   }
9768
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9775   void * jresult ;
9776   Dali::Handle *arg1 = 0 ;
9777   std::string *arg2 = 0 ;
9778   Dali::Property *result = 0 ;
9779
9780   arg1 = (Dali::Handle *)jarg1;
9781   if (!arg1) {
9782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9783     return 0;
9784   }
9785   if (!jarg2) {
9786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9787     return 0;
9788   }
9789   std::string arg2_str(jarg2);
9790   arg2 = &arg2_str;
9791   {
9792     try {
9793       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9794     } CALL_CATCH_EXCEPTION(0);
9795   }
9796
9797   jresult = (void *)result;
9798
9799   //argout typemap for const std::string&
9800
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9806   void * jresult ;
9807   Dali::Handle *arg1 = 0 ;
9808   std::string *arg2 = 0 ;
9809   int arg3 ;
9810   Dali::Property *result = 0 ;
9811
9812   arg1 = (Dali::Handle *)jarg1;
9813   if (!arg1) {
9814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9815     return 0;
9816   }
9817   if (!jarg2) {
9818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9819     return 0;
9820   }
9821   std::string arg2_str(jarg2);
9822   arg2 = &arg2_str;
9823   arg3 = (int)jarg3;
9824   {
9825     try {
9826       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9827     } CALL_CATCH_EXCEPTION(0);
9828   }
9829
9830   jresult = (void *)result;
9831
9832   //argout typemap for const std::string&
9833
9834   return jresult;
9835 }
9836
9837
9838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9839   Dali::Property *arg1 = (Dali::Property *) 0 ;
9840
9841   arg1 = (Dali::Property *)jarg1;
9842   {
9843     try {
9844       delete arg1;
9845     } CALL_CATCH_EXCEPTION();
9846   }
9847
9848 }
9849
9850
9851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9852   Dali::Property *arg1 = (Dali::Property *) 0 ;
9853   Dali::Handle *arg2 = 0 ;
9854
9855   arg1 = (Dali::Property *)jarg1;
9856   arg2 = (Dali::Handle *)jarg2;
9857   if (!arg2) {
9858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9859     return ;
9860   }
9861   if (arg1) (arg1)->object = *arg2;
9862 }
9863
9864
9865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9866   void * jresult ;
9867   Dali::Property *arg1 = (Dali::Property *) 0 ;
9868   Dali::Handle *result = 0 ;
9869
9870   arg1 = (Dali::Property *)jarg1;
9871   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9872   jresult = (void *)result;
9873   return jresult;
9874 }
9875
9876
9877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9878   Dali::Property *arg1 = (Dali::Property *) 0 ;
9879   Dali::Property::Index arg2 ;
9880
9881   arg1 = (Dali::Property *)jarg1;
9882   arg2 = (Dali::Property::Index)jarg2;
9883   if (arg1) (arg1)->propertyIndex = arg2;
9884 }
9885
9886
9887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9888   int jresult ;
9889   Dali::Property *arg1 = (Dali::Property *) 0 ;
9890   Dali::Property::Index result;
9891
9892   arg1 = (Dali::Property *)jarg1;
9893   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9894   jresult = result;
9895   return jresult;
9896 }
9897
9898
9899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9900   Dali::Property *arg1 = (Dali::Property *) 0 ;
9901   int arg2 ;
9902
9903   arg1 = (Dali::Property *)jarg1;
9904   arg2 = (int)jarg2;
9905   if (arg1) (arg1)->componentIndex = arg2;
9906 }
9907
9908
9909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9910   int jresult ;
9911   Dali::Property *arg1 = (Dali::Property *) 0 ;
9912   int result;
9913
9914   arg1 = (Dali::Property *)jarg1;
9915   result = (int) ((arg1)->componentIndex);
9916   jresult = result;
9917   return jresult;
9918 }
9919
9920
9921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9922   void * jresult ;
9923   Dali::Property::Array *result = 0 ;
9924
9925   {
9926     try {
9927       result = (Dali::Property::Array *)new Dali::Property::Array();
9928     } CALL_CATCH_EXCEPTION(0);
9929   }
9930
9931   jresult = (void *)result;
9932   return jresult;
9933 }
9934
9935
9936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9937   void * jresult ;
9938   Dali::Property::Array *arg1 = 0 ;
9939   Dali::Property::Array *result = 0 ;
9940
9941   arg1 = (Dali::Property::Array *)jarg1;
9942   if (!arg1) {
9943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9944     return 0;
9945   }
9946   {
9947     try {
9948       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9949     } CALL_CATCH_EXCEPTION(0);
9950   }
9951
9952   jresult = (void *)result;
9953   return jresult;
9954 }
9955
9956
9957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9958   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9959
9960   arg1 = (Dali::Property::Array *)jarg1;
9961   {
9962     try {
9963       delete arg1;
9964     } CALL_CATCH_EXCEPTION();
9965   }
9966
9967 }
9968
9969
9970 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9971   unsigned long jresult ;
9972   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9973   Dali::Property::Array::SizeType result;
9974
9975   arg1 = (Dali::Property::Array *)jarg1;
9976   {
9977     try {
9978       result = ((Dali::Property::Array const *)arg1)->Size();
9979     } CALL_CATCH_EXCEPTION(0);
9980   }
9981
9982   jresult = (unsigned long)result;
9983   return jresult;
9984 }
9985
9986
9987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9988   unsigned long jresult ;
9989   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9990   Dali::Property::Array::SizeType result;
9991
9992   arg1 = (Dali::Property::Array *)jarg1;
9993   {
9994     try {
9995       result = ((Dali::Property::Array const *)arg1)->Count();
9996     } CALL_CATCH_EXCEPTION(0);
9997   }
9998
9999   jresult = (unsigned long)result;
10000   return jresult;
10001 }
10002
10003
10004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
10005   unsigned int jresult ;
10006   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10007   bool result;
10008
10009   arg1 = (Dali::Property::Array *)jarg1;
10010   {
10011     try {
10012       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
10013     } CALL_CATCH_EXCEPTION(0);
10014   }
10015
10016   jresult = result;
10017   return jresult;
10018 }
10019
10020
10021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
10022   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10023
10024   arg1 = (Dali::Property::Array *)jarg1;
10025   {
10026     try {
10027       (arg1)->Clear();
10028     } CALL_CATCH_EXCEPTION();
10029   }
10030
10031 }
10032
10033
10034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
10035   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10036   Dali::Property::Array::SizeType arg2 ;
10037
10038   arg1 = (Dali::Property::Array *)jarg1;
10039   arg2 = (Dali::Property::Array::SizeType)jarg2;
10040   {
10041     try {
10042       (arg1)->Reserve(arg2);
10043     } CALL_CATCH_EXCEPTION();
10044   }
10045
10046 }
10047
10048
10049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
10050   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10051   Dali::Property::Array::SizeType arg2 ;
10052
10053   arg1 = (Dali::Property::Array *)jarg1;
10054   arg2 = (Dali::Property::Array::SizeType)jarg2;
10055   {
10056     try {
10057       (arg1)->Resize(arg2);
10058     } CALL_CATCH_EXCEPTION();
10059   }
10060
10061 }
10062
10063
10064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
10065   unsigned long jresult ;
10066   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10067   Dali::Property::Array::SizeType result;
10068
10069   arg1 = (Dali::Property::Array *)jarg1;
10070   {
10071     try {
10072       result = (arg1)->Capacity();
10073     } CALL_CATCH_EXCEPTION(0);
10074   }
10075
10076   jresult = (unsigned long)result;
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
10082   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10083   Dali::Property::Value *arg2 = 0 ;
10084
10085   arg1 = (Dali::Property::Array *)jarg1;
10086   arg2 = (Dali::Property::Value *)jarg2;
10087   if (!arg2) {
10088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10089     return ;
10090   }
10091   {
10092     try {
10093       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
10094     } CALL_CATCH_EXCEPTION();
10095   }
10096
10097 }
10098
10099
10100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
10101   void * jresult ;
10102   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10103   Dali::Property::Value *arg2 = 0 ;
10104   Dali::Property::Array *result = 0 ;
10105
10106   arg1 = (Dali::Property::Array *)jarg1;
10107   arg2 = (Dali::Property::Value *)jarg2;
10108   if (!arg2) {
10109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10110     return 0;
10111   }
10112   {
10113     try {
10114       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
10115     } CALL_CATCH_EXCEPTION(0);
10116   }
10117
10118   jresult = (void *)result;
10119   return jresult;
10120 }
10121
10122
10123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
10124   void * jresult ;
10125   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10126   Dali::Property::Array::SizeType arg2 ;
10127   Dali::Property::Value *result = 0 ;
10128
10129   arg1 = (Dali::Property::Array *)jarg1;
10130   arg2 = (Dali::Property::Array::SizeType)jarg2;
10131   {
10132     try {
10133       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
10134     } CALL_CATCH_EXCEPTION(0);
10135   }
10136
10137   jresult = (void *)result;
10138   return jresult;
10139 }
10140
10141
10142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
10143   void * jresult ;
10144   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10145   Dali::Property::Array::SizeType arg2 ;
10146   Dali::Property::Value *result = 0 ;
10147
10148   arg1 = (Dali::Property::Array *)jarg1;
10149   arg2 = (Dali::Property::Array::SizeType)jarg2;
10150   {
10151     try {
10152       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
10153     } CALL_CATCH_EXCEPTION(0);
10154   }
10155
10156   jresult = (void *)result;
10157   return jresult;
10158 }
10159
10160
10161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
10162   void * jresult ;
10163   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10164   Dali::Property::Array *arg2 = 0 ;
10165   Dali::Property::Array *result = 0 ;
10166
10167   arg1 = (Dali::Property::Array *)jarg1;
10168   arg2 = (Dali::Property::Array *)jarg2;
10169   if (!arg2) {
10170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
10171     return 0;
10172   }
10173   {
10174     try {
10175       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
10176     } CALL_CATCH_EXCEPTION(0);
10177   }
10178
10179   jresult = (void *)result;
10180   return jresult;
10181 }
10182
10183
10184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
10185   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10186   enum Dali::Property::Key::Type arg2 ;
10187
10188   arg1 = (Dali::Property::Key *)jarg1;
10189   arg2 = (enum Dali::Property::Key::Type)jarg2;
10190   if (arg1) (arg1)->type = arg2;
10191 }
10192
10193
10194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
10195   int jresult ;
10196   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10197   enum Dali::Property::Key::Type result;
10198
10199   arg1 = (Dali::Property::Key *)jarg1;
10200   result = (enum Dali::Property::Key::Type) ((arg1)->type);
10201   jresult = (int)result;
10202   return jresult;
10203 }
10204
10205
10206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
10207   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10208   Dali::Property::Index arg2 ;
10209
10210   arg1 = (Dali::Property::Key *)jarg1;
10211   arg2 = (Dali::Property::Index)jarg2;
10212   if (arg1) (arg1)->indexKey = arg2;
10213 }
10214
10215
10216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
10217   int jresult ;
10218   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10219   Dali::Property::Index result;
10220
10221   arg1 = (Dali::Property::Key *)jarg1;
10222   result = (Dali::Property::Index) ((arg1)->indexKey);
10223   jresult = result;
10224   return jresult;
10225 }
10226
10227
10228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
10229   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10230   std::string *arg2 = 0 ;
10231
10232   arg1 = (Dali::Property::Key *)jarg1;
10233   if (!jarg2) {
10234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10235     return ;
10236   }
10237   std::string arg2_str(jarg2);
10238   arg2 = &arg2_str;
10239   if (arg1) (arg1)->stringKey = *arg2;
10240
10241   //argout typemap for const std::string&
10242
10243 }
10244
10245
10246 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
10247   char * jresult ;
10248   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10249   std::string *result = 0 ;
10250
10251   arg1 = (Dali::Property::Key *)jarg1;
10252   result = (std::string *) & ((arg1)->stringKey);
10253   jresult = SWIG_csharp_string_callback(result->c_str());
10254   return jresult;
10255 }
10256
10257
10258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
10259   void * jresult ;
10260   std::string *arg1 = 0 ;
10261   Dali::Property::Key *result = 0 ;
10262
10263   if (!jarg1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10265     return 0;
10266   }
10267   std::string arg1_str(jarg1);
10268   arg1 = &arg1_str;
10269   {
10270     try {
10271       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
10272     } CALL_CATCH_EXCEPTION(0);
10273   }
10274
10275   jresult = (void *)result;
10276
10277   //argout typemap for const std::string&
10278
10279   return jresult;
10280 }
10281
10282
10283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
10284   void * jresult ;
10285   Dali::Property::Index arg1 ;
10286   Dali::Property::Key *result = 0 ;
10287
10288   arg1 = (Dali::Property::Index)jarg1;
10289   {
10290     try {
10291       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
10292     } CALL_CATCH_EXCEPTION(0);
10293   }
10294
10295   jresult = (void *)result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10303   std::string *arg2 = 0 ;
10304   bool result;
10305
10306   arg1 = (Dali::Property::Key *)jarg1;
10307   if (!jarg2) {
10308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10309     return 0;
10310   }
10311   std::string arg2_str(jarg2);
10312   arg2 = &arg2_str;
10313   {
10314     try {
10315       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
10316     } CALL_CATCH_EXCEPTION(0);
10317   }
10318
10319   jresult = result;
10320
10321   //argout typemap for const std::string&
10322
10323   return jresult;
10324 }
10325
10326
10327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
10328   unsigned int jresult ;
10329   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10330   Dali::Property::Index arg2 ;
10331   bool result;
10332
10333   arg1 = (Dali::Property::Key *)jarg1;
10334   arg2 = (Dali::Property::Index)jarg2;
10335   {
10336     try {
10337       result = (bool)(arg1)->operator ==(arg2);
10338     } CALL_CATCH_EXCEPTION(0);
10339   }
10340
10341   jresult = result;
10342   return jresult;
10343 }
10344
10345
10346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
10347   unsigned int jresult ;
10348   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10349   Dali::Property::Key *arg2 = 0 ;
10350   bool result;
10351
10352   arg1 = (Dali::Property::Key *)jarg1;
10353   arg2 = (Dali::Property::Key *)jarg2;
10354   if (!arg2) {
10355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10356     return 0;
10357   }
10358   {
10359     try {
10360       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
10361     } CALL_CATCH_EXCEPTION(0);
10362   }
10363
10364   jresult = result;
10365   return jresult;
10366 }
10367
10368
10369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
10370   unsigned int jresult ;
10371   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10372   std::string *arg2 = 0 ;
10373   bool result;
10374
10375   arg1 = (Dali::Property::Key *)jarg1;
10376   if (!jarg2) {
10377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10378     return 0;
10379   }
10380   std::string arg2_str(jarg2);
10381   arg2 = &arg2_str;
10382   {
10383     try {
10384       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
10385     } CALL_CATCH_EXCEPTION(0);
10386   }
10387
10388   jresult = result;
10389
10390   //argout typemap for const std::string&
10391
10392   return jresult;
10393 }
10394
10395
10396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
10397   unsigned int jresult ;
10398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10399   Dali::Property::Index arg2 ;
10400   bool result;
10401
10402   arg1 = (Dali::Property::Key *)jarg1;
10403   arg2 = (Dali::Property::Index)jarg2;
10404   {
10405     try {
10406       result = (bool)(arg1)->operator !=(arg2);
10407     } CALL_CATCH_EXCEPTION(0);
10408   }
10409
10410   jresult = result;
10411   return jresult;
10412 }
10413
10414
10415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
10416   unsigned int jresult ;
10417   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10418   Dali::Property::Key *arg2 = 0 ;
10419   bool result;
10420
10421   arg1 = (Dali::Property::Key *)jarg1;
10422   arg2 = (Dali::Property::Key *)jarg2;
10423   if (!arg2) {
10424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10425     return 0;
10426   }
10427   {
10428     try {
10429       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
10430     } CALL_CATCH_EXCEPTION(0);
10431   }
10432
10433   jresult = result;
10434   return jresult;
10435 }
10436
10437
10438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
10439   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10440
10441   arg1 = (Dali::Property::Key *)jarg1;
10442   {
10443     try {
10444       delete arg1;
10445     } CALL_CATCH_EXCEPTION();
10446   }
10447
10448 }
10449
10450
10451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
10452   void * jresult ;
10453   Dali::Property::Map *result = 0 ;
10454
10455   {
10456     try {
10457       result = (Dali::Property::Map *)new Dali::Property::Map();
10458     } CALL_CATCH_EXCEPTION(0);
10459   }
10460
10461   jresult = (void *)result;
10462   return jresult;
10463 }
10464
10465
10466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
10467   void * jresult ;
10468   Dali::Property::Map *arg1 = 0 ;
10469   Dali::Property::Map *result = 0 ;
10470
10471   arg1 = (Dali::Property::Map *)jarg1;
10472   if (!arg1) {
10473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10474     return 0;
10475   }
10476   {
10477     try {
10478       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
10479     } CALL_CATCH_EXCEPTION(0);
10480   }
10481
10482   jresult = (void *)result;
10483   return jresult;
10484 }
10485
10486
10487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
10488   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10489
10490   arg1 = (Dali::Property::Map *)jarg1;
10491   {
10492     try {
10493       delete arg1;
10494     } CALL_CATCH_EXCEPTION();
10495   }
10496
10497 }
10498
10499
10500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10501   unsigned long jresult ;
10502   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10503   Dali::Property::Map::SizeType result;
10504
10505   arg1 = (Dali::Property::Map *)jarg1;
10506   {
10507     try {
10508       result = ((Dali::Property::Map const *)arg1)->Count();
10509     } CALL_CATCH_EXCEPTION(0);
10510   }
10511
10512   jresult = (unsigned long)result;
10513   return jresult;
10514 }
10515
10516
10517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10518   unsigned int jresult ;
10519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10520   bool result;
10521
10522   arg1 = (Dali::Property::Map *)jarg1;
10523   {
10524     try {
10525       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10526     } CALL_CATCH_EXCEPTION(0);
10527   }
10528
10529   jresult = result;
10530   return jresult;
10531 }
10532
10533
10534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10535   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10536   char *arg2 = (char *) 0 ;
10537   Dali::Property::Value *arg3 = 0 ;
10538
10539   arg1 = (Dali::Property::Map *)jarg1;
10540   arg2 = (char *)jarg2;
10541   arg3 = (Dali::Property::Value *)jarg3;
10542   if (!arg3) {
10543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10544     return ;
10545   }
10546   {
10547     try {
10548       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10549     } CALL_CATCH_EXCEPTION();
10550   }
10551
10552 }
10553
10554
10555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10556   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10557   Dali::Property::Index arg2 ;
10558   Dali::Property::Value *arg3 = 0 ;
10559
10560   arg1 = (Dali::Property::Map *)jarg1;
10561   arg2 = (Dali::Property::Index)jarg2;
10562   arg3 = (Dali::Property::Value *)jarg3;
10563   if (!arg3) {
10564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10565     return ;
10566   }
10567   {
10568     try {
10569       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10570     } CALL_CATCH_EXCEPTION();
10571   }
10572
10573 }
10574
10575
10576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10577   void * jresult ;
10578   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10579   char *arg2 = (char *) 0 ;
10580   Dali::Property::Value *arg3 = 0 ;
10581   Dali::Property::Map *result = 0 ;
10582
10583   arg1 = (Dali::Property::Map *)jarg1;
10584   arg2 = (char *)jarg2;
10585   arg3 = (Dali::Property::Value *)jarg3;
10586   if (!arg3) {
10587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10588     return 0;
10589   }
10590   {
10591     try {
10592       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10593     } CALL_CATCH_EXCEPTION(0);
10594   }
10595
10596   jresult = (void *)result;
10597   return jresult;
10598 }
10599
10600
10601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10602   void * jresult ;
10603   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10604   Dali::Property::Index arg2 ;
10605   Dali::Property::Value *arg3 = 0 ;
10606   Dali::Property::Map *result = 0 ;
10607
10608   arg1 = (Dali::Property::Map *)jarg1;
10609   arg2 = (Dali::Property::Index)jarg2;
10610   arg3 = (Dali::Property::Value *)jarg3;
10611   if (!arg3) {
10612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10613     return 0;
10614   }
10615   {
10616     try {
10617       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10618     } CALL_CATCH_EXCEPTION(0);
10619   }
10620
10621   jresult = (void *)result;
10622   return jresult;
10623 }
10624
10625
10626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10627   void * jresult ;
10628   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10629   Dali::Property::Map::SizeType arg2 ;
10630   Dali::Property::Value *result = 0 ;
10631
10632   arg1 = (Dali::Property::Map *)jarg1;
10633   arg2 = (Dali::Property::Map::SizeType)jarg2;
10634   {
10635     try {
10636       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10637     } CALL_CATCH_EXCEPTION(0);
10638   }
10639
10640   jresult = (void *)result;
10641   return jresult;
10642 }
10643
10644
10645 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10646   char * jresult ;
10647   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10648   Dali::Property::Map::SizeType arg2 ;
10649   std::string *result = 0 ;
10650
10651   arg1 = (Dali::Property::Map *)jarg1;
10652   arg2 = (Dali::Property::Map::SizeType)jarg2;
10653   {
10654     try {
10655       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10656     } CALL_CATCH_EXCEPTION(0);
10657   }
10658
10659   jresult = SWIG_csharp_string_callback(result->c_str());
10660   return jresult;
10661 }
10662
10663
10664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10665   void * jresult ;
10666   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10667   Dali::Property::Map::SizeType arg2 ;
10668   SwigValueWrapper< Dali::Property::Key > result;
10669
10670   arg1 = (Dali::Property::Map *)jarg1;
10671   arg2 = (Dali::Property::Map::SizeType)jarg2;
10672   {
10673     try {
10674       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10675     } CALL_CATCH_EXCEPTION(0);
10676   }
10677
10678   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10679   return jresult;
10680 }
10681
10682
10683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10684   void * jresult ;
10685   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10686   Dali::Property::Map::SizeType arg2 ;
10687   StringValuePair *result = 0 ;
10688
10689   arg1 = (Dali::Property::Map *)jarg1;
10690   arg2 = (Dali::Property::Map::SizeType)jarg2;
10691   {
10692     try {
10693       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10694     } CALL_CATCH_EXCEPTION(0);
10695   }
10696
10697   jresult = (void *)result;
10698   return jresult;
10699 }
10700
10701
10702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10703   void * jresult ;
10704   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10705   char *arg2 = (char *) 0 ;
10706   Dali::Property::Value *result = 0 ;
10707
10708   arg1 = (Dali::Property::Map *)jarg1;
10709   arg2 = (char *)jarg2;
10710   {
10711     try {
10712       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10713     } CALL_CATCH_EXCEPTION(0);
10714   }
10715
10716   jresult = (void *)result;
10717   return jresult;
10718 }
10719
10720
10721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10722   void * jresult ;
10723   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10724   Dali::Property::Index arg2 ;
10725   Dali::Property::Value *result = 0 ;
10726
10727   arg1 = (Dali::Property::Map *)jarg1;
10728   arg2 = (Dali::Property::Index)jarg2;
10729   {
10730     try {
10731       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10732     } CALL_CATCH_EXCEPTION(0);
10733   }
10734
10735   jresult = (void *)result;
10736   return jresult;
10737 }
10738
10739
10740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10741   void * jresult ;
10742   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10743   Dali::Property::Index arg2 ;
10744   std::string *arg3 = 0 ;
10745   Dali::Property::Value *result = 0 ;
10746
10747   arg1 = (Dali::Property::Map *)jarg1;
10748   arg2 = (Dali::Property::Index)jarg2;
10749   if (!jarg3) {
10750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10751     return 0;
10752   }
10753   std::string arg3_str(jarg3);
10754   arg3 = &arg3_str;
10755   {
10756     try {
10757       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10758     } CALL_CATCH_EXCEPTION(0);
10759   }
10760
10761   jresult = (void *)result;
10762
10763   //argout typemap for const std::string&
10764
10765   return jresult;
10766 }
10767
10768
10769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10770   void * jresult ;
10771   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10772   std::string *arg2 = 0 ;
10773   Dali::Property::Type arg3 ;
10774   Dali::Property::Value *result = 0 ;
10775
10776   arg1 = (Dali::Property::Map *)jarg1;
10777   if (!jarg2) {
10778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10779     return 0;
10780   }
10781   std::string arg2_str(jarg2);
10782   arg2 = &arg2_str;
10783   arg3 = (Dali::Property::Type)jarg3;
10784   {
10785     try {
10786       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10787     } CALL_CATCH_EXCEPTION(0);
10788   }
10789
10790   jresult = (void *)result;
10791
10792   //argout typemap for const std::string&
10793
10794   return jresult;
10795 }
10796
10797
10798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10799   void * jresult ;
10800   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10801   Dali::Property::Index arg2 ;
10802   Dali::Property::Type arg3 ;
10803   Dali::Property::Value *result = 0 ;
10804
10805   arg1 = (Dali::Property::Map *)jarg1;
10806   arg2 = (Dali::Property::Index)jarg2;
10807   arg3 = (Dali::Property::Type)jarg3;
10808   {
10809     try {
10810       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10811     } CALL_CATCH_EXCEPTION(0);
10812   }
10813
10814   jresult = (void *)result;
10815   return jresult;
10816 }
10817
10818
10819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10820   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10821
10822   arg1 = (Dali::Property::Map *)jarg1;
10823   {
10824     try {
10825       (arg1)->Clear();
10826     } CALL_CATCH_EXCEPTION();
10827   }
10828
10829 }
10830
10831
10832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10833   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10834   Dali::Property::Map *arg2 = 0 ;
10835
10836   arg1 = (Dali::Property::Map *)jarg1;
10837   arg2 = (Dali::Property::Map *)jarg2;
10838   if (!arg2) {
10839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10840     return ;
10841   }
10842   {
10843     try {
10844       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10845     } CALL_CATCH_EXCEPTION();
10846   }
10847
10848 }
10849
10850
10851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10852   void * jresult ;
10853   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10854   std::string *arg2 = 0 ;
10855   Dali::Property::Value *result = 0 ;
10856
10857   arg1 = (Dali::Property::Map *)jarg1;
10858   if (!jarg2) {
10859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10860     return 0;
10861   }
10862   std::string arg2_str(jarg2);
10863   arg2 = &arg2_str;
10864   {
10865     try {
10866       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10867     } CALL_CATCH_EXCEPTION(0);
10868   }
10869
10870   jresult = (void *)result;
10871
10872   //argout typemap for const std::string&
10873
10874   return jresult;
10875 }
10876
10877
10878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10879   void * jresult ;
10880   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10881   Dali::Property::Index arg2 ;
10882   Dali::Property::Value *result = 0 ;
10883
10884   arg1 = (Dali::Property::Map *)jarg1;
10885   arg2 = (Dali::Property::Index)jarg2;
10886   {
10887     try {
10888       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10889     } CALL_CATCH_EXCEPTION(0);
10890   }
10891
10892   jresult = (void *)result;
10893   return jresult;
10894 }
10895
10896
10897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10898   void * jresult ;
10899   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10900   Dali::Property::Map *arg2 = 0 ;
10901   Dali::Property::Map *result = 0 ;
10902
10903   arg1 = (Dali::Property::Map *)jarg1;
10904   arg2 = (Dali::Property::Map *)jarg2;
10905   if (!arg2) {
10906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10907     return 0;
10908   }
10909   {
10910     try {
10911       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10912     } CALL_CATCH_EXCEPTION(0);
10913   }
10914
10915   jresult = (void *)result;
10916   return jresult;
10917 }
10918
10919
10920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10921
10922   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10923
10924   if (!jarg2) {
10925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10926     return;
10927   }
10928   std::string arg2_str(jarg2);
10929   std::string* arg2 = &arg2_str;
10930
10931   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10932
10933   {
10934     try {
10935       arg1->operator[]((std::string const &)*arg2) = *arg3;
10936     } CALL_CATCH_EXCEPTION();
10937   }
10938 }
10939
10940
10941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10942
10943   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10944   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10945   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10946
10947   {
10948     try {
10949       arg1->operator[](arg2) = *arg3;
10950     } CALL_CATCH_EXCEPTION();
10951   }
10952 }
10953
10954
10955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10956   void * jresult ;
10957   Dali::Property::Value *result = 0 ;
10958
10959   {
10960     try {
10961       result = (Dali::Property::Value *)new Dali::Property::Value();
10962     } CALL_CATCH_EXCEPTION(0);
10963   }
10964
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
10971   void * jresult ;
10972   bool arg1 ;
10973   Dali::Property::Value *result = 0 ;
10974
10975   arg1 = jarg1 ? true : false;
10976   {
10977     try {
10978       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10979     } CALL_CATCH_EXCEPTION(0);
10980   }
10981
10982   jresult = (void *)result;
10983   return jresult;
10984 }
10985
10986
10987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10988   void * jresult ;
10989   int arg1 ;
10990   Dali::Property::Value *result = 0 ;
10991
10992   arg1 = (int)jarg1;
10993   {
10994     try {
10995       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
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_3(float jarg1) {
11005   void * jresult ;
11006   float arg1 ;
11007   Dali::Property::Value *result = 0 ;
11008
11009   arg1 = (float)jarg1;
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_4(void * jarg1) {
11022   void * jresult ;
11023   Dali::Vector2 *arg1 = 0 ;
11024   Dali::Property::Value *result = 0 ;
11025
11026   arg1 = (Dali::Vector2 *)jarg1;
11027   if (!arg1) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
11029     return 0;
11030   }
11031   {
11032     try {
11033       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
11034     } CALL_CATCH_EXCEPTION(0);
11035   }
11036
11037   jresult = (void *)result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
11043   void * jresult ;
11044   Dali::Vector3 *arg1 = 0 ;
11045   Dali::Property::Value *result = 0 ;
11046
11047   arg1 = (Dali::Vector3 *)jarg1;
11048   if (!arg1) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11050     return 0;
11051   }
11052   {
11053     try {
11054       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
11055     } CALL_CATCH_EXCEPTION(0);
11056   }
11057
11058   jresult = (void *)result;
11059   return jresult;
11060 }
11061
11062
11063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
11064   void * jresult ;
11065   Dali::Vector4 *arg1 = 0 ;
11066   Dali::Property::Value *result = 0 ;
11067
11068   arg1 = (Dali::Vector4 *)jarg1;
11069   if (!arg1) {
11070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11071     return 0;
11072   }
11073   {
11074     try {
11075       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11076     } CALL_CATCH_EXCEPTION(0);
11077   }
11078
11079   jresult = (void *)result;
11080   return jresult;
11081 }
11082
11083
11084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11085   void * jresult ;
11086   Dali::Matrix3 *arg1 = 0 ;
11087   Dali::Property::Value *result = 0 ;
11088
11089   arg1 = (Dali::Matrix3 *)jarg1;
11090   if (!arg1) {
11091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11092     return 0;
11093   }
11094   {
11095     try {
11096       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11097     } CALL_CATCH_EXCEPTION(0);
11098   }
11099
11100   jresult = (void *)result;
11101   return jresult;
11102 }
11103
11104
11105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11106   void * jresult ;
11107   Dali::Matrix *arg1 = 0 ;
11108   Dali::Property::Value *result = 0 ;
11109
11110   arg1 = (Dali::Matrix *)jarg1;
11111   if (!arg1) {
11112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11113     return 0;
11114   }
11115   {
11116     try {
11117       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11118     } CALL_CATCH_EXCEPTION(0);
11119   }
11120
11121   jresult = (void *)result;
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11127   void * jresult ;
11128   Dali::Rect< int > *arg1 = 0 ;
11129   Dali::Property::Value *result = 0 ;
11130
11131   arg1 = (Dali::Rect< int > *)jarg1;
11132   if (!arg1) {
11133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11134     return 0;
11135   }
11136   {
11137     try {
11138       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11139     } CALL_CATCH_EXCEPTION(0);
11140   }
11141
11142   jresult = (void *)result;
11143   return jresult;
11144 }
11145
11146
11147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11148   void * jresult ;
11149   Dali::AngleAxis *arg1 = 0 ;
11150   Dali::Property::Value *result = 0 ;
11151
11152   arg1 = (Dali::AngleAxis *)jarg1;
11153   if (!arg1) {
11154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11155     return 0;
11156   }
11157   {
11158     try {
11159       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11160     } CALL_CATCH_EXCEPTION(0);
11161   }
11162
11163   jresult = (void *)result;
11164   return jresult;
11165 }
11166
11167
11168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11169   void * jresult ;
11170   Dali::Quaternion *arg1 = 0 ;
11171   Dali::Property::Value *result = 0 ;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   if (!arg1) {
11175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11176     return 0;
11177   }
11178   {
11179     try {
11180       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11181     } CALL_CATCH_EXCEPTION(0);
11182   }
11183
11184   jresult = (void *)result;
11185   return jresult;
11186 }
11187
11188
11189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11190   void * jresult ;
11191   std::string *arg1 = 0 ;
11192   Dali::Property::Value *result = 0 ;
11193
11194   if (!jarg1) {
11195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11196     return 0;
11197   }
11198   std::string arg1_str(jarg1);
11199   arg1 = &arg1_str;
11200   {
11201     try {
11202       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11203     } CALL_CATCH_EXCEPTION(0);
11204   }
11205
11206   jresult = (void *)result;
11207
11208   //argout typemap for const std::string&
11209
11210   return jresult;
11211 }
11212
11213
11214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11215   void * jresult ;
11216   Dali::Property::Array *arg1 = 0 ;
11217   Dali::Property::Value *result = 0 ;
11218
11219   arg1 = (Dali::Property::Array *)jarg1;
11220   if (!arg1) {
11221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11222     return 0;
11223   }
11224   {
11225     try {
11226       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11227     } CALL_CATCH_EXCEPTION(0);
11228   }
11229
11230   jresult = (void *)result;
11231   return jresult;
11232 }
11233
11234
11235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11236   void * jresult ;
11237   Dali::Property::Map *arg1 = 0 ;
11238   Dali::Property::Value *result = 0 ;
11239
11240   arg1 = (Dali::Property::Map *)jarg1;
11241   if (!arg1) {
11242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11243     return 0;
11244   }
11245   {
11246     try {
11247       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11248     } CALL_CATCH_EXCEPTION(0);
11249   }
11250
11251   jresult = (void *)result;
11252   return jresult;
11253 }
11254
11255
11256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11257   void * jresult ;
11258   Extents *arg1 = 0 ;
11259   Dali::Property::Value *result = 0 ;
11260
11261   arg1 = (Extents *)jarg1;
11262   if (!arg1) {
11263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11264     return 0;
11265   }
11266   {
11267     try {
11268       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11269     } CALL_CATCH_EXCEPTION(0);
11270   }
11271
11272   jresult = (void*) result;
11273   return jresult;
11274 }
11275
11276
11277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11278   void * jresult ;
11279   Dali::Property::Type arg1 ;
11280   Dali::Property::Value *result = 0 ;
11281
11282   arg1 = (Dali::Property::Type)jarg1;
11283   {
11284     try {
11285       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11286     } CALL_CATCH_EXCEPTION(0);
11287   }
11288
11289   jresult = (void *)result;
11290   return jresult;
11291 }
11292
11293
11294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11295   void * jresult ;
11296   Dali::Property::Value *arg1 = 0 ;
11297   Dali::Property::Value *result = 0 ;
11298
11299   arg1 = (Dali::Property::Value *)jarg1;
11300   if (!arg1) {
11301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11302     return 0;
11303   }
11304   {
11305     try {
11306       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11307     } CALL_CATCH_EXCEPTION(0);
11308   }
11309
11310   jresult = (void *)result;
11311   return jresult;
11312 }
11313
11314
11315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11316   void * jresult ;
11317   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11318   Dali::Property::Value *arg2 = 0 ;
11319   Dali::Property::Value *result = 0 ;
11320
11321   arg1 = (Dali::Property::Value *)jarg1;
11322   arg2 = (Dali::Property::Value *)jarg2;
11323   if (!arg2) {
11324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11325     return 0;
11326   }
11327   {
11328     try {
11329       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11330     } CALL_CATCH_EXCEPTION(0);
11331   }
11332
11333   jresult = (void *)result;
11334   return jresult;
11335 }
11336
11337
11338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11339   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11340
11341   arg1 = (Dali::Property::Value *)jarg1;
11342   {
11343     try {
11344       delete arg1;
11345     } CALL_CATCH_EXCEPTION();
11346   }
11347
11348 }
11349
11350
11351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11352   int jresult ;
11353   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11354   Dali::Property::Type result;
11355
11356   arg1 = (Dali::Property::Value *)jarg1;
11357   {
11358     try {
11359       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11360     } CALL_CATCH_EXCEPTION(0);
11361   }
11362
11363   jresult = (int)result;
11364   return jresult;
11365 }
11366
11367
11368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
11369   unsigned int jresult ;
11370   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11371   bool *arg2 = 0 ;
11372   bool result;
11373
11374   arg1 = (Dali::Property::Value *)jarg1;
11375   arg2 = (bool *)jarg2;
11376   {
11377     try {
11378       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11379     } CALL_CATCH_EXCEPTION(0);
11380   }
11381
11382   jresult = result;
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11388   unsigned int jresult ;
11389   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11390   float *arg2 = 0 ;
11391   bool result;
11392
11393   arg1 = (Dali::Property::Value *)jarg1;
11394   arg2 = (float *)jarg2;
11395   {
11396     try {
11397       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11398     } CALL_CATCH_EXCEPTION(0);
11399   }
11400
11401   jresult = result;
11402   return jresult;
11403 }
11404
11405
11406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11407   unsigned int jresult ;
11408   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11409   int *arg2 = 0 ;
11410   bool result;
11411
11412   arg1 = (Dali::Property::Value *)jarg1;
11413   arg2 = (int *)jarg2;
11414   {
11415     try {
11416       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11417     } CALL_CATCH_EXCEPTION(0);
11418   }
11419
11420   jresult = result;
11421   return jresult;
11422 }
11423
11424
11425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11426   unsigned int jresult ;
11427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11428   Dali::Rect< int > *arg2 = 0 ;
11429   bool result;
11430
11431   arg1 = (Dali::Property::Value *)jarg1;
11432   arg2 = (Dali::Rect< int > *)jarg2;
11433   if (!arg2) {
11434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11435     return 0;
11436   }
11437   {
11438     try {
11439       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11440     } CALL_CATCH_EXCEPTION(0);
11441   }
11442
11443   jresult = result;
11444   return jresult;
11445 }
11446
11447
11448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11449   unsigned int jresult ;
11450   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11451   Dali::Vector2 *arg2 = 0 ;
11452   bool result;
11453
11454   arg1 = (Dali::Property::Value *)jarg1;
11455   arg2 = (Dali::Vector2 *)jarg2;
11456   if (!arg2) {
11457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11458     return 0;
11459   }
11460   {
11461     try {
11462       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11463     } CALL_CATCH_EXCEPTION(0);
11464   }
11465
11466   jresult = result;
11467   return jresult;
11468 }
11469
11470
11471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11472   unsigned int jresult ;
11473   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11474   Dali::Vector3 *arg2 = 0 ;
11475   bool result;
11476
11477   arg1 = (Dali::Property::Value *)jarg1;
11478   arg2 = (Dali::Vector3 *)jarg2;
11479   if (!arg2) {
11480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11481     return 0;
11482   }
11483   {
11484     try {
11485       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11486     } CALL_CATCH_EXCEPTION(0);
11487   }
11488
11489   jresult = result;
11490   return jresult;
11491 }
11492
11493
11494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11495   unsigned int jresult ;
11496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11497   Dali::Vector4 *arg2 = 0 ;
11498   bool result;
11499
11500   arg1 = (Dali::Property::Value *)jarg1;
11501   arg2 = (Dali::Vector4 *)jarg2;
11502   if (!arg2) {
11503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11504     return 0;
11505   }
11506   {
11507     try {
11508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11509     } CALL_CATCH_EXCEPTION(0);
11510   }
11511
11512   jresult = result;
11513   return jresult;
11514 }
11515
11516
11517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11518   unsigned int jresult ;
11519   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11520   Dali::Matrix3 *arg2 = 0 ;
11521   bool result;
11522
11523   arg1 = (Dali::Property::Value *)jarg1;
11524   arg2 = (Dali::Matrix3 *)jarg2;
11525   if (!arg2) {
11526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11527     return 0;
11528   }
11529   {
11530     try {
11531       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11532     } CALL_CATCH_EXCEPTION(0);
11533   }
11534
11535   jresult = result;
11536   return jresult;
11537 }
11538
11539
11540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11541   unsigned int jresult ;
11542   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11543   Dali::Matrix *arg2 = 0 ;
11544   bool result;
11545
11546   arg1 = (Dali::Property::Value *)jarg1;
11547   arg2 = (Dali::Matrix *)jarg2;
11548   if (!arg2) {
11549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11550     return 0;
11551   }
11552   {
11553     try {
11554       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11555     } CALL_CATCH_EXCEPTION(0);
11556   }
11557
11558   jresult = result;
11559   return jresult;
11560 }
11561
11562
11563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11564   unsigned int jresult ;
11565   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11566   Dali::AngleAxis *arg2 = 0 ;
11567   bool result;
11568
11569   arg1 = (Dali::Property::Value *)jarg1;
11570   arg2 = (Dali::AngleAxis *)jarg2;
11571   if (!arg2) {
11572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11573     return 0;
11574   }
11575   {
11576     try {
11577       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11578     } CALL_CATCH_EXCEPTION(0);
11579   }
11580
11581   jresult = result;
11582   return jresult;
11583 }
11584
11585
11586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11587   unsigned int jresult ;
11588   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11589   Dali::Quaternion *arg2 = 0 ;
11590   bool result;
11591
11592   arg1 = (Dali::Property::Value *)jarg1;
11593   arg2 = (Dali::Quaternion *)jarg2;
11594   if (!arg2) {
11595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11596     return 0;
11597   }
11598   {
11599     try {
11600       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11601     } CALL_CATCH_EXCEPTION(0);
11602   }
11603
11604   jresult = result;
11605   return jresult;
11606 }
11607
11608
11609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11610   unsigned int jresult ;
11611   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11612   std::string *arg2 = 0 ;
11613   bool result;
11614
11615   arg1 = (Dali::Property::Value *)jarg1;
11616
11617   //typemap in
11618   std::string temp;
11619   arg2 = &temp;
11620
11621   {
11622     try {
11623       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11624     } CALL_CATCH_EXCEPTION(0);
11625   }
11626
11627   jresult = result;
11628
11629   //Typemap argout in c++ file.
11630   //This will convert c++ string to c# string
11631   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11632
11633   return jresult;
11634 }
11635
11636
11637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11638   unsigned int jresult ;
11639   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11640   Dali::Property::Array *arg2 = 0 ;
11641   bool result;
11642
11643   arg1 = (Dali::Property::Value *)jarg1;
11644   arg2 = (Dali::Property::Array *)jarg2;
11645   if (!arg2) {
11646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11647     return 0;
11648   }
11649   {
11650     try {
11651       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11652     } CALL_CATCH_EXCEPTION(0);
11653   }
11654
11655   jresult = result;
11656   return jresult;
11657 }
11658
11659
11660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11661   unsigned int jresult ;
11662   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11663   Dali::Property::Map *arg2 = 0 ;
11664   bool result;
11665
11666   arg1 = (Dali::Property::Value *)jarg1;
11667   arg2 = (Dali::Property::Map *)jarg2;
11668   if (!arg2) {
11669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11670     return 0;
11671   }
11672   {
11673     try {
11674       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11675     } CALL_CATCH_EXCEPTION(0);
11676   }
11677
11678   jresult = result;
11679   return jresult;
11680 }
11681
11682
11683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11684   unsigned int jresult ;
11685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11686   Extents *arg2 = 0 ;
11687   bool result;
11688
11689   arg1 = (Dali::Property::Value *)jarg1;
11690   arg2 = (Extents *)jarg2;
11691   if (!arg2) {
11692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11693     return 0;
11694   }
11695   {
11696     try {
11697       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11698     } CALL_CATCH_EXCEPTION(0);
11699   }
11700   jresult = result;
11701   return jresult;
11702 }
11703
11704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11705   void * jresult ;
11706   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11707   Dali::Property::Array *result = 0 ;
11708
11709   arg1 = (Dali::Property::Value *)jarg1;
11710   {
11711     try {
11712       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11713     } CALL_CATCH_EXCEPTION(0);
11714   }
11715
11716   jresult = (void *)result;
11717   return jresult;
11718 }
11719
11720
11721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11722   void * jresult ;
11723   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11724   Dali::Property::Map *result = 0 ;
11725
11726   arg1 = (Dali::Property::Value *)jarg1;
11727   {
11728     try {
11729       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11730     } CALL_CATCH_EXCEPTION(0);
11731   }
11732
11733   jresult = (void *)result;
11734   return jresult;
11735 }
11736
11737
11738 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11739   char * jresult ;
11740   Dali::Property::Type arg1 ;
11741   char *result = 0 ;
11742
11743   arg1 = (Dali::Property::Type)jarg1;
11744   {
11745     try {
11746       result = (char *)Dali::PropertyTypes::GetName(arg1);
11747     } CALL_CATCH_EXCEPTION(0);
11748   }
11749
11750   jresult = SWIG_csharp_string_callback((const char *)result);
11751   return jresult;
11752 }
11753
11754
11755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11756   unsigned int jresult ;
11757   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11758   std::string *arg2 = 0 ;
11759   Dali::Property::Map *arg3 = 0 ;
11760   bool result;
11761
11762   arg1 = (Dali::BaseObject *)jarg1;
11763   if (!jarg2) {
11764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11765     return 0;
11766   }
11767   std::string arg2_str(jarg2);
11768   arg2 = &arg2_str;
11769   arg3 = (Dali::Property::Map *)jarg3;
11770   if (!arg3) {
11771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11772     return 0;
11773   }
11774   {
11775     try {
11776       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11777     } CALL_CATCH_EXCEPTION(0);
11778   }
11779
11780   jresult = result;
11781
11782   //argout typemap for const std::string&
11783
11784   return jresult;
11785 }
11786
11787
11788 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11789   char * jresult ;
11790   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11791   std::string *result = 0 ;
11792
11793   arg1 = (Dali::BaseObject *)jarg1;
11794   {
11795     try {
11796       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11797     } CALL_CATCH_EXCEPTION(0);
11798   }
11799
11800   jresult = SWIG_csharp_string_callback(result->c_str());
11801   return jresult;
11802 }
11803
11804
11805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11806   unsigned int jresult ;
11807   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11808   Dali::TypeInfo *arg2 = 0 ;
11809   bool result;
11810
11811   arg1 = (Dali::BaseObject *)jarg1;
11812   arg2 = (Dali::TypeInfo *)jarg2;
11813   if (!arg2) {
11814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11815     return 0;
11816   }
11817   {
11818     try {
11819       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11820     } CALL_CATCH_EXCEPTION(0);
11821   }
11822
11823   jresult = result;
11824   return jresult;
11825 }
11826
11827
11828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11829   unsigned int jresult ;
11830   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11831   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11832   std::string *arg3 = 0 ;
11833   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11834   bool result;
11835
11836   arg1 = (Dali::BaseObject *)jarg1;
11837   arg2 = (ConnectionTrackerInterface *)jarg2;
11838   if (!jarg3) {
11839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11840     return 0;
11841   }
11842   std::string arg3_str(jarg3);
11843   arg3 = &arg3_str;
11844   arg4 = (FunctorDelegate *)jarg4;
11845   {
11846     try {
11847       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11848     } CALL_CATCH_EXCEPTION(0);
11849   }
11850
11851   jresult = result;
11852
11853   //argout typemap for const std::string&
11854
11855   return jresult;
11856 }
11857
11858
11859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11860   void * jresult ;
11861   Dali::BaseHandle *arg1 = 0 ;
11862   Dali::BaseObject *result = 0 ;
11863
11864   arg1 = (Dali::BaseHandle *)jarg1;
11865   if (!arg1) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11867     return 0;
11868   }
11869   {
11870     try {
11871       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11872     } CALL_CATCH_EXCEPTION(0);
11873   }
11874
11875   jresult = (void *)result;
11876   return jresult;
11877 }
11878
11879
11880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11881   void * jresult ;
11882   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11883   Dali::BaseHandle *result = 0 ;
11884
11885   arg1 = (Dali::BaseObject *)jarg1;
11886   {
11887     try {
11888       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11889     } CALL_CATCH_EXCEPTION(0);
11890   }
11891
11892   jresult = (void *)result;
11893   return jresult;
11894 }
11895
11896
11897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11898   void * jresult ;
11899   Dali::BaseHandle *result = 0 ;
11900
11901   {
11902     try {
11903       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11904     } CALL_CATCH_EXCEPTION(0);
11905   }
11906
11907   jresult = (void *)result;
11908   return jresult;
11909 }
11910
11911
11912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11913   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11914
11915   arg1 = (Dali::BaseHandle *)jarg1;
11916   {
11917     try {
11918       delete arg1;
11919     } CALL_CATCH_EXCEPTION();
11920   }
11921
11922 }
11923
11924
11925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11926   void * jresult ;
11927   Dali::BaseHandle *arg1 = 0 ;
11928   Dali::BaseHandle *result = 0 ;
11929
11930   arg1 = (Dali::BaseHandle *)jarg1;
11931   if (!arg1) {
11932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11933     return 0;
11934   }
11935   {
11936     try {
11937       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11938     } CALL_CATCH_EXCEPTION(0);
11939   }
11940
11941   jresult = (void *)result;
11942   return jresult;
11943 }
11944
11945
11946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11947   void * jresult ;
11948   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11949   Dali::BaseHandle *arg2 = 0 ;
11950   Dali::BaseHandle *result = 0 ;
11951
11952   arg1 = (Dali::BaseHandle *)jarg1;
11953   arg2 = (Dali::BaseHandle *)jarg2;
11954   if (!arg2) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11956     return 0;
11957   }
11958   {
11959     try {
11960       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11961     } CALL_CATCH_EXCEPTION(0);
11962   }
11963
11964   jresult = (void *)result;
11965   return jresult;
11966 }
11967
11968
11969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11970   unsigned int jresult ;
11971   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11972   std::string *arg2 = 0 ;
11973   Dali::Property::Map *arg3 = 0 ;
11974   bool result;
11975
11976   arg1 = (Dali::BaseHandle *)jarg1;
11977   if (!jarg2) {
11978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11979     return 0;
11980   }
11981   std::string arg2_str(jarg2);
11982   arg2 = &arg2_str;
11983   arg3 = (Dali::Property::Map *)jarg3;
11984   if (!arg3) {
11985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11986     return 0;
11987   }
11988   {
11989     try {
11990       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11991     } CALL_CATCH_EXCEPTION(0);
11992   }
11993
11994   jresult = result;
11995
11996   //argout typemap for const std::string&
11997
11998   return jresult;
11999 }
12000
12001
12002 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
12003   char * jresult ;
12004   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12005   std::string *result = 0 ;
12006
12007   arg1 = (Dali::BaseHandle *)jarg1;
12008   {
12009     try {
12010       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
12011     } CALL_CATCH_EXCEPTION(0);
12012   }
12013
12014   jresult = SWIG_csharp_string_callback(result->c_str());
12015   return jresult;
12016 }
12017
12018
12019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
12020   unsigned int jresult ;
12021   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12022   Dali::TypeInfo *arg2 = 0 ;
12023   bool result;
12024
12025   arg1 = (Dali::BaseHandle *)jarg1;
12026   arg2 = (Dali::TypeInfo *)jarg2;
12027   if (!arg2) {
12028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12029     return 0;
12030   }
12031   {
12032     try {
12033       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12034     } CALL_CATCH_EXCEPTION(0);
12035   }
12036
12037   jresult = result;
12038   return jresult;
12039 }
12040
12041
12042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12043   void * jresult ;
12044   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12045   Dali::BaseObject *result = 0 ;
12046
12047   arg1 = (Dali::BaseHandle *)jarg1;
12048   {
12049     try {
12050       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12051     } CALL_CATCH_EXCEPTION(0);
12052   }
12053
12054   jresult = (void *)result;
12055   return jresult;
12056 }
12057
12058
12059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12060   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12061
12062   arg1 = (Dali::BaseHandle *)jarg1;
12063   {
12064     try {
12065       (arg1)->Reset();
12066     } CALL_CATCH_EXCEPTION();
12067   }
12068
12069 }
12070
12071
12072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12073   unsigned int jresult ;
12074   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12075   Dali::BaseHandle *arg2 = 0 ;
12076   bool result;
12077
12078   arg1 = (Dali::BaseHandle *)jarg1;
12079   arg2 = (Dali::BaseHandle *)jarg2;
12080   if (!arg2) {
12081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12082     return 0;
12083   }
12084   {
12085     try {
12086       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12087     } CALL_CATCH_EXCEPTION(0);
12088   }
12089
12090   jresult = result;
12091   return jresult;
12092 }
12093
12094
12095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12096   unsigned int jresult ;
12097   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12098   Dali::BaseHandle *arg2 = 0 ;
12099   bool result;
12100
12101   arg1 = (Dali::BaseHandle *)jarg1;
12102   arg2 = (Dali::BaseHandle *)jarg2;
12103   if (!arg2) {
12104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12105     return 0;
12106   }
12107   {
12108     try {
12109       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12110     } CALL_CATCH_EXCEPTION(0);
12111   }
12112
12113   jresult = result;
12114   return jresult;
12115 }
12116
12117
12118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12119   void * jresult ;
12120   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12121   Dali::RefObject *result = 0 ;
12122
12123   arg1 = (Dali::BaseHandle *)jarg1;
12124   {
12125     try {
12126       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12127     } CALL_CATCH_EXCEPTION(0);
12128   }
12129
12130   jresult = (void *)result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12136   unsigned int jresult ;
12137   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12138   bool result;
12139
12140   arg1 = (Dali::BaseHandle *)jarg1;
12141   {
12142     try {
12143       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12144     } CALL_CATCH_EXCEPTION(0);
12145   }
12146
12147   jresult = result;
12148   return jresult;
12149 }
12150
12151
12152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12153   unsigned int jresult ;
12154   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12155   Dali::BaseHandle *arg2 = 0 ;
12156   bool result;
12157
12158   arg1 = (Dali::BaseHandle *)jarg1;
12159   arg2 = (Dali::BaseHandle *)jarg2;
12160   if (!arg2) {
12161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12162     return 0;
12163   }
12164   {
12165     try {
12166       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12167     } CALL_CATCH_EXCEPTION(0);
12168   }
12169
12170   jresult = result;
12171   return jresult;
12172 }
12173
12174
12175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12176   unsigned int jresult ;
12177   Dali::BaseHandle *arg1 = 0 ;
12178   Dali::BaseHandle *arg2 = 0 ;
12179   bool result;
12180
12181   arg1 = (Dali::BaseHandle *)jarg1;
12182   if (!arg1) {
12183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12184     return 0;
12185   }
12186   arg2 = (Dali::BaseHandle *)jarg2;
12187   if (!arg2) {
12188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12189     return 0;
12190   }
12191   {
12192     try {
12193       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12194     } CALL_CATCH_EXCEPTION(0);
12195   }
12196
12197   jresult = result;
12198   return jresult;
12199 }
12200
12201
12202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12203   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12204
12205   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12206   {
12207     try {
12208       delete arg1;
12209     } CALL_CATCH_EXCEPTION();
12210   }
12211
12212 }
12213
12214
12215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12216   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12217   SlotObserver *arg2 = (SlotObserver *) 0 ;
12218   CallbackBase *arg3 = (CallbackBase *) 0 ;
12219
12220   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12221   arg2 = (SlotObserver *)jarg2;
12222   arg3 = (CallbackBase *)jarg3;
12223   {
12224     try {
12225       (arg1)->SignalConnected(arg2,arg3);
12226     } CALL_CATCH_EXCEPTION();
12227   }
12228
12229 }
12230
12231
12232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12233   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12234
12235   arg1 = (Dali::SignalObserver *)jarg1;
12236   {
12237     try {
12238       delete arg1;
12239     } CALL_CATCH_EXCEPTION();
12240   }
12241
12242 }
12243
12244
12245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12246   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12247   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12248   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12249
12250   arg1 = (Dali::SignalObserver *)jarg1;
12251   arg2 = (Dali::SlotObserver *)jarg2;
12252   arg3 = (Dali::CallbackBase *)jarg3;
12253   {
12254     try {
12255       (arg1)->SignalDisconnected(arg2,arg3);
12256     } CALL_CATCH_EXCEPTION();
12257   }
12258
12259 }
12260
12261
12262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12263   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12264
12265   arg1 = (Dali::SlotObserver *)jarg1;
12266   {
12267     try {
12268       delete arg1;
12269     } CALL_CATCH_EXCEPTION();
12270   }
12271
12272 }
12273
12274
12275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12276   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12277   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12278
12279   arg1 = (Dali::SlotObserver *)jarg1;
12280   arg2 = (Dali::CallbackBase *)jarg2;
12281   {
12282     try {
12283       (arg1)->SlotDisconnected(arg2);
12284     } CALL_CATCH_EXCEPTION();
12285   }
12286
12287 }
12288
12289
12290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12291   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12292
12293   arg1 = (Dali::ConnectionTracker *)jarg1;
12294   {
12295     try {
12296       delete arg1;
12297     } CALL_CATCH_EXCEPTION();
12298   }
12299
12300 }
12301
12302
12303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12304   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12305
12306   arg1 = (Dali::ConnectionTracker *)jarg1;
12307   {
12308     try {
12309       (arg1)->DisconnectAll();
12310     } CALL_CATCH_EXCEPTION();
12311   }
12312
12313 }
12314
12315
12316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12317   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12318   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12319   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12320
12321   arg1 = (Dali::ConnectionTracker *)jarg1;
12322   arg2 = (Dali::SlotObserver *)jarg2;
12323   arg3 = (Dali::CallbackBase *)jarg3;
12324   {
12325     try {
12326       (arg1)->SignalConnected(arg2,arg3);
12327     } CALL_CATCH_EXCEPTION();
12328   }
12329
12330 }
12331
12332
12333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12334   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12335   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12336   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12337
12338   arg1 = (Dali::ConnectionTracker *)jarg1;
12339   arg2 = (Dali::SlotObserver *)jarg2;
12340   arg3 = (Dali::CallbackBase *)jarg3;
12341   {
12342     try {
12343       (arg1)->SignalDisconnected(arg2,arg3);
12344     } CALL_CATCH_EXCEPTION();
12345   }
12346
12347 }
12348
12349
12350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12351   unsigned long jresult ;
12352   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12353   std::size_t result;
12354
12355   arg1 = (Dali::ConnectionTracker *)jarg1;
12356   {
12357     try {
12358       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12359     } CALL_CATCH_EXCEPTION(0);
12360   }
12361
12362   jresult = (unsigned long)result;
12363   return jresult;
12364 }
12365
12366
12367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12368   void * jresult ;
12369   Dali::ObjectRegistry *result = 0 ;
12370
12371   {
12372     try {
12373       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12374     } CALL_CATCH_EXCEPTION(0);
12375   }
12376
12377   jresult = (void *)result;
12378   return jresult;
12379 }
12380
12381
12382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12383   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12384
12385   arg1 = (Dali::ObjectRegistry *)jarg1;
12386   {
12387     try {
12388       delete arg1;
12389     } CALL_CATCH_EXCEPTION();
12390   }
12391
12392 }
12393
12394
12395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12396   void * jresult ;
12397   Dali::ObjectRegistry *arg1 = 0 ;
12398   Dali::ObjectRegistry *result = 0 ;
12399
12400   arg1 = (Dali::ObjectRegistry *)jarg1;
12401   if (!arg1) {
12402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12403     return 0;
12404   }
12405   {
12406     try {
12407       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12408     } CALL_CATCH_EXCEPTION(0);
12409   }
12410
12411   jresult = (void *)result;
12412   return jresult;
12413 }
12414
12415
12416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12417   void * jresult ;
12418   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12419   Dali::ObjectRegistry *arg2 = 0 ;
12420   Dali::ObjectRegistry *result = 0 ;
12421
12422   arg1 = (Dali::ObjectRegistry *)jarg1;
12423   arg2 = (Dali::ObjectRegistry *)jarg2;
12424   if (!arg2) {
12425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12426     return 0;
12427   }
12428   {
12429     try {
12430       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12431     } CALL_CATCH_EXCEPTION(0);
12432   }
12433
12434   jresult = (void *)result;
12435   return jresult;
12436 }
12437
12438
12439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12440   void * jresult ;
12441   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12442   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12443
12444   arg1 = (Dali::ObjectRegistry *)jarg1;
12445   {
12446     try {
12447       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12448     } CALL_CATCH_EXCEPTION(0);
12449   }
12450
12451   jresult = (void *)result;
12452   return jresult;
12453 }
12454
12455
12456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12457   void * jresult ;
12458   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12459   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12460
12461   arg1 = (Dali::ObjectRegistry *)jarg1;
12462   {
12463     try {
12464       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12465     } CALL_CATCH_EXCEPTION(0);
12466   }
12467
12468   jresult = (void *)result;
12469   return jresult;
12470 }
12471
12472
12473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12474   void * jresult ;
12475   Dali::PropertyCondition *result = 0 ;
12476
12477   {
12478     try {
12479       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12480     } CALL_CATCH_EXCEPTION(0);
12481   }
12482
12483   jresult = (void *)result;
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12489   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12490
12491   arg1 = (Dali::PropertyCondition *)jarg1;
12492   {
12493     try {
12494       delete arg1;
12495     } CALL_CATCH_EXCEPTION();
12496   }
12497
12498 }
12499
12500
12501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12502   void * jresult ;
12503   Dali::PropertyCondition *arg1 = 0 ;
12504   Dali::PropertyCondition *result = 0 ;
12505
12506   arg1 = (Dali::PropertyCondition *)jarg1;
12507   if (!arg1) {
12508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12509     return 0;
12510   }
12511   {
12512     try {
12513       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12514     } CALL_CATCH_EXCEPTION(0);
12515   }
12516
12517   jresult = (void *)result;
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12523   void * jresult ;
12524   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12525   Dali::PropertyCondition *arg2 = 0 ;
12526   Dali::PropertyCondition *result = 0 ;
12527
12528   arg1 = (Dali::PropertyCondition *)jarg1;
12529   arg2 = (Dali::PropertyCondition *)jarg2;
12530   if (!arg2) {
12531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12532     return 0;
12533   }
12534   {
12535     try {
12536       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12537     } CALL_CATCH_EXCEPTION(0);
12538   }
12539
12540   jresult = (void *)result;
12541   return jresult;
12542 }
12543
12544
12545 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12546   unsigned long jresult ;
12547   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12548   std::size_t result;
12549
12550   arg1 = (Dali::PropertyCondition *)jarg1;
12551   {
12552     try {
12553       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12554     } CALL_CATCH_EXCEPTION(0);
12555   }
12556   jresult = (unsigned long)result;
12557   return jresult;
12558 }
12559
12560
12561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12562   float jresult ;
12563   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12564   std::size_t arg2 ;
12565   float result;
12566
12567   arg1 = (Dali::PropertyCondition *)jarg1;
12568   arg2 = (std::size_t)jarg2;
12569   {
12570     try {
12571       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12572     } CALL_CATCH_EXCEPTION(0);
12573   }
12574   jresult = result;
12575   return jresult;
12576 }
12577
12578
12579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12580   void * jresult ;
12581   float arg1 ;
12582   Dali::PropertyCondition result;
12583
12584   arg1 = (float)jarg1;
12585   {
12586     try {
12587       result = Dali::LessThanCondition(arg1);
12588     } CALL_CATCH_EXCEPTION(0);
12589   }
12590
12591   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12592   return jresult;
12593 }
12594
12595
12596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12597   void * jresult ;
12598   float arg1 ;
12599   Dali::PropertyCondition result;
12600
12601   arg1 = (float)jarg1;
12602   {
12603     try {
12604       result = Dali::GreaterThanCondition(arg1);
12605     } CALL_CATCH_EXCEPTION(0);
12606   }
12607
12608   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12614   void * jresult ;
12615   float arg1 ;
12616   float arg2 ;
12617   Dali::PropertyCondition result;
12618
12619   arg1 = (float)jarg1;
12620   arg2 = (float)jarg2;
12621   {
12622     try {
12623       result = Dali::InsideCondition(arg1,arg2);
12624     } CALL_CATCH_EXCEPTION(0);
12625   }
12626
12627   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12628   return jresult;
12629 }
12630
12631
12632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12633   void * jresult ;
12634   float arg1 ;
12635   float arg2 ;
12636   Dali::PropertyCondition result;
12637
12638   arg1 = (float)jarg1;
12639   arg2 = (float)jarg2;
12640   {
12641     try {
12642       result = Dali::OutsideCondition(arg1,arg2);
12643     } CALL_CATCH_EXCEPTION(0);
12644   }
12645
12646   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12647   return jresult;
12648 }
12649
12650
12651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12652   void * jresult ;
12653   float arg1 ;
12654   float arg2 ;
12655   Dali::PropertyCondition result;
12656
12657   arg1 = (float)jarg1;
12658   arg2 = (float)jarg2;
12659   {
12660     try {
12661       result = Dali::StepCondition(arg1,arg2);
12662     } CALL_CATCH_EXCEPTION(0);
12663   }
12664
12665   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12666   return jresult;
12667 }
12668
12669
12670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12671   void * jresult ;
12672   float arg1 ;
12673   Dali::PropertyCondition result;
12674
12675   arg1 = (float)jarg1;
12676   {
12677     try {
12678       result = Dali::StepCondition(arg1);
12679     } CALL_CATCH_EXCEPTION(0);
12680   }
12681
12682   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12683   return jresult;
12684 }
12685
12686
12687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12688   void * jresult ;
12689   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12690   Dali::PropertyCondition result;
12691
12692   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12693   if (!arg1) {
12694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12695     return 0;
12696   }
12697   {
12698     try {
12699       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12700     } CALL_CATCH_EXCEPTION(0);
12701   }
12702
12703   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12704   return jresult;
12705 }
12706
12707
12708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12709   void * jresult ;
12710   Dali::PropertyNotification *result = 0 ;
12711
12712   {
12713     try {
12714       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12715     } CALL_CATCH_EXCEPTION(0);
12716   }
12717
12718   jresult = (void *)result;
12719   return jresult;
12720 }
12721
12722
12723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12724   void * jresult ;
12725   Dali::BaseHandle arg1 ;
12726   Dali::BaseHandle *argp1 ;
12727   Dali::PropertyNotification result;
12728
12729   argp1 = (Dali::BaseHandle *)jarg1;
12730   if (!argp1) {
12731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12732     return 0;
12733   }
12734   arg1 = *argp1;
12735   {
12736     try {
12737       result = Dali::PropertyNotification::DownCast(arg1);
12738     } CALL_CATCH_EXCEPTION(0);
12739   }
12740
12741   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12742   return jresult;
12743 }
12744
12745
12746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12747   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12748
12749   arg1 = (Dali::PropertyNotification *)jarg1;
12750   {
12751     try {
12752       delete arg1;
12753     } CALL_CATCH_EXCEPTION();
12754   }
12755
12756 }
12757
12758
12759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12760   void * jresult ;
12761   Dali::PropertyNotification *arg1 = 0 ;
12762   Dali::PropertyNotification *result = 0 ;
12763
12764   arg1 = (Dali::PropertyNotification *)jarg1;
12765   if (!arg1) {
12766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12767     return 0;
12768   }
12769   {
12770     try {
12771       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12772     } CALL_CATCH_EXCEPTION(0);
12773   }
12774
12775   jresult = (void *)result;
12776   return jresult;
12777 }
12778
12779
12780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12781   void * jresult ;
12782   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12783   Dali::PropertyNotification *arg2 = 0 ;
12784   Dali::PropertyNotification *result = 0 ;
12785
12786   arg1 = (Dali::PropertyNotification *)jarg1;
12787   arg2 = (Dali::PropertyNotification *)jarg2;
12788   if (!arg2) {
12789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12790     return 0;
12791   }
12792   {
12793     try {
12794       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12795     } CALL_CATCH_EXCEPTION(0);
12796   }
12797
12798   jresult = (void *)result;
12799   return jresult;
12800 }
12801
12802
12803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12804   void * jresult ;
12805   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12806   Dali::PropertyCondition result;
12807
12808   arg1 = (Dali::PropertyNotification *)jarg1;
12809   {
12810     try {
12811       result = (arg1)->GetCondition();
12812     } CALL_CATCH_EXCEPTION(0);
12813   }
12814
12815   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12816   return jresult;
12817 }
12818
12819
12820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12821   void * jresult ;
12822   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12823   Dali::Handle result;
12824
12825   arg1 = (Dali::PropertyNotification *)jarg1;
12826   {
12827     try {
12828       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12829     } CALL_CATCH_EXCEPTION(0);
12830   }
12831
12832   jresult = new Dali::Handle((const Dali::Handle &)result);
12833   return jresult;
12834 }
12835
12836
12837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12838   int jresult ;
12839   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12840   Dali::Property::Index result;
12841
12842   arg1 = (Dali::PropertyNotification *)jarg1;
12843   {
12844     try {
12845       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12846     } CALL_CATCH_EXCEPTION(0);
12847   }
12848
12849   jresult = result;
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12855   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12856   Dali::PropertyNotification::NotifyMode arg2 ;
12857
12858   arg1 = (Dali::PropertyNotification *)jarg1;
12859   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12860   {
12861     try {
12862       (arg1)->SetNotifyMode(arg2);
12863     } CALL_CATCH_EXCEPTION();
12864   }
12865
12866 }
12867
12868
12869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12870   int jresult ;
12871   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12872   Dali::PropertyNotification::NotifyMode result;
12873
12874   arg1 = (Dali::PropertyNotification *)jarg1;
12875   {
12876     try {
12877       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12878     } CALL_CATCH_EXCEPTION(0);
12879   }
12880
12881   jresult = (int)result;
12882   return jresult;
12883 }
12884
12885
12886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12887   unsigned int jresult ;
12888   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12889   bool result;
12890
12891   arg1 = (Dali::PropertyNotification *)jarg1;
12892   {
12893     try {
12894       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12895     } CALL_CATCH_EXCEPTION(0);
12896   }
12897
12898   jresult = result;
12899   return jresult;
12900 }
12901
12902
12903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12904   void * jresult ;
12905   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12906   Dali::PropertyNotifySignalType *result = 0 ;
12907
12908   arg1 = (Dali::PropertyNotification *)jarg1;
12909   {
12910     try {
12911       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12912     } CALL_CATCH_EXCEPTION(0);
12913   }
12914
12915   jresult = (void *)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12921   void * jresult ;
12922   Dali::Handle *result = 0 ;
12923
12924   {
12925     try {
12926       result = (Dali::Handle *)new Dali::Handle();
12927     } CALL_CATCH_EXCEPTION(0);
12928   }
12929
12930   jresult = (void *)result;
12931   return jresult;
12932 }
12933
12934
12935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12936   void * jresult ;
12937   Dali::Handle result;
12938
12939   {
12940     try {
12941       result = Dali::Handle::New();
12942     } CALL_CATCH_EXCEPTION(0);
12943   }
12944
12945   jresult = new Dali::Handle((const Dali::Handle &)result);
12946   return jresult;
12947 }
12948
12949
12950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12951   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12952
12953   arg1 = (Dali::Handle *)jarg1;
12954   {
12955     try {
12956       delete arg1;
12957     } CALL_CATCH_EXCEPTION();
12958   }
12959
12960 }
12961
12962
12963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12964   void * jresult ;
12965   Dali::Handle *arg1 = 0 ;
12966   Dali::Handle *result = 0 ;
12967
12968   arg1 = (Dali::Handle *)jarg1;
12969   if (!arg1) {
12970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12971     return 0;
12972   }
12973   {
12974     try {
12975       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12976     } CALL_CATCH_EXCEPTION(0);
12977   }
12978
12979   jresult = (void *)result;
12980   return jresult;
12981 }
12982
12983
12984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12985   void * jresult ;
12986   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12987   Dali::Handle *arg2 = 0 ;
12988   Dali::Handle *result = 0 ;
12989
12990   arg1 = (Dali::Handle *)jarg1;
12991   arg2 = (Dali::Handle *)jarg2;
12992   if (!arg2) {
12993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12994     return 0;
12995   }
12996   {
12997     try {
12998       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12999     } CALL_CATCH_EXCEPTION(0);
13000   }
13001
13002   jresult = (void *)result;
13003   return jresult;
13004 }
13005
13006
13007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
13008   void * jresult ;
13009   Dali::BaseHandle arg1 ;
13010   Dali::BaseHandle *argp1 ;
13011   Dali::Handle result;
13012
13013   argp1 = (Dali::BaseHandle *)jarg1;
13014   if (!argp1) {
13015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13016     return 0;
13017   }
13018   arg1 = *argp1;
13019   {
13020     try {
13021       result = Dali::Handle::DownCast(arg1);
13022     } CALL_CATCH_EXCEPTION(0);
13023   }
13024
13025   jresult = new Dali::Handle((const Dali::Handle &)result);
13026   return jresult;
13027 }
13028
13029
13030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13031   unsigned int jresult ;
13032   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13033   Dali::Handle::Capability arg2 ;
13034   bool result;
13035
13036   arg1 = (Dali::Handle *)jarg1;
13037   arg2 = (Dali::Handle::Capability)jarg2;
13038   {
13039     try {
13040       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13041     } CALL_CATCH_EXCEPTION(0);
13042   }
13043
13044   jresult = result;
13045   return jresult;
13046 }
13047
13048
13049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13050   unsigned int jresult ;
13051   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13052   unsigned int result;
13053
13054   arg1 = (Dali::Handle *)jarg1;
13055   {
13056     try {
13057       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13058     } CALL_CATCH_EXCEPTION(0);
13059   }
13060
13061   jresult = result;
13062   return jresult;
13063 }
13064
13065
13066 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13067   char * jresult ;
13068   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13069   Dali::Property::Index arg2 ;
13070   std::string result;
13071
13072   arg1 = (Dali::Handle *)jarg1;
13073   arg2 = (Dali::Property::Index)jarg2;
13074   {
13075     try {
13076       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13077     } CALL_CATCH_EXCEPTION(0);
13078   }
13079
13080   jresult = SWIG_csharp_string_callback((&result)->c_str());
13081   return jresult;
13082 }
13083
13084
13085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13086   int jresult ;
13087   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13088   std::string *arg2 = 0 ;
13089   Dali::Property::Index result;
13090
13091   arg1 = (Dali::Handle *)jarg1;
13092   if (!jarg2) {
13093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13094     return 0;
13095   }
13096   std::string arg2_str(jarg2);
13097   arg2 = &arg2_str;
13098   {
13099     try {
13100       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13101     } CALL_CATCH_EXCEPTION(0);
13102   }
13103
13104   jresult = result;
13105
13106   //argout typemap for const std::string&
13107
13108   return jresult;
13109 }
13110
13111
13112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13113   unsigned int jresult ;
13114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13115   Dali::Property::Index arg2 ;
13116   bool result;
13117
13118   arg1 = (Dali::Handle *)jarg1;
13119   arg2 = (Dali::Property::Index)jarg2;
13120   {
13121     try {
13122       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13123     } CALL_CATCH_EXCEPTION(0);
13124   }
13125
13126   jresult = result;
13127   return jresult;
13128 }
13129
13130
13131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13132   unsigned int jresult ;
13133   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13134   Dali::Property::Index arg2 ;
13135   bool result;
13136
13137   arg1 = (Dali::Handle *)jarg1;
13138   arg2 = (Dali::Property::Index)jarg2;
13139   {
13140     try {
13141       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13142     } CALL_CATCH_EXCEPTION(0);
13143   }
13144
13145   jresult = result;
13146   return jresult;
13147 }
13148
13149
13150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13151   unsigned int jresult ;
13152   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13153   Dali::Property::Index arg2 ;
13154   bool result;
13155
13156   arg1 = (Dali::Handle *)jarg1;
13157   arg2 = (Dali::Property::Index)jarg2;
13158   {
13159     try {
13160       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13161     } CALL_CATCH_EXCEPTION(0);
13162   }
13163
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13170   int jresult ;
13171   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13172   Dali::Property::Index arg2 ;
13173   Dali::Property::Type result;
13174
13175   arg1 = (Dali::Handle *)jarg1;
13176   arg2 = (Dali::Property::Index)jarg2;
13177   {
13178     try {
13179       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13180     } CALL_CATCH_EXCEPTION(0);
13181   }
13182
13183   jresult = (int)result;
13184   return jresult;
13185 }
13186
13187
13188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13189   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13190   Dali::Property::Index arg2 ;
13191   Dali::Property::Value *arg3 = 0 ;
13192
13193   arg1 = (Dali::Handle *)jarg1;
13194   arg2 = (Dali::Property::Index)jarg2;
13195   arg3 = (Dali::Property::Value *)jarg3;
13196   if (!arg3) {
13197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13198     return ;
13199   }
13200   {
13201     try {
13202       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13203     } CALL_CATCH_EXCEPTION();
13204   }
13205
13206 }
13207
13208
13209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13210   int jresult ;
13211   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13212   std::string *arg2 = 0 ;
13213   Dali::Property::Value *arg3 = 0 ;
13214   Dali::Property::Index result;
13215
13216   arg1 = (Dali::Handle *)jarg1;
13217   if (!jarg2) {
13218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13219     return 0;
13220   }
13221   std::string arg2_str(jarg2);
13222   arg2 = &arg2_str;
13223   arg3 = (Dali::Property::Value *)jarg3;
13224   if (!arg3) {
13225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13226     return 0;
13227   }
13228   {
13229     try {
13230       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13231     } CALL_CATCH_EXCEPTION(0);
13232   }
13233
13234   jresult = result;
13235
13236   //argout typemap for const std::string&
13237
13238   return jresult;
13239 }
13240
13241
13242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13243   int jresult ;
13244   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13245   std::string *arg2 = 0 ;
13246   Dali::Property::Value *arg3 = 0 ;
13247   Dali::Property::AccessMode arg4 ;
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   arg4 = (Dali::Property::AccessMode)jarg4;
13263   {
13264     try {
13265       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13266     } CALL_CATCH_EXCEPTION(0);
13267   }
13268
13269   jresult = result;
13270
13271   //argout typemap for const std::string&
13272
13273   return jresult;
13274 }
13275
13276
13277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13278   void * jresult ;
13279   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13280   Dali::Property::Index arg2 ;
13281   Dali::Property::Value result;
13282
13283   arg1 = (Dali::Handle *)jarg1;
13284   arg2 = (Dali::Property::Index)jarg2;
13285   {
13286     try {
13287       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13288     } CALL_CATCH_EXCEPTION(0);
13289   }
13290
13291   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13292   return jresult;
13293 }
13294
13295
13296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13297   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13298   Dali::Property::IndexContainer *arg2 = 0 ;
13299
13300   arg1 = (Dali::Handle *)jarg1;
13301   arg2 = (Dali::Property::IndexContainer *)jarg2;
13302   if (!arg2) {
13303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13304     return ;
13305   }
13306   {
13307     try {
13308       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13309     } CALL_CATCH_EXCEPTION();
13310   }
13311
13312 }
13313
13314
13315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13316   void * jresult ;
13317   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13318   Dali::Property::Index arg2 ;
13319   Dali::PropertyCondition *arg3 = 0 ;
13320   Dali::PropertyNotification result;
13321
13322   arg1 = (Dali::Handle *)jarg1;
13323   arg2 = (Dali::Property::Index)jarg2;
13324   arg3 = (Dali::PropertyCondition *)jarg3;
13325   if (!arg3) {
13326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13327     return 0;
13328   }
13329   {
13330     try {
13331       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13332     } CALL_CATCH_EXCEPTION(0);
13333   }
13334
13335   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13336   return jresult;
13337 }
13338
13339
13340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13341   void * jresult ;
13342   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13343   Dali::Property::Index arg2 ;
13344   int arg3 ;
13345   Dali::PropertyCondition *arg4 = 0 ;
13346   Dali::PropertyNotification result;
13347
13348   arg1 = (Dali::Handle *)jarg1;
13349   arg2 = (Dali::Property::Index)jarg2;
13350   arg3 = (int)jarg3;
13351   arg4 = (Dali::PropertyCondition *)jarg4;
13352   if (!arg4) {
13353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13354     return 0;
13355   }
13356   {
13357     try {
13358       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13359     } CALL_CATCH_EXCEPTION(0);
13360   }
13361
13362   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13363   return jresult;
13364 }
13365
13366
13367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13368   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13369   Dali::PropertyNotification arg2 ;
13370   Dali::PropertyNotification *argp2 ;
13371
13372   arg1 = (Dali::Handle *)jarg1;
13373   argp2 = (Dali::PropertyNotification *)jarg2;
13374   if (!argp2) {
13375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13376     return ;
13377   }
13378   arg2 = *argp2;
13379   {
13380     try {
13381       (arg1)->RemovePropertyNotification(arg2);
13382     } CALL_CATCH_EXCEPTION();
13383   }
13384
13385 }
13386
13387
13388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13389   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13390
13391   arg1 = (Dali::Handle *)jarg1;
13392   {
13393     try {
13394       (arg1)->RemovePropertyNotifications();
13395     } CALL_CATCH_EXCEPTION();
13396   }
13397
13398 }
13399
13400
13401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13402   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13403
13404   arg1 = (Dali::Handle *)jarg1;
13405   {
13406     try {
13407       (arg1)->RemoveConstraints();
13408     } CALL_CATCH_EXCEPTION();
13409   }
13410
13411 }
13412
13413
13414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13415   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13416   unsigned int arg2 ;
13417
13418   arg1 = (Dali::Handle *)jarg1;
13419   arg2 = (unsigned int)jarg2;
13420   {
13421     try {
13422       (arg1)->RemoveConstraints(arg2);
13423     } CALL_CATCH_EXCEPTION();
13424   }
13425
13426 }
13427
13428
13429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13430   int jresult ;
13431   Dali::Property::Index result;
13432
13433   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13434   jresult = result;
13435   return jresult;
13436 }
13437
13438
13439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13440   void * jresult ;
13441   Dali::Handle result;
13442
13443   {
13444     try {
13445       result = Dali::WeightObject::New();
13446     } CALL_CATCH_EXCEPTION(0);
13447   }
13448
13449   jresult = new Dali::Handle((const Dali::Handle &)result);
13450   return jresult;
13451 }
13452
13453
13454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13455   void * jresult ;
13456   Dali::TypeInfo *result = 0 ;
13457
13458   {
13459     try {
13460       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13461     } CALL_CATCH_EXCEPTION(0);
13462   }
13463
13464   jresult = (void *)result;
13465   return jresult;
13466 }
13467
13468
13469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13470   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13471
13472   arg1 = (Dali::TypeInfo *)jarg1;
13473   {
13474     try {
13475       delete arg1;
13476     } CALL_CATCH_EXCEPTION();
13477   }
13478
13479 }
13480
13481
13482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13483   void * jresult ;
13484   Dali::TypeInfo *arg1 = 0 ;
13485   Dali::TypeInfo *result = 0 ;
13486
13487   arg1 = (Dali::TypeInfo *)jarg1;
13488   if (!arg1) {
13489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13490     return 0;
13491   }
13492   {
13493     try {
13494       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13495     } CALL_CATCH_EXCEPTION(0);
13496   }
13497
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13504   void * jresult ;
13505   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13506   Dali::TypeInfo *arg2 = 0 ;
13507   Dali::TypeInfo *result = 0 ;
13508
13509   arg1 = (Dali::TypeInfo *)jarg1;
13510   arg2 = (Dali::TypeInfo *)jarg2;
13511   if (!arg2) {
13512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13513     return 0;
13514   }
13515   {
13516     try {
13517       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13518     } CALL_CATCH_EXCEPTION(0);
13519   }
13520
13521   jresult = (void *)result;
13522   return jresult;
13523 }
13524
13525
13526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13527   char * jresult ;
13528   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13529   std::string *result = 0 ;
13530
13531   arg1 = (Dali::TypeInfo *)jarg1;
13532   {
13533     try {
13534       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13535     } CALL_CATCH_EXCEPTION(0);
13536   }
13537
13538   jresult = SWIG_csharp_string_callback(result->c_str());
13539   return jresult;
13540 }
13541
13542
13543 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13544   char * jresult ;
13545   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13546   std::string *result = 0 ;
13547
13548   arg1 = (Dali::TypeInfo *)jarg1;
13549   {
13550     try {
13551       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13552     } CALL_CATCH_EXCEPTION(0);
13553   }
13554
13555   jresult = SWIG_csharp_string_callback(result->c_str());
13556   return jresult;
13557 }
13558
13559
13560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13561   void * jresult ;
13562   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13563   Dali::BaseHandle result;
13564
13565   arg1 = (Dali::TypeInfo *)jarg1;
13566   {
13567     try {
13568       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13569     } CALL_CATCH_EXCEPTION(0);
13570   }
13571
13572   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13573   return jresult;
13574 }
13575
13576
13577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13578   unsigned long jresult ;
13579   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13580   size_t result;
13581
13582   arg1 = (Dali::TypeInfo *)jarg1;
13583   {
13584     try {
13585       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13586     } CALL_CATCH_EXCEPTION(0);
13587   }
13588
13589   jresult = (unsigned long)result;
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13595   char * jresult ;
13596   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13597   size_t arg2 ;
13598   std::string result;
13599
13600   arg1 = (Dali::TypeInfo *)jarg1;
13601   arg2 = (size_t)jarg2;
13602   {
13603     try {
13604       result = (arg1)->GetActionName(arg2);
13605     } CALL_CATCH_EXCEPTION(0);
13606   }
13607
13608   jresult = SWIG_csharp_string_callback((&result)->c_str());
13609   return jresult;
13610 }
13611
13612
13613 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13614   unsigned long jresult ;
13615   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13616   size_t result;
13617
13618   arg1 = (Dali::TypeInfo *)jarg1;
13619   {
13620     try {
13621       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13622     } CALL_CATCH_EXCEPTION(0);
13623   }
13624
13625   jresult = (unsigned long)result;
13626   return jresult;
13627 }
13628
13629
13630 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13631   char * jresult ;
13632   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13633   size_t arg2 ;
13634   std::string result;
13635
13636   arg1 = (Dali::TypeInfo *)jarg1;
13637   arg2 = (size_t)jarg2;
13638   {
13639     try {
13640       result = (arg1)->GetSignalName(arg2);
13641     } CALL_CATCH_EXCEPTION(0);
13642   }
13643
13644   jresult = SWIG_csharp_string_callback((&result)->c_str());
13645   return jresult;
13646 }
13647
13648
13649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13650   unsigned long jresult ;
13651   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13652   size_t result;
13653
13654   arg1 = (Dali::TypeInfo *)jarg1;
13655   {
13656     try {
13657       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13658     } CALL_CATCH_EXCEPTION(0);
13659   }
13660
13661   jresult = (unsigned long)result;
13662   return jresult;
13663 }
13664
13665
13666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13667   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13668   Dali::Property::IndexContainer *arg2 = 0 ;
13669
13670   arg1 = (Dali::TypeInfo *)jarg1;
13671   arg2 = (Dali::Property::IndexContainer *)jarg2;
13672   if (!arg2) {
13673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13674     return ;
13675   }
13676   {
13677     try {
13678       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13679     } CALL_CATCH_EXCEPTION();
13680   }
13681
13682 }
13683
13684
13685 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13686   char * jresult ;
13687   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13688   Dali::Property::Index arg2 ;
13689   std::string *result = 0 ;
13690
13691   arg1 = (Dali::TypeInfo *)jarg1;
13692   arg2 = (Dali::Property::Index)jarg2;
13693   {
13694     try {
13695       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13696     } CALL_CATCH_EXCEPTION(0);
13697   }
13698
13699   jresult = SWIG_csharp_string_callback(result->c_str());
13700   return jresult;
13701 }
13702
13703
13704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13705   void * jresult ;
13706   Dali::TypeRegistry result;
13707
13708   {
13709     try {
13710       result = Dali::TypeRegistry::Get();
13711     } CALL_CATCH_EXCEPTION(0);
13712   }
13713
13714   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13715   return jresult;
13716 }
13717
13718
13719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13720   void * jresult ;
13721   Dali::TypeRegistry *result = 0 ;
13722
13723   {
13724     try {
13725       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13726     } CALL_CATCH_EXCEPTION(0);
13727   }
13728
13729   jresult = (void *)result;
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13735   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13736
13737   arg1 = (Dali::TypeRegistry *)jarg1;
13738   {
13739     try {
13740       delete arg1;
13741     } CALL_CATCH_EXCEPTION();
13742   }
13743
13744 }
13745
13746
13747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13748   void * jresult ;
13749   Dali::TypeRegistry *arg1 = 0 ;
13750   Dali::TypeRegistry *result = 0 ;
13751
13752   arg1 = (Dali::TypeRegistry *)jarg1;
13753   if (!arg1) {
13754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13755     return 0;
13756   }
13757   {
13758     try {
13759       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13760     } CALL_CATCH_EXCEPTION(0);
13761   }
13762
13763   jresult = (void *)result;
13764   return jresult;
13765 }
13766
13767
13768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13769   void * jresult ;
13770   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13771   Dali::TypeRegistry *arg2 = 0 ;
13772   Dali::TypeRegistry *result = 0 ;
13773
13774   arg1 = (Dali::TypeRegistry *)jarg1;
13775   arg2 = (Dali::TypeRegistry *)jarg2;
13776   if (!arg2) {
13777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13778     return 0;
13779   }
13780   {
13781     try {
13782       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13783     } CALL_CATCH_EXCEPTION(0);
13784   }
13785
13786   jresult = (void *)result;
13787   return jresult;
13788 }
13789
13790
13791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13792   void * jresult ;
13793   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13794   std::string *arg2 = 0 ;
13795   Dali::TypeInfo result;
13796
13797   arg1 = (Dali::TypeRegistry *)jarg1;
13798   if (!jarg2) {
13799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13800     return 0;
13801   }
13802   std::string arg2_str(jarg2);
13803   arg2 = &arg2_str;
13804   {
13805     try {
13806       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13807     } CALL_CATCH_EXCEPTION(0);
13808   }
13809
13810   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13811
13812   //argout typemap for const std::string&
13813
13814   return jresult;
13815 }
13816
13817
13818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13819   void * jresult ;
13820   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13821   std::type_info *arg2 = 0 ;
13822   Dali::TypeInfo result;
13823
13824   arg1 = (Dali::TypeRegistry *)jarg1;
13825   arg2 = (std::type_info *)jarg2;
13826   if (!arg2) {
13827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13828     return 0;
13829   }
13830   {
13831     try {
13832       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13833     } CALL_CATCH_EXCEPTION(0);
13834   }
13835
13836   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13842   unsigned long jresult ;
13843   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13844   size_t result;
13845
13846   arg1 = (Dali::TypeRegistry *)jarg1;
13847   {
13848     try {
13849       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13850     } CALL_CATCH_EXCEPTION(0);
13851   }
13852
13853   jresult = (unsigned long)result;
13854   return jresult;
13855 }
13856
13857
13858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13859   char * jresult ;
13860   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13861   size_t arg2 ;
13862   std::string result;
13863
13864   arg1 = (Dali::TypeRegistry *)jarg1;
13865   arg2 = (size_t)jarg2;
13866   {
13867     try {
13868       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13869     } CALL_CATCH_EXCEPTION(0);
13870   }
13871
13872   jresult = SWIG_csharp_string_callback((&result)->c_str());
13873   return jresult;
13874 }
13875
13876
13877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13878   void * jresult ;
13879   std::type_info *arg1 = 0 ;
13880   std::type_info *arg2 = 0 ;
13881   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13882   Dali::TypeRegistration *result = 0 ;
13883
13884   arg1 = (std::type_info *)jarg1;
13885   if (!arg1) {
13886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13887     return 0;
13888   }
13889   arg2 = (std::type_info *)jarg2;
13890   if (!arg2) {
13891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13892     return 0;
13893   }
13894   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13895   {
13896     try {
13897       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13898     } CALL_CATCH_EXCEPTION(0);
13899   }
13900
13901   jresult = (void *)result;
13902   return jresult;
13903 }
13904
13905
13906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
13907   void * jresult ;
13908   std::type_info *arg1 = 0 ;
13909   std::type_info *arg2 = 0 ;
13910   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13911   bool arg4 ;
13912   Dali::TypeRegistration *result = 0 ;
13913
13914   arg1 = (std::type_info *)jarg1;
13915   if (!arg1) {
13916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13917     return 0;
13918   }
13919   arg2 = (std::type_info *)jarg2;
13920   if (!arg2) {
13921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13922     return 0;
13923   }
13924   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13925   arg4 = jarg4 ? true : false;
13926   {
13927     try {
13928       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13929     } CALL_CATCH_EXCEPTION(0);
13930   }
13931
13932   jresult = (void *)result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13938   void * jresult ;
13939   std::string *arg1 = 0 ;
13940   std::type_info *arg2 = 0 ;
13941   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13942   Dali::TypeRegistration *result = 0 ;
13943
13944   if (!jarg1) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13946     return 0;
13947   }
13948   std::string arg1_str(jarg1);
13949   arg1 = &arg1_str;
13950   arg2 = (std::type_info *)jarg2;
13951   if (!arg2) {
13952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13953     return 0;
13954   }
13955   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13956   {
13957     try {
13958       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13959     } CALL_CATCH_EXCEPTION(0);
13960   }
13961
13962   jresult = (void *)result;
13963
13964   //argout typemap for const std::string&
13965
13966   return jresult;
13967 }
13968
13969
13970 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
13971   char * jresult ;
13972   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13973   std::string result;
13974
13975   arg1 = (Dali::TypeRegistration *)jarg1;
13976   {
13977     try {
13978       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
13979     } CALL_CATCH_EXCEPTION(0);
13980   }
13981
13982   jresult = SWIG_csharp_string_callback((&result)->c_str());
13983   return jresult;
13984 }
13985
13986
13987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
13988   std::string *arg1 = 0 ;
13989   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13990
13991   if (!jarg1) {
13992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13993     return ;
13994   }
13995   std::string arg1_str(jarg1);
13996   arg1 = &arg1_str;
13997   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
13998   {
13999     try {
14000       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14001     } CALL_CATCH_EXCEPTION();
14002   }
14003
14004
14005   //argout typemap for const std::string&
14006
14007 }
14008
14009
14010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14011   std::string *arg1 = 0 ;
14012   std::string *arg2 = 0 ;
14013   int arg3 ;
14014   Dali::Property::Type arg4 ;
14015   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14016   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14017
14018   if (!jarg1) {
14019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14020     return ;
14021   }
14022   std::string arg1_str(jarg1);
14023   arg1 = &arg1_str;
14024   if (!jarg2) {
14025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14026     return ;
14027   }
14028   std::string arg2_str(jarg2);
14029   arg2 = &arg2_str;
14030   arg3 = (int)jarg3;
14031   arg4 = (Dali::Property::Type)jarg4;
14032   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14033   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14034   {
14035     try {
14036       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14037     } CALL_CATCH_EXCEPTION();
14038   }
14039
14040
14041   //argout typemap for const std::string&
14042
14043
14044   //argout typemap for const std::string&
14045
14046 }
14047
14048
14049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14050   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14051
14052   arg1 = (Dali::TypeRegistration *)jarg1;
14053   {
14054     try {
14055       delete arg1;
14056     } CALL_CATCH_EXCEPTION();
14057   }
14058
14059 }
14060
14061
14062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14063   void * jresult ;
14064   Dali::TypeRegistration *arg1 = 0 ;
14065   std::string *arg2 = 0 ;
14066   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14067   Dali::SignalConnectorType *result = 0 ;
14068
14069   arg1 = (Dali::TypeRegistration *)jarg1;
14070   if (!arg1) {
14071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14072     return 0;
14073   }
14074   if (!jarg2) {
14075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14076     return 0;
14077   }
14078   std::string arg2_str(jarg2);
14079   arg2 = &arg2_str;
14080   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14081   {
14082     try {
14083       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14084     } CALL_CATCH_EXCEPTION(0);
14085   }
14086
14087   jresult = (void *)result;
14088
14089   //argout typemap for const std::string&
14090
14091   return jresult;
14092 }
14093
14094
14095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14096   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14097
14098   arg1 = (Dali::SignalConnectorType *)jarg1;
14099   {
14100     try {
14101       delete arg1;
14102     } CALL_CATCH_EXCEPTION();
14103   }
14104
14105 }
14106
14107
14108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14109   void * jresult ;
14110   Dali::TypeRegistration *arg1 = 0 ;
14111   std::string *arg2 = 0 ;
14112   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14113   Dali::TypeAction *result = 0 ;
14114
14115   arg1 = (Dali::TypeRegistration *)jarg1;
14116   if (!arg1) {
14117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14118     return 0;
14119   }
14120   if (!jarg2) {
14121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14122     return 0;
14123   }
14124   std::string arg2_str(jarg2);
14125   arg2 = &arg2_str;
14126   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14127   {
14128     try {
14129       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14130     } CALL_CATCH_EXCEPTION(0);
14131   }
14132
14133   jresult = (void *)result;
14134
14135   //argout typemap for const std::string&
14136
14137   return jresult;
14138 }
14139
14140
14141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14142   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14143
14144   arg1 = (Dali::TypeAction *)jarg1;
14145   {
14146     try {
14147       delete arg1;
14148     } CALL_CATCH_EXCEPTION();
14149   }
14150
14151 }
14152
14153
14154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14155   void * jresult ;
14156   Dali::TypeRegistration *arg1 = 0 ;
14157   std::string *arg2 = 0 ;
14158   Dali::Property::Index arg3 ;
14159   Dali::Property::Type arg4 ;
14160   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14161   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14162   Dali::PropertyRegistration *result = 0 ;
14163
14164   arg1 = (Dali::TypeRegistration *)jarg1;
14165   if (!arg1) {
14166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14167     return 0;
14168   }
14169   if (!jarg2) {
14170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14171     return 0;
14172   }
14173   std::string arg2_str(jarg2);
14174   arg2 = &arg2_str;
14175   arg3 = (Dali::Property::Index)jarg3;
14176   arg4 = (Dali::Property::Type)jarg4;
14177   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14178   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14179   {
14180     try {
14181       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14182     } CALL_CATCH_EXCEPTION(0);
14183   }
14184
14185   jresult = (void *)result;
14186
14187   //argout typemap for const std::string&
14188
14189   return jresult;
14190 }
14191
14192
14193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14194   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14195
14196   arg1 = (Dali::PropertyRegistration *)jarg1;
14197   {
14198     try {
14199       delete arg1;
14200     } CALL_CATCH_EXCEPTION();
14201   }
14202
14203 }
14204
14205
14206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14207   void * jresult ;
14208   Dali::TypeRegistration *arg1 = 0 ;
14209   std::string *arg2 = 0 ;
14210   Dali::Property::Index arg3 ;
14211   Dali::Property::Type arg4 ;
14212   Dali::AnimatablePropertyRegistration *result = 0 ;
14213
14214   arg1 = (Dali::TypeRegistration *)jarg1;
14215   if (!arg1) {
14216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14217     return 0;
14218   }
14219   if (!jarg2) {
14220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14221     return 0;
14222   }
14223   std::string arg2_str(jarg2);
14224   arg2 = &arg2_str;
14225   arg3 = (Dali::Property::Index)jarg3;
14226   arg4 = (Dali::Property::Type)jarg4;
14227   {
14228     try {
14229       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14230     } CALL_CATCH_EXCEPTION(0);
14231   }
14232
14233   jresult = (void *)result;
14234
14235   //argout typemap for const std::string&
14236
14237   return jresult;
14238 }
14239
14240
14241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14242   void * jresult ;
14243   Dali::TypeRegistration *arg1 = 0 ;
14244   std::string *arg2 = 0 ;
14245   Dali::Property::Index arg3 ;
14246   Dali::Property::Value *arg4 = 0 ;
14247   Dali::AnimatablePropertyRegistration *result = 0 ;
14248
14249   arg1 = (Dali::TypeRegistration *)jarg1;
14250   if (!arg1) {
14251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14252     return 0;
14253   }
14254   if (!jarg2) {
14255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14256     return 0;
14257   }
14258   std::string arg2_str(jarg2);
14259   arg2 = &arg2_str;
14260   arg3 = (Dali::Property::Index)jarg3;
14261   arg4 = (Dali::Property::Value *)jarg4;
14262   if (!arg4) {
14263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14264     return 0;
14265   }
14266   {
14267     try {
14268       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14269     } CALL_CATCH_EXCEPTION(0);
14270   }
14271
14272   jresult = (void *)result;
14273
14274   //argout typemap for const std::string&
14275
14276   return jresult;
14277 }
14278
14279
14280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14281   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14282
14283   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14284   {
14285     try {
14286       delete arg1;
14287     } CALL_CATCH_EXCEPTION();
14288   }
14289
14290 }
14291
14292
14293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14294   void * jresult ;
14295   Dali::TypeRegistration *arg1 = 0 ;
14296   std::string *arg2 = 0 ;
14297   Dali::Property::Index arg3 ;
14298   Dali::Property::Index arg4 ;
14299   unsigned int arg5 ;
14300   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14301
14302   arg1 = (Dali::TypeRegistration *)jarg1;
14303   if (!arg1) {
14304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14305     return 0;
14306   }
14307   if (!jarg2) {
14308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14309     return 0;
14310   }
14311   std::string arg2_str(jarg2);
14312   arg2 = &arg2_str;
14313   arg3 = (Dali::Property::Index)jarg3;
14314   arg4 = (Dali::Property::Index)jarg4;
14315   arg5 = (unsigned int)jarg5;
14316   {
14317     try {
14318       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14319     } CALL_CATCH_EXCEPTION(0);
14320   }
14321
14322   jresult = (void *)result;
14323
14324   //argout typemap for const std::string&
14325
14326   return jresult;
14327 }
14328
14329
14330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14331   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14332
14333   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14334   {
14335     try {
14336       delete arg1;
14337     } CALL_CATCH_EXCEPTION();
14338   }
14339
14340 }
14341
14342
14343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14344   void * jresult ;
14345   Dali::TypeRegistration *arg1 = 0 ;
14346   std::string *arg2 = 0 ;
14347   Dali::Property::Index arg3 ;
14348   Dali::Property::Type arg4 ;
14349   Dali::ChildPropertyRegistration *result = 0 ;
14350
14351   arg1 = (Dali::TypeRegistration *)jarg1;
14352   if (!arg1) {
14353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14354     return 0;
14355   }
14356   if (!jarg2) {
14357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14358     return 0;
14359   }
14360   std::string arg2_str(jarg2);
14361   arg2 = &arg2_str;
14362   arg3 = (Dali::Property::Index)jarg3;
14363   arg4 = (Dali::Property::Type)jarg4;
14364   {
14365     try {
14366       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14367     } CALL_CATCH_EXCEPTION(0);
14368   }
14369
14370   jresult = (void *)result;
14371
14372   //argout typemap for const std::string&
14373
14374   return jresult;
14375 }
14376
14377
14378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14379   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14380
14381   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14382   {
14383     try {
14384       delete arg1;
14385     } CALL_CATCH_EXCEPTION();
14386   }
14387
14388 }
14389
14390
14391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14392   unsigned int jresult ;
14393   std::string *arg1 = 0 ;
14394   std::type_info *arg2 = 0 ;
14395   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14396   bool result;
14397
14398   if (!jarg1) {
14399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14400     return 0;
14401   }
14402   std::string arg1_str(jarg1);
14403   arg1 = &arg1_str;
14404   arg2 = (std::type_info *)jarg2;
14405   if (!arg2) {
14406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14407     return 0;
14408   }
14409   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14410   {
14411     try {
14412       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14413     } CALL_CATCH_EXCEPTION(0);
14414   }
14415
14416   jresult = result;
14417
14418   //argout typemap for const std::string&
14419
14420   return jresult;
14421 }
14422
14423
14424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14425   unsigned int jresult ;
14426   std::string *arg1 = 0 ;
14427   std::string *arg2 = 0 ;
14428   Dali::Property::Index arg3 ;
14429   Dali::Property::Type arg4 ;
14430   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14431   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14432   bool result;
14433
14434   if (!jarg1) {
14435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14436     return 0;
14437   }
14438   std::string arg1_str(jarg1);
14439   arg1 = &arg1_str;
14440   if (!jarg2) {
14441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14442     return 0;
14443   }
14444   std::string arg2_str(jarg2);
14445   arg2 = &arg2_str;
14446   arg3 = (Dali::Property::Index)jarg3;
14447   arg4 = (Dali::Property::Type)jarg4;
14448   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14449   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14450   {
14451     try {
14452       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14453     } CALL_CATCH_EXCEPTION(0);
14454   }
14455
14456   jresult = result;
14457
14458   //argout typemap for const std::string&
14459
14460
14461   //argout typemap for const std::string&
14462
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14468   float jresult ;
14469   float result;
14470
14471   result = (float)(float)Dali::ParentOrigin::TOP;
14472   jresult = result;
14473   return jresult;
14474 }
14475
14476
14477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14478   float jresult ;
14479   float result;
14480
14481   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14482   jresult = result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14488   float jresult ;
14489   float result;
14490
14491   result = (float)(float)Dali::ParentOrigin::LEFT;
14492   jresult = result;
14493   return jresult;
14494 }
14495
14496
14497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14498   float jresult ;
14499   float result;
14500
14501   result = (float)(float)Dali::ParentOrigin::RIGHT;
14502   jresult = result;
14503   return jresult;
14504 }
14505
14506
14507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14508   float jresult ;
14509   float result;
14510
14511   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14512   jresult = result;
14513   return jresult;
14514 }
14515
14516
14517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14518   void * jresult ;
14519   Dali::Vector3 *result = 0 ;
14520
14521   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14522   jresult = (void *)result;
14523   return jresult;
14524 }
14525
14526
14527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14528   void * jresult ;
14529   Dali::Vector3 *result = 0 ;
14530
14531   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14532   jresult = (void *)result;
14533   return jresult;
14534 }
14535
14536
14537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14538   void * jresult ;
14539   Dali::Vector3 *result = 0 ;
14540
14541   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14542   jresult = (void *)result;
14543   return jresult;
14544 }
14545
14546
14547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14548   void * jresult ;
14549   Dali::Vector3 *result = 0 ;
14550
14551   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14552   jresult = (void *)result;
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14558   void * jresult ;
14559   Dali::Vector3 *result = 0 ;
14560
14561   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14562   jresult = (void *)result;
14563   return jresult;
14564 }
14565
14566
14567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14568   void * jresult ;
14569   Dali::Vector3 *result = 0 ;
14570
14571   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14572   jresult = (void *)result;
14573   return jresult;
14574 }
14575
14576
14577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14578   void * jresult ;
14579   Dali::Vector3 *result = 0 ;
14580
14581   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14582   jresult = (void *)result;
14583   return jresult;
14584 }
14585
14586
14587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14588   void * jresult ;
14589   Dali::Vector3 *result = 0 ;
14590
14591   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14592   jresult = (void *)result;
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14598   void * jresult ;
14599   Dali::Vector3 *result = 0 ;
14600
14601   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14602   jresult = (void *)result;
14603   return jresult;
14604 }
14605
14606
14607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14608   float jresult ;
14609   float result;
14610
14611   result = (float)(float)Dali::AnchorPoint::TOP;
14612   jresult = result;
14613   return jresult;
14614 }
14615
14616
14617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14618   float jresult ;
14619   float result;
14620
14621   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14622   jresult = result;
14623   return jresult;
14624 }
14625
14626
14627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14628   float jresult ;
14629   float result;
14630
14631   result = (float)(float)Dali::AnchorPoint::LEFT;
14632   jresult = result;
14633   return jresult;
14634 }
14635
14636
14637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14638   float jresult ;
14639   float result;
14640
14641   result = (float)(float)Dali::AnchorPoint::RIGHT;
14642   jresult = result;
14643   return jresult;
14644 }
14645
14646
14647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14648   float jresult ;
14649   float result;
14650
14651   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14652   jresult = result;
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14658   void * jresult ;
14659   Dali::Vector3 *result = 0 ;
14660
14661   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14662   jresult = (void *)result;
14663   return jresult;
14664 }
14665
14666
14667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14668   void * jresult ;
14669   Dali::Vector3 *result = 0 ;
14670
14671   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14672   jresult = (void *)result;
14673   return jresult;
14674 }
14675
14676
14677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14678   void * jresult ;
14679   Dali::Vector3 *result = 0 ;
14680
14681   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14682   jresult = (void *)result;
14683   return jresult;
14684 }
14685
14686
14687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14688   void * jresult ;
14689   Dali::Vector3 *result = 0 ;
14690
14691   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14692   jresult = (void *)result;
14693   return jresult;
14694 }
14695
14696
14697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14698   void * jresult ;
14699   Dali::Vector3 *result = 0 ;
14700
14701   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14702   jresult = (void *)result;
14703   return jresult;
14704 }
14705
14706
14707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14708   void * jresult ;
14709   Dali::Vector3 *result = 0 ;
14710
14711   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14712   jresult = (void *)result;
14713   return jresult;
14714 }
14715
14716
14717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14718   void * jresult ;
14719   Dali::Vector3 *result = 0 ;
14720
14721   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14722   jresult = (void *)result;
14723   return jresult;
14724 }
14725
14726
14727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14728   void * jresult ;
14729   Dali::Vector3 *result = 0 ;
14730
14731   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14732   jresult = (void *)result;
14733   return jresult;
14734 }
14735
14736
14737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14738   void * jresult ;
14739   Dali::Vector3 *result = 0 ;
14740
14741   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14742   jresult = (void *)result;
14743   return jresult;
14744 }
14745
14746
14747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14748   void * jresult ;
14749   Dali::Vector4 *result = 0 ;
14750
14751   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14752   jresult = (void *)result;
14753   return jresult;
14754 }
14755
14756
14757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
14758   void * jresult ;
14759   Dali::Vector4 *result = 0 ;
14760
14761   result = (Dali::Vector4 *)&Dali::Color::WHITE;
14762   jresult = (void *)result;
14763   return jresult;
14764 }
14765
14766
14767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
14768   void * jresult ;
14769   Dali::Vector4 *result = 0 ;
14770
14771   result = (Dali::Vector4 *)&Dali::Color::RED;
14772   jresult = (void *)result;
14773   return jresult;
14774 }
14775
14776
14777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14778   void * jresult ;
14779   Dali::Vector4 *result = 0 ;
14780
14781   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14782   jresult = (void *)result;
14783   return jresult;
14784 }
14785
14786
14787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14788   void * jresult ;
14789   Dali::Vector4 *result = 0 ;
14790
14791   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14792   jresult = (void *)result;
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
14798   void * jresult ;
14799   Dali::Vector4 *result = 0 ;
14800
14801   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
14802   jresult = (void *)result;
14803   return jresult;
14804 }
14805
14806
14807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
14808   void * jresult ;
14809   Dali::Vector4 *result = 0 ;
14810
14811   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
14812   jresult = (void *)result;
14813   return jresult;
14814 }
14815
14816
14817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14818   void * jresult ;
14819   Dali::Vector4 *result = 0 ;
14820
14821   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14822   jresult = (void *)result;
14823   return jresult;
14824 }
14825
14826
14827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
14828   void * jresult ;
14829   Dali::Vector4 *result = 0 ;
14830
14831   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
14832   jresult = (void *)result;
14833   return jresult;
14834 }
14835
14836
14837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
14838   float jresult ;
14839   float result;
14840
14841   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
14842   jresult = result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
14848   float jresult ;
14849   float result;
14850
14851   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
14852   jresult = result;
14853   return jresult;
14854 }
14855
14856
14857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
14858   float jresult ;
14859   float result;
14860
14861   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
14862   jresult = result;
14863   return jresult;
14864 }
14865
14866
14867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
14868   float jresult ;
14869   float result;
14870
14871   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
14872   jresult = result;
14873   return jresult;
14874 }
14875
14876
14877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
14878   float jresult ;
14879   float result;
14880
14881   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
14882   jresult = result;
14883   return jresult;
14884 }
14885
14886
14887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
14888   float jresult ;
14889   float result;
14890
14891   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
14892   jresult = result;
14893   return jresult;
14894 }
14895
14896
14897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
14898   float jresult ;
14899   float result;
14900
14901   result = (float)(float)Dali::Math::PI;
14902   jresult = result;
14903   return jresult;
14904 }
14905
14906
14907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
14908   float jresult ;
14909   float result;
14910
14911   result = (float)(float)Dali::Math::PI_2;
14912   jresult = result;
14913   return jresult;
14914 }
14915
14916
14917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
14918   float jresult ;
14919   float result;
14920
14921   result = (float)(float)Dali::Math::PI_4;
14922   jresult = result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
14928   float jresult ;
14929   float result;
14930
14931   result = (float)(float)Dali::Math::PI_OVER_180;
14932   jresult = result;
14933   return jresult;
14934 }
14935
14936
14937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
14938   float jresult ;
14939   float result;
14940
14941   result = (float)(float)Dali::Math::ONE80_OVER_PI;
14942   jresult = result;
14943   return jresult;
14944 }
14945
14946
14947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
14948   int jresult ;
14949   Dali::ResizePolicy::Type result;
14950
14951   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
14952   jresult = (int)result;
14953   return jresult;
14954 }
14955
14956
14957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
14958   unsigned long jresult ;
14959   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14960   Dali::VectorBase::SizeType result;
14961
14962   arg1 = (Dali::VectorBase *)jarg1;
14963   {
14964     try {
14965       result = ((Dali::VectorBase const *)arg1)->Count();
14966     } CALL_CATCH_EXCEPTION(0);
14967   }
14968
14969   jresult = (unsigned long)result;
14970   return jresult;
14971 }
14972
14973
14974 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
14975   unsigned long jresult ;
14976   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14977   Dali::VectorBase::SizeType result;
14978
14979   arg1 = (Dali::VectorBase *)jarg1;
14980   {
14981     try {
14982       result = ((Dali::VectorBase const *)arg1)->Size();
14983     } CALL_CATCH_EXCEPTION(0);
14984   }
14985
14986   jresult = (unsigned long)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
14992   unsigned int jresult ;
14993   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14994   bool result;
14995
14996   arg1 = (Dali::VectorBase *)jarg1;
14997   {
14998     try {
14999       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15000     } CALL_CATCH_EXCEPTION(0);
15001   }
15002
15003   jresult = result;
15004   return jresult;
15005 }
15006
15007
15008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(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)->Capacity();
15017     } CALL_CATCH_EXCEPTION(0);
15018   }
15019
15020   jresult = (unsigned long)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15026   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15027
15028   arg1 = (Dali::VectorBase *)jarg1;
15029   {
15030     try {
15031       (arg1)->Release();
15032     } CALL_CATCH_EXCEPTION();
15033   }
15034
15035 }
15036
15037
15038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15039   int jresult ;
15040   Dali::Pixel::Format result;
15041
15042   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15043   jresult = (int)result;
15044   return jresult;
15045 }
15046
15047
15048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15049   int jresult ;
15050   Dali::Pixel::Format result;
15051
15052   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15053   jresult = (int)result;
15054   return jresult;
15055 }
15056
15057
15058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15059   unsigned int jresult ;
15060   Dali::Pixel::Format arg1 ;
15061   bool result;
15062
15063   arg1 = (Dali::Pixel::Format)jarg1;
15064   {
15065     try {
15066       result = (bool)Dali::Pixel::HasAlpha(arg1);
15067     } CALL_CATCH_EXCEPTION(0);
15068   }
15069
15070   jresult = result;
15071   return jresult;
15072 }
15073
15074
15075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15076   unsigned int jresult ;
15077   Dali::Pixel::Format arg1 ;
15078   unsigned int result;
15079
15080   arg1 = (Dali::Pixel::Format)jarg1;
15081   {
15082     try {
15083       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15084     } CALL_CATCH_EXCEPTION(0);
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15093   Dali::Pixel::Format arg1 ;
15094   int *arg2 = 0 ;
15095   int *arg3 = 0 ;
15096
15097   arg1 = (Dali::Pixel::Format)jarg1;
15098   arg2 = (int *)jarg2;
15099   if (!arg2) {
15100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15101     return ;
15102   }
15103   arg3 = (int *)jarg3;
15104   if (!arg3) {
15105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15106     return ;
15107   }
15108   {
15109     try {
15110       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15111     } CALL_CATCH_EXCEPTION();
15112   }
15113
15114 }
15115
15116
15117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
15118   void * jresult ;
15119   unsigned char *arg1 = (unsigned char *) 0 ;
15120   unsigned int arg2 ;
15121   unsigned int arg3 ;
15122   unsigned int arg4 ;
15123   Dali::Pixel::Format arg5 ;
15124   Dali::PixelData::ReleaseFunction arg6 ;
15125   Dali::PixelData result;
15126
15127   arg1 = jarg1;
15128   arg2 = (unsigned int)jarg2;
15129   arg3 = (unsigned int)jarg3;
15130   arg4 = (unsigned int)jarg4;
15131   arg5 = (Dali::Pixel::Format)jarg5;
15132   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
15133   {
15134     try {
15135       auto pixelBuffer = new unsigned char[jarg2];
15136       memcpy( pixelBuffer, arg1, arg2);
15137       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
15138     } CALL_CATCH_EXCEPTION(0);
15139   }
15140
15141   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15142
15143
15144   return jresult;
15145 }
15146
15147
15148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15149   void * jresult ;
15150   Dali::PixelData *result = 0 ;
15151
15152   {
15153     try {
15154       result = (Dali::PixelData *)new Dali::PixelData();
15155     } CALL_CATCH_EXCEPTION(0);
15156   }
15157
15158   jresult = (void *)result;
15159   return jresult;
15160 }
15161
15162
15163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
15164   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15165
15166   arg1 = (Dali::PixelData *)jarg1;
15167   {
15168     try {
15169       delete arg1;
15170     } CALL_CATCH_EXCEPTION();
15171   }
15172
15173 }
15174
15175
15176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
15177   void * jresult ;
15178   Dali::PixelData *arg1 = 0 ;
15179   Dali::PixelData *result = 0 ;
15180
15181   arg1 = (Dali::PixelData *)jarg1;
15182   if (!arg1) {
15183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15184     return 0;
15185   }
15186   {
15187     try {
15188       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
15189     } CALL_CATCH_EXCEPTION(0);
15190   }
15191
15192   jresult = (void *)result;
15193   return jresult;
15194 }
15195
15196
15197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
15198   void * jresult ;
15199   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15200   Dali::PixelData *arg2 = 0 ;
15201   Dali::PixelData *result = 0 ;
15202
15203   arg1 = (Dali::PixelData *)jarg1;
15204   arg2 = (Dali::PixelData *)jarg2;
15205   if (!arg2) {
15206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15207     return 0;
15208   }
15209   {
15210     try {
15211       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
15212     } CALL_CATCH_EXCEPTION(0);
15213   }
15214
15215   jresult = (void *)result;
15216   return jresult;
15217 }
15218
15219
15220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
15221   unsigned int jresult ;
15222   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15223   unsigned int result;
15224
15225   arg1 = (Dali::PixelData *)jarg1;
15226   {
15227     try {
15228       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
15229     } CALL_CATCH_EXCEPTION(0);
15230   }
15231
15232   jresult = result;
15233   return jresult;
15234 }
15235
15236
15237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
15238   unsigned int jresult ;
15239   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15240   unsigned int result;
15241
15242   arg1 = (Dali::PixelData *)jarg1;
15243   {
15244     try {
15245       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
15246     } CALL_CATCH_EXCEPTION(0);
15247   }
15248
15249   jresult = result;
15250   return jresult;
15251 }
15252
15253
15254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
15255   int jresult ;
15256   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15257   Dali::Pixel::Format result;
15258
15259   arg1 = (Dali::PixelData *)jarg1;
15260   {
15261     try {
15262       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
15263     } CALL_CATCH_EXCEPTION(0);
15264   }
15265
15266   jresult = (int)result;
15267   return jresult;
15268 }
15269
15270
15271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
15272   unsigned int jresult ;
15273   unsigned int result;
15274
15275   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
15276   jresult = result;
15277   return jresult;
15278 }
15279
15280
15281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
15282   unsigned int jresult ;
15283   unsigned int result;
15284
15285   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
15286   jresult = result;
15287   return jresult;
15288 }
15289
15290
15291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
15292   unsigned int jresult ;
15293   unsigned int result;
15294
15295   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
15296   jresult = result;
15297   return jresult;
15298 }
15299
15300
15301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
15302   unsigned int jresult ;
15303   unsigned int result;
15304
15305   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
15306   jresult = result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
15312   unsigned int jresult ;
15313   unsigned int result;
15314
15315   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
15316   jresult = result;
15317   return jresult;
15318 }
15319
15320
15321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
15322   unsigned int jresult ;
15323   unsigned int result;
15324
15325   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
15326   jresult = result;
15327   return jresult;
15328 }
15329
15330
15331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
15332   void * jresult ;
15333   Dali::TextureType::Type arg1 ;
15334   Dali::Pixel::Format arg2 ;
15335   unsigned int arg3 ;
15336   unsigned int arg4 ;
15337   Dali::Texture result;
15338
15339   arg1 = (Dali::TextureType::Type)jarg1;
15340   arg2 = (Dali::Pixel::Format)jarg2;
15341   arg3 = (unsigned int)jarg3;
15342   arg4 = (unsigned int)jarg4;
15343   {
15344     try {
15345       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
15346     } CALL_CATCH_EXCEPTION(0);
15347   }
15348
15349   jresult = new Dali::Texture((const Dali::Texture &)result);
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
15355   void * jresult ;
15356   NativeImageInterface *arg1 = 0 ;
15357   Dali::Texture result;
15358
15359   arg1 = (NativeImageInterface *)jarg1;
15360   if (!arg1) {
15361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
15362     return 0;
15363   }
15364   {
15365     try {
15366       result = Dali::Texture::New(*arg1);
15367     } CALL_CATCH_EXCEPTION(0);
15368   }
15369
15370   jresult = new Dali::Texture((const Dali::Texture &)result);
15371   return jresult;
15372 }
15373
15374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
15375   void * jresult ;
15376   Dali::Texture *result = 0 ;
15377
15378   {
15379     try {
15380       result = (Dali::Texture *)new Dali::Texture();
15381     } CALL_CATCH_EXCEPTION(0);
15382   }
15383
15384   jresult = (void *)result;
15385   return jresult;
15386 }
15387
15388
15389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
15390   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15391
15392   arg1 = (Dali::Texture *)jarg1;
15393   {
15394     try {
15395       delete arg1;
15396     } CALL_CATCH_EXCEPTION();
15397   }
15398
15399 }
15400
15401
15402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
15403   void * jresult ;
15404   Dali::Texture *arg1 = 0 ;
15405   Dali::Texture *result = 0 ;
15406
15407   arg1 = (Dali::Texture *)jarg1;
15408   if (!arg1) {
15409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15410     return 0;
15411   }
15412   {
15413     try {
15414       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
15415     } CALL_CATCH_EXCEPTION(0);
15416   }
15417
15418   jresult = (void *)result;
15419   return jresult;
15420 }
15421
15422
15423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
15424   void * jresult ;
15425   Dali::BaseHandle arg1 ;
15426   Dali::BaseHandle *argp1 ;
15427   Dali::Texture result;
15428
15429   argp1 = (Dali::BaseHandle *)jarg1;
15430   if (!argp1) {
15431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15432     return 0;
15433   }
15434   arg1 = *argp1;
15435   {
15436     try {
15437       result = Dali::Texture::DownCast(arg1);
15438     } CALL_CATCH_EXCEPTION(0);
15439   }
15440
15441   jresult = new Dali::Texture((const Dali::Texture &)result);
15442   return jresult;
15443 }
15444
15445
15446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
15447   void * jresult ;
15448   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15449   Dali::Texture *arg2 = 0 ;
15450   Dali::Texture *result = 0 ;
15451
15452   arg1 = (Dali::Texture *)jarg1;
15453   arg2 = (Dali::Texture *)jarg2;
15454   if (!arg2) {
15455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15456     return 0;
15457   }
15458   {
15459     try {
15460       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
15461     } CALL_CATCH_EXCEPTION(0);
15462   }
15463
15464   jresult = (void *)result;
15465   return jresult;
15466 }
15467
15468
15469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
15470   unsigned int jresult ;
15471   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15472   Dali::PixelData arg2 ;
15473   Dali::PixelData *argp2 ;
15474   bool result;
15475
15476   arg1 = (Dali::Texture *)jarg1;
15477   argp2 = (Dali::PixelData *)jarg2;
15478   if (!argp2) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15480     return 0;
15481   }
15482   arg2 = *argp2;
15483   {
15484     try {
15485       result = (bool)(arg1)->Upload(arg2);
15486     } CALL_CATCH_EXCEPTION(0);
15487   }
15488
15489   jresult = result;
15490   return jresult;
15491 }
15492
15493
15494 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) {
15495   unsigned int jresult ;
15496   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15497   Dali::PixelData arg2 ;
15498   unsigned int arg3 ;
15499   unsigned int arg4 ;
15500   unsigned int arg5 ;
15501   unsigned int arg6 ;
15502   unsigned int arg7 ;
15503   unsigned int arg8 ;
15504   Dali::PixelData *argp2 ;
15505   bool result;
15506
15507   arg1 = (Dali::Texture *)jarg1;
15508   argp2 = (Dali::PixelData *)jarg2;
15509   if (!argp2) {
15510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15511     return 0;
15512   }
15513   arg2 = *argp2;
15514   arg3 = (unsigned int)jarg3;
15515   arg4 = (unsigned int)jarg4;
15516   arg5 = (unsigned int)jarg5;
15517   arg6 = (unsigned int)jarg6;
15518   arg7 = (unsigned int)jarg7;
15519   arg8 = (unsigned int)jarg8;
15520   {
15521     try {
15522       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15523     } CALL_CATCH_EXCEPTION(0);
15524   }
15525
15526   jresult = result;
15527   return jresult;
15528 }
15529
15530
15531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
15532   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15533
15534   arg1 = (Dali::Texture *)jarg1;
15535   {
15536     try {
15537       (arg1)->GenerateMipmaps();
15538     } CALL_CATCH_EXCEPTION();
15539   }
15540
15541 }
15542
15543
15544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
15545   unsigned int jresult ;
15546   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15547   unsigned int result;
15548
15549   arg1 = (Dali::Texture *)jarg1;
15550   {
15551     try {
15552       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
15553     } CALL_CATCH_EXCEPTION(0);
15554   }
15555
15556   jresult = result;
15557   return jresult;
15558 }
15559
15560
15561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
15562   unsigned int jresult ;
15563   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15564   unsigned int result;
15565
15566   arg1 = (Dali::Texture *)jarg1;
15567   {
15568     try {
15569       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
15570     } CALL_CATCH_EXCEPTION(0);
15571   }
15572
15573   jresult = result;
15574   return jresult;
15575 }
15576
15577
15578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
15579   void * jresult ;
15580   Dali::Sampler result;
15581
15582   {
15583     try {
15584       result = Dali::Sampler::New();
15585     } CALL_CATCH_EXCEPTION(0);
15586   }
15587
15588   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15589   return jresult;
15590 }
15591
15592
15593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
15594   void * jresult ;
15595   Dali::Sampler *result = 0 ;
15596
15597   {
15598     try {
15599       result = (Dali::Sampler *)new Dali::Sampler();
15600     } CALL_CATCH_EXCEPTION(0);
15601   }
15602
15603   jresult = (void *)result;
15604   return jresult;
15605 }
15606
15607
15608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
15609   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15610
15611   arg1 = (Dali::Sampler *)jarg1;
15612   {
15613     try {
15614       delete arg1;
15615     } CALL_CATCH_EXCEPTION();
15616   }
15617
15618 }
15619
15620
15621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
15622   void * jresult ;
15623   Dali::Sampler *arg1 = 0 ;
15624   Dali::Sampler *result = 0 ;
15625
15626   arg1 = (Dali::Sampler *)jarg1;
15627   if (!arg1) {
15628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15629     return 0;
15630   }
15631   {
15632     try {
15633       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
15634     } CALL_CATCH_EXCEPTION(0);
15635   }
15636
15637   jresult = (void *)result;
15638   return jresult;
15639 }
15640
15641
15642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
15643   void * jresult ;
15644   Dali::BaseHandle arg1 ;
15645   Dali::BaseHandle *argp1 ;
15646   Dali::Sampler result;
15647
15648   argp1 = (Dali::BaseHandle *)jarg1;
15649   if (!argp1) {
15650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15651     return 0;
15652   }
15653   arg1 = *argp1;
15654   {
15655     try {
15656       result = Dali::Sampler::DownCast(arg1);
15657     } CALL_CATCH_EXCEPTION(0);
15658   }
15659
15660   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15661   return jresult;
15662 }
15663
15664
15665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
15666   void * jresult ;
15667   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15668   Dali::Sampler *arg2 = 0 ;
15669   Dali::Sampler *result = 0 ;
15670
15671   arg1 = (Dali::Sampler *)jarg1;
15672   arg2 = (Dali::Sampler *)jarg2;
15673   if (!arg2) {
15674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15675     return 0;
15676   }
15677   {
15678     try {
15679       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
15680     } CALL_CATCH_EXCEPTION(0);
15681   }
15682
15683   jresult = (void *)result;
15684   return jresult;
15685 }
15686
15687
15688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
15689   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15690   Dali::FilterMode::Type arg2 ;
15691   Dali::FilterMode::Type arg3 ;
15692
15693   arg1 = (Dali::Sampler *)jarg1;
15694   arg2 = (Dali::FilterMode::Type)jarg2;
15695   arg3 = (Dali::FilterMode::Type)jarg3;
15696   {
15697     try {
15698       (arg1)->SetFilterMode(arg2,arg3);
15699     } CALL_CATCH_EXCEPTION();
15700   }
15701
15702 }
15703
15704
15705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
15706   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15707   Dali::WrapMode::Type arg2 ;
15708   Dali::WrapMode::Type arg3 ;
15709
15710   arg1 = (Dali::Sampler *)jarg1;
15711   arg2 = (Dali::WrapMode::Type)jarg2;
15712   arg3 = (Dali::WrapMode::Type)jarg3;
15713   {
15714     try {
15715       (arg1)->SetWrapMode(arg2,arg3);
15716     } CALL_CATCH_EXCEPTION();
15717   }
15718
15719 }
15720
15721
15722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
15723   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15724   Dali::WrapMode::Type arg2 ;
15725   Dali::WrapMode::Type arg3 ;
15726   Dali::WrapMode::Type arg4 ;
15727
15728   arg1 = (Dali::Sampler *)jarg1;
15729   arg2 = (Dali::WrapMode::Type)jarg2;
15730   arg3 = (Dali::WrapMode::Type)jarg3;
15731   arg4 = (Dali::WrapMode::Type)jarg4;
15732   {
15733     try {
15734       (arg1)->SetWrapMode(arg2,arg3,arg4);
15735     } CALL_CATCH_EXCEPTION();
15736   }
15737
15738 }
15739
15740
15741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
15742   void * jresult ;
15743   Dali::TextureSet result;
15744
15745   {
15746     try {
15747       result = Dali::TextureSet::New();
15748     } CALL_CATCH_EXCEPTION(0);
15749   }
15750
15751   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15752   return jresult;
15753 }
15754
15755
15756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
15757   void * jresult ;
15758   Dali::TextureSet *result = 0 ;
15759
15760   {
15761     try {
15762       result = (Dali::TextureSet *)new Dali::TextureSet();
15763     } CALL_CATCH_EXCEPTION(0);
15764   }
15765
15766   jresult = (void *)result;
15767   return jresult;
15768 }
15769
15770
15771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
15772   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15773
15774   arg1 = (Dali::TextureSet *)jarg1;
15775   {
15776     try {
15777       delete arg1;
15778     } CALL_CATCH_EXCEPTION();
15779   }
15780
15781 }
15782
15783
15784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
15785   void * jresult ;
15786   Dali::TextureSet *arg1 = 0 ;
15787   Dali::TextureSet *result = 0 ;
15788
15789   arg1 = (Dali::TextureSet *)jarg1;
15790   if (!arg1) {
15791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15792     return 0;
15793   }
15794   {
15795     try {
15796       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
15797     } CALL_CATCH_EXCEPTION(0);
15798   }
15799
15800   jresult = (void *)result;
15801   return jresult;
15802 }
15803
15804
15805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
15806   void * jresult ;
15807   Dali::BaseHandle arg1 ;
15808   Dali::BaseHandle *argp1 ;
15809   Dali::TextureSet result;
15810
15811   argp1 = (Dali::BaseHandle *)jarg1;
15812   if (!argp1) {
15813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15814     return 0;
15815   }
15816   arg1 = *argp1;
15817   {
15818     try {
15819       result = Dali::TextureSet::DownCast(arg1);
15820     } CALL_CATCH_EXCEPTION(0);
15821   }
15822
15823   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15824   return jresult;
15825 }
15826
15827
15828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
15829   void * jresult ;
15830   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15831   Dali::TextureSet *arg2 = 0 ;
15832   Dali::TextureSet *result = 0 ;
15833
15834   arg1 = (Dali::TextureSet *)jarg1;
15835   arg2 = (Dali::TextureSet *)jarg2;
15836   if (!arg2) {
15837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15838     return 0;
15839   }
15840   {
15841     try {
15842       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
15843     } CALL_CATCH_EXCEPTION(0);
15844   }
15845
15846   jresult = (void *)result;
15847   return jresult;
15848 }
15849
15850
15851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
15852   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15853   size_t arg2 ;
15854   Dali::Texture arg3 ;
15855   Dali::Texture *argp3 ;
15856
15857   arg1 = (Dali::TextureSet *)jarg1;
15858   arg2 = (size_t)jarg2;
15859   argp3 = (Dali::Texture *)jarg3;
15860   if (!argp3) {
15861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
15862     return ;
15863   }
15864   arg3 = *argp3;
15865   {
15866     try {
15867       (arg1)->SetTexture(arg2,arg3);
15868     } CALL_CATCH_EXCEPTION();
15869   }
15870
15871 }
15872
15873
15874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
15875   void * jresult ;
15876   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15877   size_t arg2 ;
15878   Dali::Texture result;
15879
15880   arg1 = (Dali::TextureSet *)jarg1;
15881   arg2 = (size_t)jarg2;
15882   {
15883     try {
15884       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
15885     } CALL_CATCH_EXCEPTION(0);
15886   }
15887
15888   jresult = new Dali::Texture((const Dali::Texture &)result);
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
15894   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15895   size_t arg2 ;
15896   Dali::Sampler arg3 ;
15897   Dali::Sampler *argp3 ;
15898
15899   arg1 = (Dali::TextureSet *)jarg1;
15900   arg2 = (size_t)jarg2;
15901   argp3 = (Dali::Sampler *)jarg3;
15902   if (!argp3) {
15903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
15904     return ;
15905   }
15906   arg3 = *argp3;
15907   {
15908     try {
15909       (arg1)->SetSampler(arg2,arg3);
15910     } CALL_CATCH_EXCEPTION();
15911   }
15912
15913 }
15914
15915
15916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
15917   void * jresult ;
15918   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15919   size_t arg2 ;
15920   Dali::Sampler result;
15921
15922   arg1 = (Dali::TextureSet *)jarg1;
15923   arg2 = (size_t)jarg2;
15924   {
15925     try {
15926       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
15927     } CALL_CATCH_EXCEPTION(0);
15928   }
15929
15930   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15931   return jresult;
15932 }
15933
15934
15935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
15936   unsigned long jresult ;
15937   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15938   size_t result;
15939
15940   arg1 = (Dali::TextureSet *)jarg1;
15941   {
15942     try {
15943       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
15944     } CALL_CATCH_EXCEPTION(0);
15945   }
15946
15947   jresult = (unsigned long)result;
15948   return jresult;
15949 }
15950
15951
15952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
15953   void * jresult ;
15954   Dali::Property::Map *arg1 = 0 ;
15955   Dali::VertexBuffer result;
15956
15957   arg1 = (Dali::Property::Map *)jarg1;
15958   if (!arg1) {
15959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15960     return 0;
15961   }
15962   {
15963     try {
15964       result = Dali::VertexBuffer::New(*arg1);
15965     } CALL_CATCH_EXCEPTION(0);
15966   }
15967
15968   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
15974   void * jresult ;
15975   Dali::VertexBuffer *result = 0 ;
15976
15977   {
15978     try {
15979       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
15980     } CALL_CATCH_EXCEPTION(0);
15981   }
15982
15983   jresult = (void *)result;
15984   return jresult;
15985 }
15986
15987
15988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
15989   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
15990
15991   arg1 = (Dali::VertexBuffer *)jarg1;
15992   {
15993     try {
15994       delete arg1;
15995     } CALL_CATCH_EXCEPTION();
15996   }
15997
15998 }
15999
16000
16001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16002   void * jresult ;
16003   Dali::VertexBuffer *arg1 = 0 ;
16004   Dali::VertexBuffer *result = 0 ;
16005
16006   arg1 = (Dali::VertexBuffer *)jarg1;
16007   if (!arg1) {
16008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16009     return 0;
16010   }
16011   {
16012     try {
16013       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16014     } CALL_CATCH_EXCEPTION(0);
16015   }
16016
16017   jresult = (void *)result;
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16023   void * jresult ;
16024   Dali::BaseHandle arg1 ;
16025   Dali::BaseHandle *argp1 ;
16026   Dali::VertexBuffer result;
16027
16028   argp1 = (Dali::BaseHandle *)jarg1;
16029   if (!argp1) {
16030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16031     return 0;
16032   }
16033   arg1 = *argp1;
16034   {
16035     try {
16036       result = Dali::VertexBuffer::DownCast(arg1);
16037     } CALL_CATCH_EXCEPTION(0);
16038   }
16039
16040   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16041   return jresult;
16042 }
16043
16044
16045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16046   void * jresult ;
16047   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16048   Dali::VertexBuffer *arg2 = 0 ;
16049   Dali::VertexBuffer *result = 0 ;
16050
16051   arg1 = (Dali::VertexBuffer *)jarg1;
16052   arg2 = (Dali::VertexBuffer *)jarg2;
16053   if (!arg2) {
16054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16055     return 0;
16056   }
16057   {
16058     try {
16059       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16060     } CALL_CATCH_EXCEPTION(0);
16061   }
16062
16063   jresult = (void *)result;
16064   return jresult;
16065 }
16066
16067
16068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16069   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16070   void *arg2 = (void *) 0 ;
16071   std::size_t arg3 ;
16072
16073   arg1 = (Dali::VertexBuffer *)jarg1;
16074   arg2 = jarg2;
16075   arg3 = (std::size_t)jarg3;
16076   {
16077     try {
16078       (arg1)->SetData((void const *)arg2,arg3);
16079     } CALL_CATCH_EXCEPTION();
16080   }
16081
16082 }
16083
16084
16085 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16086   unsigned long jresult ;
16087   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16088   std::size_t result;
16089
16090   arg1 = (Dali::VertexBuffer *)jarg1;
16091   {
16092     try {
16093       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16094     } CALL_CATCH_EXCEPTION(0);
16095   }
16096
16097   jresult = (unsigned long)result;
16098   return jresult;
16099 }
16100
16101
16102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16103   void * jresult ;
16104   Dali::Geometry result;
16105
16106   {
16107     try {
16108       result = Dali::Geometry::New();
16109     } CALL_CATCH_EXCEPTION(0);
16110   }
16111
16112   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16113   return jresult;
16114 }
16115
16116
16117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16118   void * jresult ;
16119   Dali::Geometry *result = 0 ;
16120
16121   {
16122     try {
16123       result = (Dali::Geometry *)new Dali::Geometry();
16124     } CALL_CATCH_EXCEPTION(0);
16125   }
16126
16127   jresult = (void *)result;
16128   return jresult;
16129 }
16130
16131
16132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16133   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16134
16135   arg1 = (Dali::Geometry *)jarg1;
16136   {
16137     try {
16138       delete arg1;
16139     } CALL_CATCH_EXCEPTION();
16140   }
16141
16142 }
16143
16144
16145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
16146   void * jresult ;
16147   Dali::Geometry *arg1 = 0 ;
16148   Dali::Geometry *result = 0 ;
16149
16150   arg1 = (Dali::Geometry *)jarg1;
16151   if (!arg1) {
16152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16153     return 0;
16154   }
16155   {
16156     try {
16157       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
16158     } CALL_CATCH_EXCEPTION(0);
16159   }
16160
16161   jresult = (void *)result;
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
16167   void * jresult ;
16168   Dali::BaseHandle arg1 ;
16169   Dali::BaseHandle *argp1 ;
16170   Dali::Geometry result;
16171
16172   argp1 = (Dali::BaseHandle *)jarg1;
16173   if (!argp1) {
16174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16175     return 0;
16176   }
16177   arg1 = *argp1;
16178   {
16179     try {
16180       result = Dali::Geometry::DownCast(arg1);
16181     } CALL_CATCH_EXCEPTION(0);
16182   }
16183
16184   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16185   return jresult;
16186 }
16187
16188
16189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
16190   void * jresult ;
16191   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16192   Dali::Geometry *arg2 = 0 ;
16193   Dali::Geometry *result = 0 ;
16194
16195   arg1 = (Dali::Geometry *)jarg1;
16196   arg2 = (Dali::Geometry *)jarg2;
16197   if (!arg2) {
16198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16199     return 0;
16200   }
16201   {
16202     try {
16203       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
16204     } CALL_CATCH_EXCEPTION(0);
16205   }
16206
16207   jresult = (void *)result;
16208   return jresult;
16209 }
16210
16211
16212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
16213   unsigned long jresult ;
16214   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16215   Dali::VertexBuffer *arg2 = 0 ;
16216   std::size_t result;
16217
16218   arg1 = (Dali::Geometry *)jarg1;
16219   arg2 = (Dali::VertexBuffer *)jarg2;
16220   if (!arg2) {
16221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
16222     return 0;
16223   }
16224   {
16225     try {
16226       result = (arg1)->AddVertexBuffer(*arg2);
16227     } CALL_CATCH_EXCEPTION(0);
16228   }
16229
16230   jresult = (unsigned long)result;
16231   return jresult;
16232 }
16233
16234
16235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
16236   unsigned long jresult ;
16237   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16238   std::size_t result;
16239
16240   arg1 = (Dali::Geometry *)jarg1;
16241   {
16242     try {
16243       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
16244     } CALL_CATCH_EXCEPTION(0);
16245   }
16246
16247   jresult = (unsigned long)result;
16248   return jresult;
16249 }
16250
16251
16252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
16253   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16254   std::size_t arg2 ;
16255
16256   arg1 = (Dali::Geometry *)jarg1;
16257   arg2 = (std::size_t)jarg2;
16258   {
16259     try {
16260       (arg1)->RemoveVertexBuffer(arg2);
16261     } CALL_CATCH_EXCEPTION();
16262   }
16263
16264 }
16265
16266
16267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
16268   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16269   unsigned short *arg2 = (unsigned short *) 0 ;
16270   size_t arg3 ;
16271
16272   arg1 = (Dali::Geometry *)jarg1;
16273   arg2 = jarg2;
16274   arg3 = (size_t)jarg3;
16275   {
16276     try {
16277       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
16278     } CALL_CATCH_EXCEPTION();
16279   }
16280
16281
16282
16283 }
16284
16285
16286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
16287   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16288   Dali::Geometry::Type arg2 ;
16289
16290   arg1 = (Dali::Geometry *)jarg1;
16291   arg2 = (Dali::Geometry::Type)jarg2;
16292   {
16293     try {
16294       (arg1)->SetType(arg2);
16295     } CALL_CATCH_EXCEPTION();
16296   }
16297
16298 }
16299
16300
16301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
16302   int jresult ;
16303   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16304   Dali::Geometry::Type result;
16305
16306   arg1 = (Dali::Geometry *)jarg1;
16307   {
16308     try {
16309       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
16310     } CALL_CATCH_EXCEPTION(0);
16311   }
16312
16313   jresult = (int)result;
16314   return jresult;
16315 }
16316
16317
16318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
16319   void * jresult ;
16320   Dali::Shader::Hint *result = 0 ;
16321
16322   {
16323     try {
16324       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
16325     } CALL_CATCH_EXCEPTION(0);
16326   }
16327
16328   jresult = (void *)result;
16329   return jresult;
16330 }
16331
16332
16333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
16334   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
16335
16336   arg1 = (Dali::Shader::Hint *)jarg1;
16337   {
16338     try {
16339       delete arg1;
16340     } CALL_CATCH_EXCEPTION();
16341   }
16342
16343 }
16344
16345
16346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
16347   int jresult ;
16348   int result;
16349
16350   result = (int)Dali::Shader::Property::PROGRAM;
16351   jresult = (int)result;
16352   return jresult;
16353 }
16354
16355
16356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
16357   void * jresult ;
16358   Dali::Shader::Property *result = 0 ;
16359
16360   {
16361     try {
16362       result = (Dali::Shader::Property *)new Dali::Shader::Property();
16363     } CALL_CATCH_EXCEPTION(0);
16364   }
16365
16366   jresult = (void *)result;
16367   return jresult;
16368 }
16369
16370
16371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
16372   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
16373
16374   arg1 = (Dali::Shader::Property *)jarg1;
16375   {
16376     try {
16377       delete arg1;
16378     } CALL_CATCH_EXCEPTION();
16379   }
16380
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   std::string *arg1 = 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Shader::Hint::Value arg3 ;
16389   Dali::Shader result;
16390
16391   if (!jarg1) {
16392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16393     return 0;
16394   }
16395   std::string arg1_str(jarg1);
16396   arg1 = &arg1_str;
16397   if (!jarg2) {
16398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16399     return 0;
16400   }
16401   std::string arg2_str(jarg2);
16402   arg2 = &arg2_str;
16403   arg3 = (Dali::Shader::Hint::Value)jarg3;
16404   {
16405     try {
16406       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
16407     } CALL_CATCH_EXCEPTION(0);
16408   }
16409
16410   jresult = new Dali::Shader((const Dali::Shader &)result);
16411
16412   //argout typemap for const std::string&
16413
16414
16415   //argout typemap for const std::string&
16416
16417   return jresult;
16418 }
16419
16420
16421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
16422   void * jresult ;
16423   std::string *arg1 = 0 ;
16424   std::string *arg2 = 0 ;
16425   Dali::Shader result;
16426
16427   if (!jarg1) {
16428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16429     return 0;
16430   }
16431   std::string arg1_str(jarg1);
16432   arg1 = &arg1_str;
16433   if (!jarg2) {
16434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16435     return 0;
16436   }
16437   std::string arg2_str(jarg2);
16438   arg2 = &arg2_str;
16439   {
16440     try {
16441       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
16442     } CALL_CATCH_EXCEPTION(0);
16443   }
16444
16445   jresult = new Dali::Shader((const Dali::Shader &)result);
16446
16447   //argout typemap for const std::string&
16448
16449
16450   //argout typemap for const std::string&
16451
16452   return jresult;
16453 }
16454
16455
16456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
16457   void * jresult ;
16458   Dali::Shader *result = 0 ;
16459
16460   {
16461     try {
16462       result = (Dali::Shader *)new Dali::Shader();
16463     } CALL_CATCH_EXCEPTION(0);
16464   }
16465
16466   jresult = (void *)result;
16467   return jresult;
16468 }
16469
16470
16471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
16472   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16473
16474   arg1 = (Dali::Shader *)jarg1;
16475   {
16476     try {
16477       delete arg1;
16478     } CALL_CATCH_EXCEPTION();
16479   }
16480
16481 }
16482
16483
16484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
16485   void * jresult ;
16486   Dali::Shader *arg1 = 0 ;
16487   Dali::Shader *result = 0 ;
16488
16489   arg1 = (Dali::Shader *)jarg1;
16490   if (!arg1) {
16491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16492     return 0;
16493   }
16494   {
16495     try {
16496       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
16497     } CALL_CATCH_EXCEPTION(0);
16498   }
16499
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
16506   void * jresult ;
16507   Dali::BaseHandle arg1 ;
16508   Dali::BaseHandle *argp1 ;
16509   Dali::Shader result;
16510
16511   argp1 = (Dali::BaseHandle *)jarg1;
16512   if (!argp1) {
16513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16514     return 0;
16515   }
16516   arg1 = *argp1;
16517   {
16518     try {
16519       result = Dali::Shader::DownCast(arg1);
16520     } CALL_CATCH_EXCEPTION(0);
16521   }
16522
16523   jresult = new Dali::Shader((const Dali::Shader &)result);
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
16529   void * jresult ;
16530   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16531   Dali::Shader *arg2 = 0 ;
16532   Dali::Shader *result = 0 ;
16533
16534   arg1 = (Dali::Shader *)jarg1;
16535   arg2 = (Dali::Shader *)jarg2;
16536   if (!arg2) {
16537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16538     return 0;
16539   }
16540   {
16541     try {
16542       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
16543     } CALL_CATCH_EXCEPTION(0);
16544   }
16545
16546   jresult = (void *)result;
16547   return jresult;
16548 }
16549
16550
16551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
16552   int jresult ;
16553   int result;
16554
16555   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
16556   jresult = (int)result;
16557   return jresult;
16558 }
16559
16560
16561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
16562   int jresult ;
16563   int result;
16564
16565   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
16566   jresult = (int)result;
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
16572   int jresult ;
16573   int result;
16574
16575   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
16576   jresult = (int)result;
16577   return jresult;
16578 }
16579
16580
16581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
16582   int jresult ;
16583   int result;
16584
16585   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
16586   jresult = (int)result;
16587   return jresult;
16588 }
16589
16590
16591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
16592   int jresult ;
16593   int result;
16594
16595   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
16596   jresult = (int)result;
16597   return jresult;
16598 }
16599
16600
16601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
16602   int jresult ;
16603   int result;
16604
16605   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
16606   jresult = (int)result;
16607   return jresult;
16608 }
16609
16610
16611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
16612   int jresult ;
16613   int result;
16614
16615   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
16616   jresult = (int)result;
16617   return jresult;
16618 }
16619
16620
16621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
16622   int jresult ;
16623   int result;
16624
16625   result = (int)Dali::Renderer::Property::BLEND_MODE;
16626   jresult = (int)result;
16627   return jresult;
16628 }
16629
16630
16631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
16632   int jresult ;
16633   int result;
16634
16635   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
16636   jresult = (int)result;
16637   return jresult;
16638 }
16639
16640
16641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
16642   int jresult ;
16643   int result;
16644
16645   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
16646   jresult = (int)result;
16647   return jresult;
16648 }
16649
16650
16651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
16652   int jresult ;
16653   int result;
16654
16655   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
16656   jresult = (int)result;
16657   return jresult;
16658 }
16659
16660
16661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
16662   int jresult ;
16663   int result;
16664
16665   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
16666   jresult = (int)result;
16667   return jresult;
16668 }
16669
16670
16671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
16672   int jresult ;
16673   int result;
16674
16675   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
16676   jresult = (int)result;
16677   return jresult;
16678 }
16679
16680
16681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
16682   int jresult ;
16683   int result;
16684
16685   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
16686   jresult = (int)result;
16687   return jresult;
16688 }
16689
16690
16691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
16692   int jresult ;
16693   int result;
16694
16695   result = (int)Dali::Renderer::Property::BLEND_COLOR;
16696   jresult = (int)result;
16697   return jresult;
16698 }
16699
16700
16701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
16702   int jresult ;
16703   int result;
16704
16705   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
16706   jresult = (int)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
16712   int jresult ;
16713   int result;
16714
16715   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
16716   jresult = (int)result;
16717   return jresult;
16718 }
16719
16720
16721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
16722   int jresult ;
16723   int result;
16724
16725   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
16726   jresult = (int)result;
16727   return jresult;
16728 }
16729
16730
16731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
16732   int jresult ;
16733   int result;
16734
16735   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
16736   jresult = (int)result;
16737   return jresult;
16738 }
16739
16740
16741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
16742   int jresult ;
16743   int result;
16744
16745   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
16746   jresult = (int)result;
16747   return jresult;
16748 }
16749
16750
16751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
16752   int jresult ;
16753   int result;
16754
16755   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
16756   jresult = (int)result;
16757   return jresult;
16758 }
16759
16760
16761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
16762   int jresult ;
16763   int result;
16764
16765   result = (int)Dali::Renderer::Property::RENDER_MODE;
16766   jresult = (int)result;
16767   return jresult;
16768 }
16769
16770
16771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
16772   int jresult ;
16773   int result;
16774
16775   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
16776   jresult = (int)result;
16777   return jresult;
16778 }
16779
16780
16781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
16782   int jresult ;
16783   int result;
16784
16785   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
16786   jresult = (int)result;
16787   return jresult;
16788 }
16789
16790
16791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
16792   int jresult ;
16793   int result;
16794
16795   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
16796   jresult = (int)result;
16797   return jresult;
16798 }
16799
16800
16801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
16802   int jresult ;
16803   int result;
16804
16805   result = (int)Dali::Renderer::Property::STENCIL_MASK;
16806   jresult = (int)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
16812   int jresult ;
16813   int result;
16814
16815   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
16816   jresult = (int)result;
16817   return jresult;
16818 }
16819
16820
16821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
16822   int jresult ;
16823   int result;
16824
16825   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
16826   jresult = (int)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
16832   int jresult ;
16833   int result;
16834
16835   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
16836   jresult = (int)result;
16837   return jresult;
16838 }
16839
16840
16841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
16842   void * jresult ;
16843   Dali::Renderer::Property *result = 0 ;
16844
16845   {
16846     try {
16847       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
16848     } CALL_CATCH_EXCEPTION(0);
16849   }
16850
16851   jresult = (void *)result;
16852   return jresult;
16853 }
16854
16855
16856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
16857   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
16858
16859   arg1 = (Dali::Renderer::Property *)jarg1;
16860   {
16861     try {
16862       delete arg1;
16863     } CALL_CATCH_EXCEPTION();
16864   }
16865
16866 }
16867
16868
16869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
16870   void * jresult ;
16871   Dali::Geometry *arg1 = 0 ;
16872   Dali::Shader *arg2 = 0 ;
16873   Dali::Renderer result;
16874
16875   arg1 = (Dali::Geometry *)jarg1;
16876   if (!arg1) {
16877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
16878     return 0;
16879   }
16880   arg2 = (Dali::Shader *)jarg2;
16881   if (!arg2) {
16882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
16883     return 0;
16884   }
16885   {
16886     try {
16887       result = Dali::Renderer::New(*arg1,*arg2);
16888     } CALL_CATCH_EXCEPTION(0);
16889   }
16890
16891   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16892   return jresult;
16893 }
16894
16895
16896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
16897   void * jresult ;
16898   Dali::Renderer *result = 0 ;
16899
16900   {
16901     try {
16902       result = (Dali::Renderer *)new Dali::Renderer();
16903     } CALL_CATCH_EXCEPTION(0);
16904   }
16905
16906   jresult = (void *)result;
16907   return jresult;
16908 }
16909
16910
16911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
16912   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16913
16914   arg1 = (Dali::Renderer *)jarg1;
16915   {
16916     try {
16917       delete arg1;
16918     } CALL_CATCH_EXCEPTION();
16919   }
16920
16921 }
16922
16923
16924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
16925   void * jresult ;
16926   Dali::Renderer *arg1 = 0 ;
16927   Dali::Renderer *result = 0 ;
16928
16929   arg1 = (Dali::Renderer *)jarg1;
16930   if (!arg1) {
16931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
16932     return 0;
16933   }
16934   {
16935     try {
16936       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
16937     } CALL_CATCH_EXCEPTION(0);
16938   }
16939
16940   jresult = (void *)result;
16941   return jresult;
16942 }
16943
16944
16945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
16946   void * jresult ;
16947   Dali::BaseHandle arg1 ;
16948   Dali::BaseHandle *argp1 ;
16949   Dali::Renderer result;
16950
16951   argp1 = (Dali::BaseHandle *)jarg1;
16952   if (!argp1) {
16953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16954     return 0;
16955   }
16956   arg1 = *argp1;
16957   {
16958     try {
16959       result = Dali::Renderer::DownCast(arg1);
16960     } CALL_CATCH_EXCEPTION(0);
16961   }
16962
16963   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16964   return jresult;
16965 }
16966
16967
16968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
16969   void * jresult ;
16970   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16971   Dali::Renderer *arg2 = 0 ;
16972   Dali::Renderer *result = 0 ;
16973
16974   arg1 = (Dali::Renderer *)jarg1;
16975   arg2 = (Dali::Renderer *)jarg2;
16976   if (!arg2) {
16977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
16978     return 0;
16979   }
16980   {
16981     try {
16982       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
16983     } CALL_CATCH_EXCEPTION(0);
16984   }
16985
16986   jresult = (void *)result;
16987   return jresult;
16988 }
16989
16990
16991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
16992   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16993   Dali::Geometry *arg2 = 0 ;
16994
16995   arg1 = (Dali::Renderer *)jarg1;
16996   arg2 = (Dali::Geometry *)jarg2;
16997   if (!arg2) {
16998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
16999     return ;
17000   }
17001   {
17002     try {
17003       (arg1)->SetGeometry(*arg2);
17004     } CALL_CATCH_EXCEPTION();
17005   }
17006
17007 }
17008
17009
17010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17011   void * jresult ;
17012   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17013   Dali::Geometry result;
17014
17015   arg1 = (Dali::Renderer *)jarg1;
17016   {
17017     try {
17018       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17019     } CALL_CATCH_EXCEPTION(0);
17020   }
17021
17022   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17023   return jresult;
17024 }
17025
17026
17027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17028   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17029   int arg2 ;
17030   int arg3 ;
17031
17032   arg1 = (Dali::Renderer *)jarg1;
17033   arg2 = (int)jarg2;
17034   arg3 = (int)jarg3;
17035   {
17036     try {
17037       (arg1)->SetIndexRange(arg2,arg3);
17038     } CALL_CATCH_EXCEPTION();
17039   }
17040
17041 }
17042
17043
17044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17045   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17046   Dali::TextureSet *arg2 = 0 ;
17047
17048   arg1 = (Dali::Renderer *)jarg1;
17049   arg2 = (Dali::TextureSet *)jarg2;
17050   if (!arg2) {
17051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17052     return ;
17053   }
17054   {
17055     try {
17056       (arg1)->SetTextures(*arg2);
17057     } CALL_CATCH_EXCEPTION();
17058   }
17059
17060 }
17061
17062
17063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17064   void * jresult ;
17065   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17066   Dali::TextureSet result;
17067
17068   arg1 = (Dali::Renderer *)jarg1;
17069   {
17070     try {
17071       result = ((Dali::Renderer const *)arg1)->GetTextures();
17072     } CALL_CATCH_EXCEPTION(0);
17073   }
17074
17075   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17076   return jresult;
17077 }
17078
17079
17080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17081   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17082   Dali::Shader *arg2 = 0 ;
17083
17084   arg1 = (Dali::Renderer *)jarg1;
17085   arg2 = (Dali::Shader *)jarg2;
17086   if (!arg2) {
17087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17088     return ;
17089   }
17090   {
17091     try {
17092       (arg1)->SetShader(*arg2);
17093     } CALL_CATCH_EXCEPTION();
17094   }
17095
17096 }
17097
17098
17099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17100   void * jresult ;
17101   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17102   Dali::Shader result;
17103
17104   arg1 = (Dali::Renderer *)jarg1;
17105   {
17106     try {
17107       result = ((Dali::Renderer const *)arg1)->GetShader();
17108     } CALL_CATCH_EXCEPTION(0);
17109   }
17110
17111   jresult = new Dali::Shader((const Dali::Shader &)result);
17112   return jresult;
17113 }
17114
17115
17116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17117   void * jresult ;
17118   Dali::FrameBuffer::Attachment *result = 0 ;
17119
17120   {
17121     try {
17122       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17123     } CALL_CATCH_EXCEPTION(0);
17124   }
17125
17126   jresult = (void *)result;
17127   return jresult;
17128 }
17129
17130
17131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17132   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17133
17134   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17135   {
17136     try {
17137       delete arg1;
17138     } CALL_CATCH_EXCEPTION();
17139   }
17140
17141 }
17142
17143
17144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
17145   void * jresult ;
17146   unsigned int arg1 ;
17147   unsigned int arg2 ;
17148   unsigned int arg3 ;
17149   Dali::FrameBuffer result;
17150
17151   arg1 = (unsigned int)jarg1;
17152   arg2 = (unsigned int)jarg2;
17153   arg3 = (unsigned int)jarg3;
17154   {
17155     try {
17156       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
17157     } CALL_CATCH_EXCEPTION(0);
17158   }
17159
17160   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
17166   void * jresult ;
17167   Dali::FrameBuffer *result = 0 ;
17168
17169   {
17170     try {
17171       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
17172     } CALL_CATCH_EXCEPTION(0);
17173   }
17174
17175   jresult = (void *)result;
17176   return jresult;
17177 }
17178
17179
17180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
17181   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17182
17183   arg1 = (Dali::FrameBuffer *)jarg1;
17184   {
17185     try {
17186       delete arg1;
17187     } CALL_CATCH_EXCEPTION();
17188   }
17189
17190 }
17191
17192
17193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
17194   void * jresult ;
17195   Dali::FrameBuffer *arg1 = 0 ;
17196   Dali::FrameBuffer *result = 0 ;
17197
17198   arg1 = (Dali::FrameBuffer *)jarg1;
17199   if (!arg1) {
17200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17201     return 0;
17202   }
17203   {
17204     try {
17205       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
17206     } CALL_CATCH_EXCEPTION(0);
17207   }
17208
17209   jresult = (void *)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
17215   void * jresult ;
17216   Dali::BaseHandle arg1 ;
17217   Dali::BaseHandle *argp1 ;
17218   Dali::FrameBuffer result;
17219
17220   argp1 = (Dali::BaseHandle *)jarg1;
17221   if (!argp1) {
17222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17223     return 0;
17224   }
17225   arg1 = *argp1;
17226   {
17227     try {
17228       result = Dali::FrameBuffer::DownCast(arg1);
17229     } CALL_CATCH_EXCEPTION(0);
17230   }
17231
17232   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17233   return jresult;
17234 }
17235
17236
17237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
17238   void * jresult ;
17239   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17240   Dali::FrameBuffer *arg2 = 0 ;
17241   Dali::FrameBuffer *result = 0 ;
17242
17243   arg1 = (Dali::FrameBuffer *)jarg1;
17244   arg2 = (Dali::FrameBuffer *)jarg2;
17245   if (!arg2) {
17246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17247     return 0;
17248   }
17249   {
17250     try {
17251       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
17252     } CALL_CATCH_EXCEPTION(0);
17253   }
17254
17255   jresult = (void *)result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
17261   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17262   Dali::Texture *arg2 = 0 ;
17263
17264   arg1 = (Dali::FrameBuffer *)jarg1;
17265   arg2 = (Dali::Texture *)jarg2;
17266   if (!arg2) {
17267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17268     return ;
17269   }
17270   {
17271     try {
17272       (arg1)->AttachColorTexture(*arg2);
17273     } CALL_CATCH_EXCEPTION();
17274   }
17275
17276 }
17277
17278
17279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
17280   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17281   Dali::Texture *arg2 = 0 ;
17282   unsigned int arg3 ;
17283   unsigned int arg4 ;
17284
17285   arg1 = (Dali::FrameBuffer *)jarg1;
17286   arg2 = (Dali::Texture *)jarg2;
17287   if (!arg2) {
17288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17289     return ;
17290   }
17291   arg3 = (unsigned int)jarg3;
17292   arg4 = (unsigned int)jarg4;
17293   {
17294     try {
17295       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
17296     } CALL_CATCH_EXCEPTION();
17297   }
17298
17299 }
17300
17301
17302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
17303   void * jresult ;
17304   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17305   Dali::Texture result;
17306
17307   arg1 = (Dali::FrameBuffer *)jarg1;
17308   {
17309     try {
17310       result = (arg1)->GetColorTexture();
17311     } CALL_CATCH_EXCEPTION(0);
17312   }
17313
17314   jresult = new Dali::Texture((const Dali::Texture &)result);
17315   return jresult;
17316 }
17317
17318
17319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
17320   void * jresult ;
17321   Dali::RenderTaskList *result = 0 ;
17322
17323   {
17324     try {
17325       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
17326     } CALL_CATCH_EXCEPTION(0);
17327   }
17328
17329   jresult = (void *)result;
17330   return jresult;
17331 }
17332
17333
17334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
17335   void * jresult ;
17336   Dali::BaseHandle arg1 ;
17337   Dali::BaseHandle *argp1 ;
17338   Dali::RenderTaskList result;
17339
17340   argp1 = (Dali::BaseHandle *)jarg1;
17341   if (!argp1) {
17342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17343     return 0;
17344   }
17345   arg1 = *argp1;
17346   {
17347     try {
17348       result = Dali::RenderTaskList::DownCast(arg1);
17349     } CALL_CATCH_EXCEPTION(0);
17350   }
17351
17352   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
17353   return jresult;
17354 }
17355
17356
17357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
17358   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17359
17360   arg1 = (Dali::RenderTaskList *)jarg1;
17361   {
17362     try {
17363       delete arg1;
17364     } CALL_CATCH_EXCEPTION();
17365   }
17366
17367 }
17368
17369
17370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
17371   void * jresult ;
17372   Dali::RenderTaskList *arg1 = 0 ;
17373   Dali::RenderTaskList *result = 0 ;
17374
17375   arg1 = (Dali::RenderTaskList *)jarg1;
17376   if (!arg1) {
17377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17378     return 0;
17379   }
17380   {
17381     try {
17382       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
17383     } CALL_CATCH_EXCEPTION(0);
17384   }
17385
17386   jresult = (void *)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
17392   void * jresult ;
17393   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17394   Dali::RenderTaskList *arg2 = 0 ;
17395   Dali::RenderTaskList *result = 0 ;
17396
17397   arg1 = (Dali::RenderTaskList *)jarg1;
17398   arg2 = (Dali::RenderTaskList *)jarg2;
17399   if (!arg2) {
17400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17401     return 0;
17402   }
17403   {
17404     try {
17405       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
17406     } CALL_CATCH_EXCEPTION(0);
17407   }
17408
17409   jresult = (void *)result;
17410   return jresult;
17411 }
17412
17413
17414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
17415   void * jresult ;
17416   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17417   Dali::RenderTask result;
17418
17419   arg1 = (Dali::RenderTaskList *)jarg1;
17420   {
17421     try {
17422       result = (arg1)->CreateTask();
17423     } CALL_CATCH_EXCEPTION(0);
17424   }
17425
17426   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17427   return jresult;
17428 }
17429
17430
17431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
17432   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17433   Dali::RenderTask arg2 ;
17434   Dali::RenderTask *argp2 ;
17435
17436   arg1 = (Dali::RenderTaskList *)jarg1;
17437   argp2 = (Dali::RenderTask *)jarg2;
17438   if (!argp2) {
17439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
17440     return ;
17441   }
17442   arg2 = *argp2;
17443   {
17444     try {
17445       (arg1)->RemoveTask(arg2);
17446     } CALL_CATCH_EXCEPTION();
17447   }
17448
17449 }
17450
17451
17452 //// ===============================================end part 1 =================
17453
17454 //// ========================= part 2 ===============================
17455
17456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
17457   unsigned int jresult ;
17458   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17459   unsigned int result;
17460
17461   arg1 = (Dali::RenderTaskList *)jarg1;
17462   {
17463     try {
17464       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
17465     } CALL_CATCH_EXCEPTION(0);
17466   }
17467
17468   jresult = result;
17469   return jresult;
17470 }
17471
17472
17473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
17474   void * jresult ;
17475   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17476   unsigned int arg2 ;
17477   Dali::RenderTask result;
17478
17479   arg1 = (Dali::RenderTaskList *)jarg1;
17480   arg2 = (unsigned int)jarg2;
17481   {
17482     try {
17483       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
17484     } CALL_CATCH_EXCEPTION(0);
17485   }
17486
17487   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17488   return jresult;
17489 }
17490
17491
17492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
17493   int jresult ;
17494   int result;
17495
17496   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
17497   jresult = (int)result;
17498   return jresult;
17499 }
17500
17501
17502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
17503   int jresult ;
17504   int result;
17505
17506   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
17507   jresult = (int)result;
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
17513   int jresult ;
17514   int result;
17515
17516   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
17517   jresult = (int)result;
17518   return jresult;
17519 }
17520
17521
17522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
17523   int jresult ;
17524   int result;
17525
17526   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
17527   jresult = (int)result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
17533   void * jresult ;
17534   Dali::RenderTask::Property *result = 0 ;
17535
17536   {
17537     try {
17538       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
17539     } CALL_CATCH_EXCEPTION(0);
17540   }
17541
17542   jresult = (void *)result;
17543   return jresult;
17544 }
17545
17546
17547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
17548   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
17549
17550   arg1 = (Dali::RenderTask::Property *)jarg1;
17551   {
17552     try {
17553       delete arg1;
17554     } CALL_CATCH_EXCEPTION();
17555   }
17556
17557 }
17558
17559
17560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
17561   void * jresult ;
17562   bool (*result)(Dali::Vector2 &) = 0 ;
17563
17564   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
17565   jresult = (void *)result;
17566   return jresult;
17567 }
17568
17569
17570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
17571   void * jresult ;
17572   bool (*result)(Dali::Vector2 &) = 0 ;
17573
17574   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
17575   jresult = (void *)result;
17576   return jresult;
17577 }
17578
17579
17580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
17581   unsigned int jresult ;
17582   bool result;
17583
17584   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
17585   jresult = result;
17586   return jresult;
17587 }
17588
17589
17590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
17591   unsigned int jresult ;
17592   bool result;
17593
17594   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
17595   jresult = result;
17596   return jresult;
17597 }
17598
17599
17600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
17601   void * jresult ;
17602   Dali::Vector4 *result = 0 ;
17603
17604   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
17605   jresult = (void *)result;
17606   return jresult;
17607 }
17608
17609
17610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
17611   unsigned int jresult ;
17612   bool result;
17613
17614   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
17615   jresult = result;
17616   return jresult;
17617 }
17618
17619
17620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
17621   unsigned int jresult ;
17622   bool result;
17623
17624   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
17625   jresult = result;
17626   return jresult;
17627 }
17628
17629
17630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
17631   unsigned int jresult ;
17632   unsigned int result;
17633
17634   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
17635   jresult = result;
17636   return jresult;
17637 }
17638
17639
17640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
17641   void * jresult ;
17642   Dali::RenderTask *result = 0 ;
17643
17644   {
17645     try {
17646       result = (Dali::RenderTask *)new Dali::RenderTask();
17647     } CALL_CATCH_EXCEPTION(0);
17648   }
17649
17650   jresult = (void *)result;
17651   return jresult;
17652 }
17653
17654
17655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
17656   void * jresult ;
17657   Dali::BaseHandle arg1 ;
17658   Dali::BaseHandle *argp1 ;
17659   Dali::RenderTask result;
17660
17661   argp1 = (Dali::BaseHandle *)jarg1;
17662   if (!argp1) {
17663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17664     return 0;
17665   }
17666   arg1 = *argp1;
17667   {
17668     try {
17669       result = Dali::RenderTask::DownCast(arg1);
17670     } CALL_CATCH_EXCEPTION(0);
17671   }
17672
17673   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17674   return jresult;
17675 }
17676
17677
17678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
17679   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17680
17681   arg1 = (Dali::RenderTask *)jarg1;
17682   {
17683     try {
17684       delete arg1;
17685     } CALL_CATCH_EXCEPTION();
17686   }
17687
17688 }
17689
17690
17691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
17692   void * jresult ;
17693   Dali::RenderTask *arg1 = 0 ;
17694   Dali::RenderTask *result = 0 ;
17695
17696   arg1 = (Dali::RenderTask *)jarg1;
17697   if (!arg1) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17699     return 0;
17700   }
17701   {
17702     try {
17703       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
17704     } CALL_CATCH_EXCEPTION(0);
17705   }
17706
17707   jresult = (void *)result;
17708   return jresult;
17709 }
17710
17711
17712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
17713   void * jresult ;
17714   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17715   Dali::RenderTask *arg2 = 0 ;
17716   Dali::RenderTask *result = 0 ;
17717
17718   arg1 = (Dali::RenderTask *)jarg1;
17719   arg2 = (Dali::RenderTask *)jarg2;
17720   if (!arg2) {
17721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17722     return 0;
17723   }
17724   {
17725     try {
17726       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
17727     } CALL_CATCH_EXCEPTION(0);
17728   }
17729
17730   jresult = (void *)result;
17731   return jresult;
17732 }
17733
17734
17735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
17736   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17737   Dali::Actor arg2 ;
17738   Dali::Actor *argp2 ;
17739
17740   arg1 = (Dali::RenderTask *)jarg1;
17741   argp2 = (Dali::Actor *)jarg2;
17742   if (!argp2) {
17743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17744     return ;
17745   }
17746   arg2 = *argp2;
17747   {
17748     try {
17749       (arg1)->SetSourceActor(arg2);
17750     } CALL_CATCH_EXCEPTION();
17751   }
17752
17753 }
17754
17755
17756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
17757   void * jresult ;
17758   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17759   Dali::Actor result;
17760
17761   arg1 = (Dali::RenderTask *)jarg1;
17762   {
17763     try {
17764       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
17765     } CALL_CATCH_EXCEPTION(0);
17766   }
17767
17768   jresult = new Dali::Actor((const Dali::Actor &)result);
17769   return jresult;
17770 }
17771
17772
17773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
17774   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17775   bool arg2 ;
17776
17777   arg1 = (Dali::RenderTask *)jarg1;
17778   arg2 = jarg2 ? true : false;
17779   {
17780     try {
17781       (arg1)->SetExclusive(arg2);
17782     } CALL_CATCH_EXCEPTION();
17783   }
17784
17785 }
17786
17787
17788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
17789   unsigned int jresult ;
17790   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17791   bool result;
17792
17793   arg1 = (Dali::RenderTask *)jarg1;
17794   {
17795     try {
17796       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
17797     } CALL_CATCH_EXCEPTION(0);
17798   }
17799
17800   jresult = result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
17806   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17807   bool arg2 ;
17808
17809   arg1 = (Dali::RenderTask *)jarg1;
17810   arg2 = jarg2 ? true : false;
17811   {
17812     try {
17813       (arg1)->SetInputEnabled(arg2);
17814     } CALL_CATCH_EXCEPTION();
17815   }
17816
17817 }
17818
17819
17820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
17821   unsigned int jresult ;
17822   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17823   bool result;
17824
17825   arg1 = (Dali::RenderTask *)jarg1;
17826   {
17827     try {
17828       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
17829     } CALL_CATCH_EXCEPTION(0);
17830   }
17831
17832   jresult = result;
17833   return jresult;
17834 }
17835
17836
17837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
17838   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17839   Dali::CameraActor arg2 ;
17840   Dali::CameraActor *argp2 ;
17841
17842   arg1 = (Dali::RenderTask *)jarg1;
17843   argp2 = (Dali::CameraActor *)jarg2;
17844   if (!argp2) {
17845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
17846     return ;
17847   }
17848   arg2 = *argp2;
17849   {
17850     try {
17851       (arg1)->SetCameraActor(arg2);
17852     } CALL_CATCH_EXCEPTION();
17853   }
17854
17855 }
17856
17857
17858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
17859   void * jresult ;
17860   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17861   Dali::CameraActor result;
17862
17863   arg1 = (Dali::RenderTask *)jarg1;
17864   {
17865     try {
17866       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
17867     } CALL_CATCH_EXCEPTION(0);
17868   }
17869
17870   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
17871   return jresult;
17872 }
17873
17874
17875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
17876   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17877   Dali::FrameBuffer arg2 ;
17878   Dali::FrameBuffer *argp2 ;
17879
17880   arg1 = (Dali::RenderTask *)jarg1;
17881   argp2 = (Dali::FrameBuffer *)jarg2;
17882   if (!argp2) {
17883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
17884     return ;
17885   }
17886   arg2 = *argp2;
17887   {
17888     try {
17889       (arg1)->SetFrameBuffer(arg2);
17890     } CALL_CATCH_EXCEPTION();
17891   }
17892
17893 }
17894
17895
17896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
17897   void * jresult ;
17898   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17899   Dali::FrameBuffer result;
17900
17901   arg1 = (Dali::RenderTask *)jarg1;
17902   {
17903     try {
17904       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
17905     } CALL_CATCH_EXCEPTION(0);
17906   }
17907
17908   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17909   return jresult;
17910 }
17911
17912
17913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
17914   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17915   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
17916
17917   arg1 = (Dali::RenderTask *)jarg1;
17918   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
17919   {
17920     try {
17921       (arg1)->SetScreenToFrameBufferFunction(arg2);
17922     } CALL_CATCH_EXCEPTION();
17923   }
17924
17925 }
17926
17927
17928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
17929   void * jresult ;
17930   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17931   Dali::RenderTask::ScreenToFrameBufferFunction result;
17932
17933   arg1 = (Dali::RenderTask *)jarg1;
17934   {
17935     try {
17936       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
17937     } CALL_CATCH_EXCEPTION(0);
17938   }
17939
17940   jresult = (void *)result;
17941   return jresult;
17942 }
17943
17944
17945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
17946   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17947   Dali::Actor arg2 ;
17948   Dali::Actor *argp2 ;
17949
17950   arg1 = (Dali::RenderTask *)jarg1;
17951   argp2 = (Dali::Actor *)jarg2;
17952   if (!argp2) {
17953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17954     return ;
17955   }
17956   arg2 = *argp2;
17957   {
17958     try {
17959       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
17960     } CALL_CATCH_EXCEPTION();
17961   }
17962
17963 }
17964
17965
17966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
17967   void * jresult ;
17968   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17969   Dali::Actor result;
17970
17971   arg1 = (Dali::RenderTask *)jarg1;
17972   {
17973     try {
17974       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
17975     } CALL_CATCH_EXCEPTION(0);
17976   }
17977
17978   jresult = new Dali::Actor((const Dali::Actor &)result);
17979   return jresult;
17980 }
17981
17982
17983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
17984   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17985   Dali::Vector2 arg2 ;
17986   Dali::Vector2 *argp2 ;
17987
17988   arg1 = (Dali::RenderTask *)jarg1;
17989   argp2 = (Dali::Vector2 *)jarg2;
17990   if (!argp2) {
17991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
17992     return ;
17993   }
17994   arg2 = *argp2;
17995   {
17996     try {
17997       (arg1)->SetViewportPosition(arg2);
17998     } CALL_CATCH_EXCEPTION();
17999   }
18000
18001 }
18002
18003
18004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18005   void * jresult ;
18006   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18007   Dali::Vector2 result;
18008
18009   arg1 = (Dali::RenderTask *)jarg1;
18010   {
18011     try {
18012       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18013     } CALL_CATCH_EXCEPTION(0);
18014   }
18015
18016   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18017   return jresult;
18018 }
18019
18020
18021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18022   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18023   Dali::Vector2 arg2 ;
18024   Dali::Vector2 *argp2 ;
18025
18026   arg1 = (Dali::RenderTask *)jarg1;
18027   argp2 = (Dali::Vector2 *)jarg2;
18028   if (!argp2) {
18029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18030     return ;
18031   }
18032   arg2 = *argp2;
18033   {
18034     try {
18035       (arg1)->SetViewportSize(arg2);
18036     } CALL_CATCH_EXCEPTION();
18037   }
18038
18039 }
18040
18041
18042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18043   void * jresult ;
18044   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18045   Dali::Vector2 result;
18046
18047   arg1 = (Dali::RenderTask *)jarg1;
18048   {
18049     try {
18050       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18051     } CALL_CATCH_EXCEPTION(0);
18052   }
18053
18054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18055   return jresult;
18056 }
18057
18058
18059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18060   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18061   Dali::Viewport arg2 ;
18062   Dali::Viewport *argp2 ;
18063
18064   arg1 = (Dali::RenderTask *)jarg1;
18065   argp2 = (Dali::Viewport *)jarg2;
18066   if (!argp2) {
18067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18068     return ;
18069   }
18070   arg2 = *argp2;
18071   {
18072     try {
18073       (arg1)->SetViewport(arg2);
18074     } CALL_CATCH_EXCEPTION();
18075   }
18076
18077 }
18078
18079
18080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18081   void * jresult ;
18082   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18083   Dali::Viewport result;
18084
18085   arg1 = (Dali::RenderTask *)jarg1;
18086   {
18087     try {
18088       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18089     } CALL_CATCH_EXCEPTION(0);
18090   }
18091
18092   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18098   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18099   Dali::Vector4 *arg2 = 0 ;
18100
18101   arg1 = (Dali::RenderTask *)jarg1;
18102   arg2 = (Dali::Vector4 *)jarg2;
18103   if (!arg2) {
18104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18105     return ;
18106   }
18107   {
18108     try {
18109       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18110     } CALL_CATCH_EXCEPTION();
18111   }
18112
18113 }
18114
18115
18116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
18117   void * jresult ;
18118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18119   Dali::Vector4 result;
18120
18121   arg1 = (Dali::RenderTask *)jarg1;
18122   {
18123     try {
18124       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
18125     } CALL_CATCH_EXCEPTION(0);
18126   }
18127
18128   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18129   return jresult;
18130 }
18131
18132
18133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
18134   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18135   bool arg2 ;
18136
18137   arg1 = (Dali::RenderTask *)jarg1;
18138   arg2 = jarg2 ? true : false;
18139   {
18140     try {
18141       (arg1)->SetClearEnabled(arg2);
18142     } CALL_CATCH_EXCEPTION();
18143   }
18144
18145 }
18146
18147
18148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
18149   unsigned int jresult ;
18150   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18151   bool result;
18152
18153   arg1 = (Dali::RenderTask *)jarg1;
18154   {
18155     try {
18156       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
18157     } CALL_CATCH_EXCEPTION(0);
18158   }
18159
18160   jresult = result;
18161   return jresult;
18162 }
18163
18164
18165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
18166   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18167   bool arg2 ;
18168
18169   arg1 = (Dali::RenderTask *)jarg1;
18170   arg2 = jarg2 ? true : false;
18171   {
18172     try {
18173       (arg1)->SetCullMode(arg2);
18174     } CALL_CATCH_EXCEPTION();
18175   }
18176
18177 }
18178
18179
18180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
18181   unsigned int jresult ;
18182   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18183   bool result;
18184
18185   arg1 = (Dali::RenderTask *)jarg1;
18186   {
18187     try {
18188       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
18189     } CALL_CATCH_EXCEPTION(0);
18190   }
18191
18192   jresult = result;
18193   return jresult;
18194 }
18195
18196
18197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
18198   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18199   unsigned int arg2 ;
18200
18201   arg1 = (Dali::RenderTask *)jarg1;
18202   arg2 = (unsigned int)jarg2;
18203   {
18204     try {
18205       (arg1)->SetRefreshRate(arg2);
18206     } CALL_CATCH_EXCEPTION();
18207   }
18208
18209 }
18210
18211
18212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
18213   unsigned int jresult ;
18214   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18215   unsigned int result;
18216
18217   arg1 = (Dali::RenderTask *)jarg1;
18218   {
18219     try {
18220       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
18221     } CALL_CATCH_EXCEPTION(0);
18222   }
18223
18224   jresult = result;
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
18230   unsigned int jresult ;
18231   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18232   Dali::Vector3 *arg2 = 0 ;
18233   float *arg3 = 0 ;
18234   float *arg4 = 0 ;
18235   bool result;
18236
18237   arg1 = (Dali::RenderTask *)jarg1;
18238   arg2 = (Dali::Vector3 *)jarg2;
18239   if (!arg2) {
18240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
18241     return 0;
18242   }
18243   arg3 = (float *)jarg3;
18244   arg4 = (float *)jarg4;
18245   {
18246     try {
18247       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
18248     } CALL_CATCH_EXCEPTION(0);
18249   }
18250
18251   jresult = result;
18252   return jresult;
18253 }
18254
18255
18256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
18257   unsigned int jresult ;
18258   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18259   Dali::Actor arg2 ;
18260   float arg3 ;
18261   float arg4 ;
18262   float *arg5 = 0 ;
18263   float *arg6 = 0 ;
18264   Dali::Actor *argp2 ;
18265   bool result;
18266
18267   arg1 = (Dali::RenderTask *)jarg1;
18268   argp2 = (Dali::Actor *)jarg2;
18269   if (!argp2) {
18270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18271     return 0;
18272   }
18273   arg2 = *argp2;
18274   arg3 = (float)jarg3;
18275   arg4 = (float)jarg4;
18276   arg5 = (float *)jarg5;
18277   arg6 = (float *)jarg6;
18278   {
18279     try {
18280       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
18281     } CALL_CATCH_EXCEPTION(0);
18282   }
18283
18284   jresult = result;
18285   return jresult;
18286 }
18287
18288
18289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
18290   void * jresult ;
18291   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18292   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
18293
18294   arg1 = (Dali::RenderTask *)jarg1;
18295   {
18296     try {
18297       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
18298     } CALL_CATCH_EXCEPTION(0);
18299   }
18300
18301   jresult = (void *)result;
18302   return jresult;
18303 }
18304
18305
18306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
18307   void * jresult ;
18308   int arg1 ;
18309   Dali::PointState::Type arg2 ;
18310   float arg3 ;
18311   float arg4 ;
18312   Dali::TouchPoint *result = 0 ;
18313
18314   arg1 = (int)jarg1;
18315   arg2 = (Dali::PointState::Type)jarg2;
18316   arg3 = (float)jarg3;
18317   arg4 = (float)jarg4;
18318   {
18319     try {
18320       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
18321     } CALL_CATCH_EXCEPTION(0);
18322   }
18323
18324   jresult = (void *)result;
18325   return jresult;
18326 }
18327
18328
18329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
18330   void * jresult ;
18331   int arg1 ;
18332   Dali::PointState::Type arg2 ;
18333   float arg3 ;
18334   float arg4 ;
18335   float arg5 ;
18336   float arg6 ;
18337   Dali::TouchPoint *result = 0 ;
18338
18339   arg1 = (int)jarg1;
18340   arg2 = (Dali::PointState::Type)jarg2;
18341   arg3 = (float)jarg3;
18342   arg4 = (float)jarg4;
18343   arg5 = (float)jarg5;
18344   arg6 = (float)jarg6;
18345   {
18346     try {
18347       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
18348     } CALL_CATCH_EXCEPTION(0);
18349   }
18350
18351   jresult = (void *)result;
18352   return jresult;
18353 }
18354
18355
18356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
18357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18358
18359   arg1 = (Dali::TouchPoint *)jarg1;
18360   {
18361     try {
18362       delete arg1;
18363     } CALL_CATCH_EXCEPTION();
18364   }
18365
18366 }
18367
18368
18369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
18370   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18371   int arg2 ;
18372
18373   arg1 = (Dali::TouchPoint *)jarg1;
18374   arg2 = (int)jarg2;
18375   if (arg1) (arg1)->deviceId = arg2;
18376 }
18377
18378
18379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
18380   int jresult ;
18381   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18382   int result;
18383
18384   arg1 = (Dali::TouchPoint *)jarg1;
18385   result = (int) ((arg1)->deviceId);
18386   jresult = result;
18387   return jresult;
18388 }
18389
18390
18391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
18392   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18393   Dali::PointState::Type arg2 ;
18394
18395   arg1 = (Dali::TouchPoint *)jarg1;
18396   arg2 = (Dali::PointState::Type)jarg2;
18397   if (arg1) (arg1)->state = arg2;
18398 }
18399
18400
18401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
18402   int jresult ;
18403   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18404   Dali::PointState::Type result;
18405
18406   arg1 = (Dali::TouchPoint *)jarg1;
18407   result = (Dali::PointState::Type) ((arg1)->state);
18408   jresult = (int)result;
18409   return jresult;
18410 }
18411
18412
18413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
18414   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18415   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
18416
18417   arg1 = (Dali::TouchPoint *)jarg1;
18418   arg2 = (Dali::Actor *)jarg2;
18419   if (arg1) (arg1)->hitActor = *arg2;
18420 }
18421
18422
18423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
18424   void * jresult ;
18425   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18426   Dali::Actor *result = 0 ;
18427
18428   arg1 = (Dali::TouchPoint *)jarg1;
18429   result = (Dali::Actor *)& ((arg1)->hitActor);
18430   jresult = (void *)result;
18431   return jresult;
18432 }
18433
18434
18435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
18436   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18437   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18438
18439   arg1 = (Dali::TouchPoint *)jarg1;
18440   arg2 = (Dali::Vector2 *)jarg2;
18441   if (arg1) (arg1)->local = *arg2;
18442 }
18443
18444
18445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
18446   void * jresult ;
18447   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18448   Dali::Vector2 *result = 0 ;
18449
18450   arg1 = (Dali::TouchPoint *)jarg1;
18451   result = (Dali::Vector2 *)& ((arg1)->local);
18452   jresult = (void *)result;
18453   return jresult;
18454 }
18455
18456
18457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
18458   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18459   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18460
18461   arg1 = (Dali::TouchPoint *)jarg1;
18462   arg2 = (Dali::Vector2 *)jarg2;
18463   if (arg1) (arg1)->screen = *arg2;
18464 }
18465
18466
18467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
18468   void * jresult ;
18469   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18470   Dali::Vector2 *result = 0 ;
18471
18472   arg1 = (Dali::TouchPoint *)jarg1;
18473   result = (Dali::Vector2 *)& ((arg1)->screen);
18474   jresult = (void *)result;
18475   return jresult;
18476 }
18477
18478
18479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
18480   void * jresult ;
18481   Dali::TouchEvent *result = 0 ;
18482
18483   {
18484     try {
18485       result = (Dali::TouchEvent *)new Dali::TouchEvent();
18486     } CALL_CATCH_EXCEPTION(0);
18487   }
18488
18489   jresult = (void *)result;
18490   return jresult;
18491 }
18492
18493
18494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
18495   void * jresult ;
18496   Dali::TouchEvent *arg1 = 0 ;
18497   Dali::TouchEvent *result = 0 ;
18498
18499   arg1 = (Dali::TouchEvent *)jarg1;
18500   if (!arg1) {
18501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18502     return 0;
18503   }
18504   {
18505     try {
18506       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
18507     } CALL_CATCH_EXCEPTION(0);
18508   }
18509
18510   jresult = (void *)result;
18511   return jresult;
18512 }
18513
18514
18515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
18516   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18517
18518   arg1 = (Dali::TouchEvent *)jarg1;
18519   {
18520     try {
18521       delete arg1;
18522     } CALL_CATCH_EXCEPTION();
18523   }
18524
18525 }
18526
18527
18528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
18529   void * jresult ;
18530   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18531   Dali::TouchEvent *arg2 = 0 ;
18532   Dali::TouchEvent *result = 0 ;
18533
18534   arg1 = (Dali::TouchEvent *)jarg1;
18535   arg2 = (Dali::TouchEvent *)jarg2;
18536   if (!arg2) {
18537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18538     return 0;
18539   }
18540   {
18541     try {
18542       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
18543     } CALL_CATCH_EXCEPTION(0);
18544   }
18545
18546   jresult = (void *)result;
18547   return jresult;
18548 }
18549
18550
18551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
18552   unsigned long jresult ;
18553   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18554   unsigned long result;
18555
18556   arg1 = (Dali::TouchEvent *)jarg1;
18557   {
18558     try {
18559       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
18560     } CALL_CATCH_EXCEPTION(0);
18561   }
18562
18563   jresult = (unsigned long)result;
18564   return jresult;
18565 }
18566
18567
18568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
18569   unsigned long jresult ;
18570   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18571   std::size_t result;
18572
18573   arg1 = (Dali::TouchEvent *)jarg1;
18574   {
18575     try {
18576       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
18577     } CALL_CATCH_EXCEPTION(0);
18578   }
18579
18580   jresult = (unsigned long)result;
18581   return jresult;
18582 }
18583
18584
18585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
18586   int jresult ;
18587   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18588   std::size_t arg2 ;
18589   int32_t result;
18590
18591   arg1 = (Dali::TouchEvent *)jarg1;
18592   arg2 = (std::size_t)jarg2;
18593   {
18594     try {
18595       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
18596     } CALL_CATCH_EXCEPTION(0);
18597   }
18598
18599   jresult = result;
18600   return jresult;
18601 }
18602
18603
18604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
18605   int jresult ;
18606   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18607   std::size_t arg2 ;
18608   Dali::PointState::Type result;
18609
18610   arg1 = (Dali::TouchEvent *)jarg1;
18611   arg2 = (std::size_t)jarg2;
18612   {
18613     try {
18614       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
18615     } CALL_CATCH_EXCEPTION(0);
18616   }
18617
18618   jresult = (int)result;
18619   return jresult;
18620 }
18621
18622
18623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
18624   void * jresult ;
18625   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18626   std::size_t arg2 ;
18627   Dali::Actor result;
18628
18629   arg1 = (Dali::TouchEvent *)jarg1;
18630   arg2 = (std::size_t)jarg2;
18631   {
18632     try {
18633       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
18634     } CALL_CATCH_EXCEPTION(0);
18635   }
18636
18637   jresult = new Dali::Actor((const Dali::Actor &)result);
18638   return jresult;
18639 }
18640
18641
18642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
18643   void * jresult ;
18644   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18645   std::size_t arg2 ;
18646   Dali::Vector2 *result = 0 ;
18647
18648   arg1 = (Dali::TouchEvent *)jarg1;
18649   arg2 = (std::size_t)jarg2;
18650   {
18651     try {
18652       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
18653     } CALL_CATCH_EXCEPTION(0);
18654   }
18655
18656   jresult = (void *)result;
18657   return jresult;
18658 }
18659
18660
18661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
18662   void * jresult ;
18663   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18664   std::size_t arg2 ;
18665   Dali::Vector2 *result = 0 ;
18666
18667   arg1 = (Dali::TouchEvent *)jarg1;
18668   arg2 = (std::size_t)jarg2;
18669   {
18670     try {
18671       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
18672     } CALL_CATCH_EXCEPTION(0);
18673   }
18674
18675   jresult = (void *)result;
18676   return jresult;
18677 }
18678
18679
18680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
18681   float jresult ;
18682   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18683   std::size_t arg2 ;
18684   float result;
18685
18686   arg1 = (Dali::TouchEvent *)jarg1;
18687   arg2 = (std::size_t)jarg2;
18688   {
18689     try {
18690       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
18691     } CALL_CATCH_EXCEPTION(0);
18692   }
18693
18694   jresult = result;
18695   return jresult;
18696 }
18697
18698
18699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
18700   void * jresult ;
18701   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18702   std::size_t arg2 ;
18703   Dali::Vector2 *result = 0 ;
18704
18705   arg1 = (Dali::TouchEvent *)jarg1;
18706   arg2 = (std::size_t)jarg2;
18707   {
18708     try {
18709       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
18710     } CALL_CATCH_EXCEPTION(0);
18711   }
18712
18713   jresult = (void *)result;
18714   return jresult;
18715 }
18716
18717
18718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
18719   float jresult ;
18720   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18721   std::size_t arg2 ;
18722   float result;
18723
18724   arg1 = (Dali::TouchEvent *)jarg1;
18725   arg2 = (std::size_t)jarg2;
18726   {
18727     try {
18728       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
18729     } CALL_CATCH_EXCEPTION(0);
18730   }
18731
18732   jresult = result;
18733   return jresult;
18734 }
18735
18736
18737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
18738   void * jresult ;
18739   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18740   std::size_t arg2 ;
18741   Dali::Degree result;
18742
18743   arg1 = (Dali::TouchEvent *)jarg1;
18744   arg2 = (std::size_t)jarg2;
18745   {
18746     try {
18747       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
18748     } CALL_CATCH_EXCEPTION(0);
18749   }
18750
18751   jresult = new Dali::Degree((const Dali::Degree &)result);
18752   return jresult;
18753 }
18754
18755
18756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
18757   int jresult ;
18758   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18759   std::size_t arg2 ;
18760   Dali::MouseButton::Type result;
18761
18762   arg1 = (Dali::TouchEvent *)jarg1;
18763   arg2 = (std::size_t)jarg2;
18764   {
18765     try {
18766       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
18767     } CALL_CATCH_EXCEPTION(0);
18768   }
18769
18770   jresult = static_cast< int >(result);
18771   return jresult;
18772 }
18773
18774
18775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
18776   void * jresult ;
18777   Dali::GestureDetector *result = 0 ;
18778
18779   {
18780     try {
18781       result = (Dali::GestureDetector *)new Dali::GestureDetector();
18782     } CALL_CATCH_EXCEPTION(0);
18783   }
18784
18785   jresult = (void *)result;
18786   return jresult;
18787 }
18788
18789
18790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
18791   void * jresult ;
18792   Dali::BaseHandle arg1 ;
18793   Dali::BaseHandle *argp1 ;
18794   Dali::GestureDetector result;
18795
18796   argp1 = (Dali::BaseHandle *)jarg1;
18797   if (!argp1) {
18798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18799     return 0;
18800   }
18801   arg1 = *argp1;
18802   {
18803     try {
18804       result = Dali::GestureDetector::DownCast(arg1);
18805     } CALL_CATCH_EXCEPTION(0);
18806   }
18807
18808   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
18809   return jresult;
18810 }
18811
18812
18813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
18814   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18815
18816   arg1 = (Dali::GestureDetector *)jarg1;
18817   {
18818     try {
18819       delete arg1;
18820     } CALL_CATCH_EXCEPTION();
18821   }
18822
18823 }
18824
18825
18826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
18827   void * jresult ;
18828   Dali::GestureDetector *arg1 = 0 ;
18829   Dali::GestureDetector *result = 0 ;
18830
18831   arg1 = (Dali::GestureDetector *)jarg1;
18832   if (!arg1) {
18833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18834     return 0;
18835   }
18836   {
18837     try {
18838       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
18839     } CALL_CATCH_EXCEPTION(0);
18840   }
18841
18842   jresult = (void *)result;
18843   return jresult;
18844 }
18845
18846
18847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
18848   void * jresult ;
18849   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18850   Dali::GestureDetector *arg2 = 0 ;
18851   Dali::GestureDetector *result = 0 ;
18852
18853   arg1 = (Dali::GestureDetector *)jarg1;
18854   arg2 = (Dali::GestureDetector *)jarg2;
18855   if (!arg2) {
18856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18857     return 0;
18858   }
18859   {
18860     try {
18861       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
18862     } CALL_CATCH_EXCEPTION(0);
18863   }
18864
18865   jresult = (void *)result;
18866   return jresult;
18867 }
18868
18869
18870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
18871   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18872   Dali::Actor arg2 ;
18873   Dali::Actor *argp2 ;
18874
18875   arg1 = (Dali::GestureDetector *)jarg1;
18876   argp2 = (Dali::Actor *)jarg2;
18877   if (!argp2) {
18878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18879     return ;
18880   }
18881   arg2 = *argp2;
18882   {
18883     try {
18884       (arg1)->Attach(arg2);
18885     } CALL_CATCH_EXCEPTION();
18886   }
18887
18888 }
18889
18890
18891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
18892   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18893   Dali::Actor arg2 ;
18894   Dali::Actor *argp2 ;
18895
18896   arg1 = (Dali::GestureDetector *)jarg1;
18897   argp2 = (Dali::Actor *)jarg2;
18898   if (!argp2) {
18899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18900     return ;
18901   }
18902   arg2 = *argp2;
18903   {
18904     try {
18905       (arg1)->Detach(arg2);
18906     } CALL_CATCH_EXCEPTION();
18907   }
18908
18909 }
18910
18911
18912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
18913   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18914
18915   arg1 = (Dali::GestureDetector *)jarg1;
18916   {
18917     try {
18918       (arg1)->DetachAll();
18919     } CALL_CATCH_EXCEPTION();
18920   }
18921
18922 }
18923
18924
18925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
18926   unsigned long jresult ;
18927   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18928   size_t result;
18929
18930   arg1 = (Dali::GestureDetector *)jarg1;
18931   {
18932     try {
18933       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
18934     } CALL_CATCH_EXCEPTION(0);
18935   }
18936
18937   jresult = (unsigned long)result;
18938   return jresult;
18939 }
18940
18941
18942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
18943   void * jresult ;
18944   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18945   size_t arg2 ;
18946   Dali::Actor result;
18947
18948   arg1 = (Dali::GestureDetector *)jarg1;
18949   arg2 = (size_t)jarg2;
18950   {
18951     try {
18952       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
18953     } CALL_CATCH_EXCEPTION(0);
18954   }
18955
18956   jresult = new Dali::Actor((const Dali::Actor &)result);
18957   return jresult;
18958 }
18959
18960
18961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
18962   void * jresult ;
18963   Dali::Gesture *arg1 = 0 ;
18964   Dali::Gesture *result = 0 ;
18965
18966   arg1 = (Dali::Gesture *)jarg1;
18967   if (!arg1) {
18968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
18969     return 0;
18970   }
18971   {
18972     try {
18973       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
18974     } CALL_CATCH_EXCEPTION(0);
18975   }
18976
18977   jresult = (void *)result;
18978   return jresult;
18979 }
18980
18981
18982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
18983   void * jresult ;
18984   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
18985   Dali::Gesture *arg2 = 0 ;
18986   Dali::Gesture *result = 0 ;
18987
18988   arg1 = (Dali::Gesture *)jarg1;
18989   arg2 = (Dali::Gesture *)jarg2;
18990   if (!arg2) {
18991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
18992     return 0;
18993   }
18994   {
18995     try {
18996       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
18997     } CALL_CATCH_EXCEPTION(0);
18998   }
18999
19000   jresult = (void *)result;
19001   return jresult;
19002 }
19003
19004
19005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19006   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19007
19008   arg1 = (Dali::Gesture *)jarg1;
19009   {
19010     try {
19011       delete arg1;
19012     } CALL_CATCH_EXCEPTION();
19013   }
19014
19015 }
19016
19017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19018   int jresult ;
19019   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19020   Dali::GestureType::Value result;
19021
19022   arg1 = (Dali::Gesture *)jarg1;
19023   result = (Dali::GestureType::Value) ((arg1)->GetType());
19024   jresult = (int)result;
19025   return jresult;
19026 }
19027
19028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19029   int jresult ;
19030   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19031   Dali::GestureState result;
19032
19033   arg1 = (Dali::Gesture *)jarg1;
19034   result = (Dali::GestureState) ((arg1)->GetState());
19035   jresult = (int)result;
19036   return jresult;
19037 }
19038
19039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19040   unsigned int jresult ;
19041   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19042   unsigned int result;
19043
19044   arg1 = (Dali::Gesture *)jarg1;
19045   result = (unsigned int) ((arg1)->GetTime());
19046   jresult = result;
19047   return jresult;
19048 }
19049
19050
19051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19052   void * jresult ;
19053   Dali::HoverEvent *result = 0 ;
19054
19055   {
19056     try {
19057       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19058     } CALL_CATCH_EXCEPTION(0);
19059   }
19060
19061   jresult = (void *)result;
19062   return jresult;
19063 }
19064
19065
19066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19067   void * jresult ;
19068   Dali::HoverEvent *arg1 = 0 ;
19069   Dali::HoverEvent *result = 0 ;
19070
19071   arg1 = (Dali::HoverEvent *)jarg1;
19072   if (!arg1) {
19073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19074     return 0;
19075   }
19076   {
19077     try {
19078       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
19079     } CALL_CATCH_EXCEPTION(0);
19080   }
19081
19082   jresult = (void *)result;
19083   return jresult;
19084 }
19085
19086
19087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
19088   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19089
19090   arg1 = (Dali::HoverEvent *)jarg1;
19091   {
19092     try {
19093       delete arg1;
19094     } CALL_CATCH_EXCEPTION();
19095   }
19096
19097 }
19098
19099
19100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
19101   void * jresult ;
19102   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19103   Dali::HoverEvent *arg2 = 0 ;
19104   Dali::HoverEvent *result = 0 ;
19105
19106   arg1 = (Dali::HoverEvent *)jarg1;
19107   arg2 = (Dali::HoverEvent *)jarg2;
19108   if (!arg2) {
19109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19110     return 0;
19111   }
19112   {
19113     try {
19114       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
19115     } catch (std::out_of_range& e) {
19116       {
19117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19118       };
19119     } catch (std::exception& e) {
19120       {
19121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19122       };
19123     } catch (Dali::DaliException e) {
19124       {
19125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19126       };
19127     } catch (...) {
19128       {
19129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19130       };
19131     }
19132   }
19133
19134   jresult = (void *)result;
19135   return jresult;
19136 }
19137
19138
19139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
19140   void * jresult ;
19141   unsigned int arg1 ;
19142   Dali::HoverEvent result;
19143
19144   arg1 = (unsigned int)jarg1;
19145   {
19146     try {
19147       result = DevelHoverEvent::New(arg1);
19148     } CALL_CATCH_EXCEPTION(0);
19149   }
19150
19151   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
19152   return jresult;
19153 }
19154
19155
19156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19157   unsigned long jresult ;
19158   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19159   unsigned long result;
19160
19161   arg1 = (Dali::HoverEvent *)jarg1;
19162   {
19163     try {
19164       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19165     } catch (std::out_of_range& e) {
19166       {
19167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19168       };
19169     } catch (std::exception& e) {
19170       {
19171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19172       };
19173     } catch (Dali::DaliException e) {
19174       {
19175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19176       };
19177     } catch (...) {
19178       {
19179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19180       };
19181     }
19182   }
19183
19184   jresult = (unsigned long)result;
19185   return jresult;
19186 }
19187
19188
19189 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19190   unsigned long jresult ;
19191   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19192   std::size_t result;
19193
19194   arg1 = (Dali::HoverEvent *)jarg1;
19195   {
19196     try {
19197       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19198     } catch (std::out_of_range& e) {
19199       {
19200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (std::exception& e) {
19203       {
19204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19205       };
19206     } catch (Dali::DaliException e) {
19207       {
19208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19209       };
19210     } catch (...) {
19211       {
19212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19213       };
19214     }
19215   }
19216
19217   jresult = (unsigned long)result;
19218   return jresult;
19219 }
19220
19221
19222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19223   int jresult ;
19224   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19225   std::size_t arg2 ;
19226   int32_t result;
19227
19228   arg1 = (Dali::HoverEvent *)jarg1;
19229   arg2 = (std::size_t)jarg2;
19230   {
19231     try {
19232       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19233     } catch (std::out_of_range& e) {
19234       {
19235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (std::exception& e) {
19238       {
19239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (Dali::DaliException e) {
19242       {
19243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19244       };
19245     } catch (...) {
19246       {
19247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19248       };
19249     }
19250   }
19251
19252   jresult = result;
19253   return jresult;
19254 }
19255
19256
19257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19258   int jresult ;
19259   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19260   std::size_t arg2 ;
19261   Dali::PointState::Type result;
19262
19263   arg1 = (Dali::HoverEvent *)jarg1;
19264   arg2 = (std::size_t)jarg2;
19265   {
19266     try {
19267       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19268     } CALL_CATCH_EXCEPTION(0);
19269   }
19270
19271   jresult = (int)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19277   void * jresult ;
19278   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19279   std::size_t arg2 ;
19280   Dali::Actor result;
19281
19282   arg1 = (Dali::HoverEvent *)jarg1;
19283   arg2 = (std::size_t)jarg2;
19284   {
19285     try {
19286       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19287     } catch (std::out_of_range& e) {
19288       {
19289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19290       };
19291     } catch (std::exception& e) {
19292       {
19293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (Dali::DaliException e) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19298       };
19299     } catch (...) {
19300       {
19301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19302       };
19303     }
19304   }
19305
19306   jresult = new Dali::Actor((const Dali::Actor &)result);
19307   return jresult;
19308 }
19309
19310
19311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19312   void * jresult ;
19313   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19314   std::size_t arg2 ;
19315   Dali::Vector2 *result = 0 ;
19316
19317   arg1 = (Dali::HoverEvent *)jarg1;
19318   arg2 = (std::size_t)jarg2;
19319   {
19320     try {
19321       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19322     } catch (std::out_of_range& e) {
19323       {
19324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19325       };
19326     } catch (std::exception& e) {
19327       {
19328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19329       };
19330     } catch (Dali::DaliException e) {
19331       {
19332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19333       };
19334     } catch (...) {
19335       {
19336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19337       };
19338     }
19339   }
19340
19341   jresult = (void *)result;
19342   return jresult;
19343 }
19344
19345
19346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19347   void * jresult ;
19348   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19349   std::size_t arg2 ;
19350   Dali::Vector2 *result = 0 ;
19351
19352   arg1 = (Dali::HoverEvent *)jarg1;
19353   arg2 = (std::size_t)jarg2;
19354   {
19355     try {
19356       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
19357     } CALL_CATCH_EXCEPTION(0);
19358   }
19359
19360   jresult = (void *)result;
19361   return jresult;
19362 }
19363
19364
19365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
19366   void * jresult ;
19367   Dali::KeyEvent *result = 0 ;
19368
19369   {
19370     try {
19371       result = (Dali::KeyEvent *)new Dali::KeyEvent();
19372     } CALL_CATCH_EXCEPTION(0);
19373   }
19374
19375   jresult = (void *)result;
19376   return jresult;
19377 }
19378
19379
19380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
19381   void * jresult ;
19382   Dali::KeyEvent *arg1 = 0 ;
19383   Dali::KeyEvent *result = 0 ;
19384
19385   arg1 = (Dali::KeyEvent *)jarg1;
19386   if (!arg1) {
19387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19388     return 0;
19389   }
19390   {
19391     try {
19392       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
19393     } CALL_CATCH_EXCEPTION(0);
19394   }
19395
19396   jresult = (void *)result;
19397   return jresult;
19398 }
19399
19400
19401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
19402   void * jresult ;
19403   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19404   Dali::KeyEvent *arg2 = 0 ;
19405   Dali::KeyEvent *result = 0 ;
19406
19407   arg1 = (Dali::KeyEvent *)jarg1;
19408   arg2 = (Dali::KeyEvent *)jarg2;
19409   if (!arg2) {
19410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19411     return 0;
19412   }
19413   {
19414     try {
19415       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
19416     } CALL_CATCH_EXCEPTION(0);
19417   }
19418
19419   jresult = (void *)result;
19420   return jresult;
19421 }
19422
19423
19424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
19425   void * jresult ;
19426   std::string *arg1 = 0 ;
19427   std::string *arg2 = 0 ;
19428   int arg3 ;
19429   int arg4 ;
19430   unsigned long arg5 ;
19431   Dali::KeyEvent::State *arg6 = 0 ;
19432   Dali::KeyEvent::State temp6 ;
19433   Dali::KeyEvent result;
19434
19435   if (!jarg1) {
19436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19437     return 0;
19438   }
19439   std::string arg1_str(jarg1);
19440   arg1 = &arg1_str;
19441   if (!jarg2) {
19442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19443     return 0;
19444   }
19445   std::string arg2_str(jarg2);
19446   arg2 = &arg2_str;
19447   arg3 = (int)jarg3;
19448   arg4 = (int)jarg4;
19449   arg5 = (unsigned long)jarg5;
19450   temp6 = (Dali::KeyEvent::State)jarg6;
19451   arg6 = &temp6;
19452   {
19453     try {
19454       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);
19455     } CALL_CATCH_EXCEPTION(0);
19456   }
19457
19458   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
19459
19460   //argout typemap for const std::string&
19461
19462
19463   //argout typemap for const std::string&
19464
19465   return jresult;
19466 }
19467
19468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
19469   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19470
19471   arg1 = (Dali::KeyEvent *)jarg1;
19472   {
19473     try {
19474       delete arg1;
19475     } CALL_CATCH_EXCEPTION();
19476   }
19477
19478 }
19479
19480
19481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
19482   unsigned int jresult ;
19483   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19484   bool result;
19485
19486   arg1 = (Dali::KeyEvent *)jarg1;
19487   {
19488     try {
19489       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
19490     } CALL_CATCH_EXCEPTION(0);
19491   }
19492
19493   jresult = result;
19494   return jresult;
19495 }
19496
19497
19498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(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)->IsCtrlModifier();
19507     } CALL_CATCH_EXCEPTION(0);
19508   }
19509
19510   jresult = result;
19511   return jresult;
19512 }
19513
19514
19515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(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)->IsAltModifier();
19524     } CALL_CATCH_EXCEPTION(0);
19525   }
19526
19527   jresult = result;
19528   return jresult;
19529 }
19530
19531
19532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
19533   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19534   std::string *arg2 = 0 ;
19535
19536   argp1 = (Dali::KeyEvent *) jarg1;
19537   if (!argp1) {
19538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19539     return ;
19540   }
19541
19542   Dali::KeyEvent arg1 = *argp1;
19543   if (!jarg2) {
19544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19545     return ;
19546   }
19547   std::string arg2_str(jarg2);
19548   arg2 = &arg2_str;
19549
19550   {
19551     try {
19552       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19553     } catch (std::out_of_range& e) {
19554       {
19555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19556       };
19557     } catch (std::exception& e) {
19558       {
19559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19560       };
19561     } catch (Dali::DaliException e) {
19562       {
19563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19564       };
19565     } catch (...) {
19566       {
19567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19568       };
19569     }
19570   }
19571 }
19572
19573
19574 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19575   char * jresult ;
19576
19577   if( jarg1 == NULL )
19578   {
19579     jresult = SWIG_csharp_string_callback( "" );
19580   }
19581   else
19582   {
19583     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19584     std::string *result = 0;
19585
19586     arg1 = ( Dali::KeyEvent * )jarg1;
19587     {
19588       try {
19589         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19590         result = (std::string *) &str;
19591       } catch (std::out_of_range& e) {
19592         {
19593           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19594         };
19595       } catch (std::exception& e) {
19596         {
19597           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19598         };
19599       } catch (Dali::DaliException e) {
19600         {
19601           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19602         };
19603       } catch (...) {
19604         {
19605           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19606         };
19607       }
19608     }
19609
19610     jresult = SWIG_csharp_string_callback(result->c_str());
19611   }
19612
19613   return jresult;
19614 }
19615
19616
19617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19618   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19619   std::string *arg2 = 0 ;
19620
19621   argp1 = (Dali::KeyEvent *) jarg1;
19622   if (!argp1) {
19623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19624     return ;
19625   }
19626
19627   Dali::KeyEvent arg1 = *argp1;
19628   if (!jarg2) {
19629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19630     return ;
19631   }
19632   std::string arg2_str(jarg2);
19633   arg2 = &arg2_str;
19634
19635   {
19636     try {
19637       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19638     } catch (std::out_of_range& e) {
19639       {
19640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19641       };
19642     } catch (std::exception& e) {
19643       {
19644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19645       };
19646     } catch (Dali::DaliException e) {
19647       {
19648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19649       };
19650     } catch (...) {
19651       {
19652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19653       };
19654     }
19655   }
19656 }
19657
19658
19659 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19660   char * jresult ;
19661
19662   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19663   std::string *result = 0;
19664
19665   arg1 = ( Dali::KeyEvent * )jarg1;
19666   {
19667     try {
19668       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19669       result = (std::string *) &str;
19670     } catch (std::out_of_range& e) {
19671       {
19672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19673       };
19674     } catch (std::exception& e) {
19675       {
19676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19677       };
19678     } catch (Dali::DaliException e) {
19679       {
19680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19681       };
19682     } catch (...) {
19683       {
19684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19685       };
19686     }
19687
19688     jresult = SWIG_csharp_string_callback(result->c_str());
19689   }
19690
19691   return jresult;
19692 }
19693
19694
19695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19696   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19697   int arg2 ;
19698
19699   argp1 = (Dali::KeyEvent *) jarg1;
19700   if (!argp1) {
19701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19702     return ;
19703   }
19704
19705   Dali::KeyEvent arg1 = *argp1;
19706   arg2 = (int)jarg2;
19707   {
19708     try {
19709       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19710     } catch (std::out_of_range& e) {
19711       {
19712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19713       };
19714     } catch (std::exception& e) {
19715       {
19716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19717       };
19718     } catch (Dali::DaliException e) {
19719       {
19720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19721       };
19722     } catch (...) {
19723       {
19724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19725       };
19726     }
19727   }
19728 }
19729
19730
19731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19732   int jresult ;
19733   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19734   int result;
19735
19736   arg1 = (Dali::KeyEvent *)jarg1;
19737   {
19738     try {
19739       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19740     } catch (std::out_of_range& e) {
19741       {
19742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19743       };
19744     } catch (std::exception& e) {
19745       {
19746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19747       };
19748     } catch (Dali::DaliException e) {
19749       {
19750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19751       };
19752     } catch (...) {
19753       {
19754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19755       };
19756     }
19757   }
19758
19759   jresult = result;
19760   return jresult;
19761 }
19762
19763
19764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19765   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19766   int arg2 ;
19767
19768   argp1 = (Dali::KeyEvent *) jarg1;
19769   if (!argp1) {
19770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19771     return ;
19772   }
19773
19774   Dali::KeyEvent arg1 = *argp1;
19775   arg2 = (int)jarg2;
19776   {
19777     try {
19778       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19779     } catch (std::out_of_range& e) {
19780       {
19781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19782       };
19783     } catch (std::exception& e) {
19784       {
19785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19786       };
19787     } catch (Dali::DaliException e) {
19788       {
19789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19790       };
19791     } catch (...) {
19792       {
19793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19794       };
19795     }
19796   }
19797 }
19798
19799
19800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19801   int jresult ;
19802   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19803   int result;
19804
19805   arg1 = (Dali::KeyEvent *)jarg1;
19806   {
19807     try {
19808       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19809     } catch (std::out_of_range& e) {
19810       {
19811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19812       };
19813     } catch (std::exception& e) {
19814       {
19815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19816       };
19817     } catch (Dali::DaliException e) {
19818       {
19819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19820       };
19821     } catch (...) {
19822       {
19823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19824       };
19825     }
19826   }
19827
19828   jresult = result;
19829   return jresult;
19830 }
19831
19832
19833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19834   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19835   unsigned long arg2 ;
19836
19837   argp1 = (Dali::KeyEvent *) jarg1;
19838   if (!argp1) {
19839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19840     return ;
19841   }
19842
19843   Dali::KeyEvent arg1 = *argp1;
19844   arg2 = (int)jarg2;
19845   {
19846     try {
19847       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19848     } catch (std::out_of_range& e) {
19849       {
19850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19851       };
19852     } catch (std::exception& e) {
19853       {
19854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19855       };
19856     } catch (Dali::DaliException e) {
19857       {
19858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19859       };
19860     } catch (...) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19863       };
19864     }
19865   }
19866 }
19867
19868
19869 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19870   unsigned long jresult ;
19871   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19872   unsigned long result;
19873
19874   arg1 = (Dali::KeyEvent *)jarg1;
19875   {
19876     try {
19877       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19878     } catch (std::out_of_range& e) {
19879       {
19880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19881       };
19882     } catch (std::exception& e) {
19883       {
19884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19885       };
19886     } catch (Dali::DaliException e) {
19887       {
19888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19889       };
19890     } catch (...) {
19891       {
19892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19893       };
19894     }
19895   }
19896
19897   jresult = result;
19898   return jresult;
19899 }
19900
19901
19902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19903   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19904   Dali::KeyEvent::State arg2;
19905
19906   argp1 = (Dali::KeyEvent *) jarg1;
19907   if (!argp1) {
19908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
19909     return ;
19910   }
19911
19912   Dali::KeyEvent arg1 = *argp1;
19913   arg2 = (Dali::KeyEvent::State)jarg2;
19914   {
19915     try {
19916       Dali::DevelKeyEvent::SetState(arg1, arg2);
19917     } catch (std::out_of_range& e) {
19918       {
19919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19920       };
19921     } catch (std::exception& e) {
19922       {
19923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19924       };
19925     } catch (Dali::DaliException e) {
19926       {
19927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19928       };
19929     } catch (...) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19932       };
19933     }
19934   }
19935 }
19936
19937
19938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19939   int jresult ;
19940   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19941   Dali::KeyEvent::State result;
19942
19943   arg1 = (Dali::KeyEvent *)jarg1;
19944   {
19945     try {
19946       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19947     } catch (std::out_of_range& e) {
19948       {
19949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19950       };
19951     } catch (std::exception& e) {
19952       {
19953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19954       };
19955     } catch (Dali::DaliException e) {
19956       {
19957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19958       };
19959     } catch (...) {
19960       {
19961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19962       };
19963     }
19964   }
19965
19966   jresult = (int)result;
19967   return jresult;
19968
19969 }
19970
19971 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19972   char * jresult ;
19973
19974   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19975   std::string *result = 0;
19976
19977   arg1 = ( Dali::KeyEvent * )jarg1;
19978   {
19979     try {
19980       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19981       result = (std::string *) &str;
19982     } CALL_CATCH_EXCEPTION(0);
19983
19984   }
19985
19986   jresult = SWIG_csharp_string_callback(result->c_str());
19987   return jresult;
19988 }
19989
19990
19991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
19992   void * jresult ;
19993   Dali::LongPressGestureDetector *result = 0 ;
19994
19995   {
19996     try {
19997       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
19998     } CALL_CATCH_EXCEPTION(0);
19999   }
20000
20001   jresult = (void *)result;
20002   return jresult;
20003 }
20004
20005
20006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20007   void * jresult ;
20008   Dali::LongPressGestureDetector result;
20009
20010   {
20011     try {
20012       result = Dali::LongPressGestureDetector::New();
20013     } CALL_CATCH_EXCEPTION(0);
20014   }
20015
20016   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20017   return jresult;
20018 }
20019
20020
20021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20022   void * jresult ;
20023   unsigned int arg1 ;
20024   Dali::LongPressGestureDetector result;
20025
20026   arg1 = (unsigned int)jarg1;
20027   {
20028     try {
20029       result = Dali::LongPressGestureDetector::New(arg1);
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_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20039   void * jresult ;
20040   unsigned int arg1 ;
20041   unsigned int arg2 ;
20042   Dali::LongPressGestureDetector result;
20043
20044   arg1 = (unsigned int)jarg1;
20045   arg2 = (unsigned int)jarg2;
20046   {
20047     try {
20048       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20049     } CALL_CATCH_EXCEPTION(0);
20050   }
20051
20052   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20053   return jresult;
20054 }
20055
20056
20057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20058   void * jresult ;
20059   Dali::BaseHandle arg1 ;
20060   Dali::BaseHandle *argp1 ;
20061   Dali::LongPressGestureDetector result;
20062
20063   argp1 = (Dali::BaseHandle *)jarg1;
20064   if (!argp1) {
20065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20066     return 0;
20067   }
20068   arg1 = *argp1;
20069   {
20070     try {
20071       result = Dali::LongPressGestureDetector::DownCast(arg1);
20072     } CALL_CATCH_EXCEPTION(0);
20073   }
20074
20075   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20076   return jresult;
20077 }
20078
20079
20080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20081   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20082
20083   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20084   {
20085     try {
20086       delete arg1;
20087     } CALL_CATCH_EXCEPTION();
20088   }
20089
20090 }
20091
20092
20093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20094   void * jresult ;
20095   Dali::LongPressGestureDetector *arg1 = 0 ;
20096   Dali::LongPressGestureDetector *result = 0 ;
20097
20098   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20099   if (!arg1) {
20100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20101     return 0;
20102   }
20103   {
20104     try {
20105       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20106     } CALL_CATCH_EXCEPTION(0);
20107   }
20108
20109   jresult = (void *)result;
20110   return jresult;
20111 }
20112
20113
20114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20115   void * jresult ;
20116   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20117   Dali::LongPressGestureDetector *arg2 = 0 ;
20118   Dali::LongPressGestureDetector *result = 0 ;
20119
20120   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20121   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20122   if (!arg2) {
20123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20124     return 0;
20125   }
20126   {
20127     try {
20128       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20129     } CALL_CATCH_EXCEPTION(0);
20130   }
20131
20132   jresult = (void *)result;
20133   return jresult;
20134 }
20135
20136
20137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20138   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20139   unsigned int arg2 ;
20140
20141   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20142   arg2 = (unsigned int)jarg2;
20143   {
20144     try {
20145       (arg1)->SetTouchesRequired(arg2);
20146     } CALL_CATCH_EXCEPTION();
20147   }
20148
20149 }
20150
20151
20152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20153   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20154   unsigned int arg2 ;
20155   unsigned int arg3 ;
20156
20157   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20158   arg2 = (unsigned int)jarg2;
20159   arg3 = (unsigned int)jarg3;
20160   {
20161     try {
20162       (arg1)->SetTouchesRequired(arg2,arg3);
20163     } CALL_CATCH_EXCEPTION();
20164   }
20165
20166 }
20167
20168
20169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20170   unsigned int jresult ;
20171   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20172   unsigned int result;
20173
20174   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20175   {
20176     try {
20177       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20178     } CALL_CATCH_EXCEPTION(0);
20179   }
20180
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20187   unsigned int jresult ;
20188   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20189   unsigned int result;
20190
20191   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20192   {
20193     try {
20194       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20195     } CALL_CATCH_EXCEPTION(0);
20196   }
20197
20198   jresult = result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20204   void * jresult ;
20205   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20206   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20207
20208   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20209   {
20210     try {
20211       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20212     } CALL_CATCH_EXCEPTION(0);
20213   }
20214
20215   jresult = (void *)result;
20216   return jresult;
20217 }
20218
20219
20220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
20221   void * jresult ;
20222   Dali::LongPressGesture *result = 0 ;
20223
20224   {
20225     try {
20226       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
20227     } CALL_CATCH_EXCEPTION(0);
20228   }
20229
20230   jresult = (void *)result;
20231   return jresult;
20232 }
20233
20234
20235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20236   void * jresult ;
20237   Dali::LongPressGesture *arg1 = 0 ;
20238   Dali::LongPressGesture *result = 0 ;
20239
20240   arg1 = (Dali::LongPressGesture *)jarg1;
20241   if (!arg1) {
20242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20243     return 0;
20244   }
20245   {
20246     try {
20247       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20248     } CALL_CATCH_EXCEPTION(0);
20249   }
20250
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20257   void * jresult ;
20258   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20259   Dali::LongPressGesture *arg2 = 0 ;
20260   Dali::LongPressGesture *result = 0 ;
20261
20262   arg1 = (Dali::LongPressGesture *)jarg1;
20263   arg2 = (Dali::LongPressGesture *)jarg2;
20264   if (!arg2) {
20265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20266     return 0;
20267   }
20268   {
20269     try {
20270       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20271     } CALL_CATCH_EXCEPTION(0);
20272   }
20273
20274   jresult = (void *)result;
20275   return jresult;
20276 }
20277
20278
20279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20280   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20281
20282   arg1 = (Dali::LongPressGesture *)jarg1;
20283   {
20284     try {
20285       delete arg1;
20286     } CALL_CATCH_EXCEPTION();
20287   }
20288
20289 }
20290
20291
20292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20293   unsigned int jresult ;
20294   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20295   unsigned int result;
20296
20297   arg1 = (Dali::LongPressGesture *)jarg1;
20298   result = (unsigned int) ((arg1)->GetNumberOfTouches());
20299   jresult = result;
20300   return jresult;
20301 }
20302
20303
20304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20305   void * jresult ;
20306   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20307   Dali::Vector2 result;
20308
20309   arg1 = (Dali::LongPressGesture *)jarg1;
20310   {
20311     try {
20312       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
20313     } catch (std::out_of_range& e) {
20314       {
20315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20316       };
20317     } catch (std::exception& e) {
20318       {
20319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20320       };
20321     } catch (Dali::DaliException e) {
20322       {
20323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20324       };
20325     } catch (...) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20328       };
20329     }
20330   }
20331   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20337   void * jresult ;
20338   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20339   Dali::Vector2 result;
20340
20341   arg1 = (Dali::LongPressGesture *)jarg1;
20342   {
20343     try {
20344       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
20345     } catch (std::out_of_range& e) {
20346       {
20347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20348       };
20349     } catch (std::exception& e) {
20350       {
20351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20352       };
20353     } catch (Dali::DaliException e) {
20354       {
20355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20356       };
20357     } catch (...) {
20358       {
20359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20360       };
20361     }
20362   }
20363   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20364   return jresult;
20365 }
20366
20367
20368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20369   void * jresult ;
20370   Dali::WheelEvent *result = 0 ;
20371
20372   {
20373     try {
20374       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20375     } CALL_CATCH_EXCEPTION(0);
20376   }
20377
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20384   void * jresult ;
20385   Dali::WheelEvent *arg1 = 0 ;
20386   Dali::WheelEvent *result = 0 ;
20387
20388   arg1 = (Dali::WheelEvent *)jarg1;
20389   if (!arg1) {
20390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20391     return 0;
20392   }
20393   {
20394     try {
20395       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20396     } catch (std::out_of_range& e) {
20397       {
20398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20399       };
20400     } catch (std::exception& e) {
20401       {
20402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20403       };
20404     } catch (Dali::DaliException e) {
20405       {
20406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20407       };
20408     } catch (...) {
20409       {
20410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20411       };
20412     }
20413   }
20414
20415   jresult = (void *)result;
20416   return jresult;
20417 }
20418
20419
20420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20421   void * jresult ;
20422   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20423   Dali::WheelEvent *arg2 = 0 ;
20424   Dali::WheelEvent *result = 0 ;
20425
20426   arg1 = (Dali::WheelEvent *)jarg1;
20427   arg2 = (Dali::WheelEvent *)jarg2;
20428   if (!arg2) {
20429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20430     return 0;
20431   }
20432   {
20433     try {
20434       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20435     } catch (std::out_of_range& e) {
20436       {
20437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20438       };
20439     } catch (std::exception& e) {
20440       {
20441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20442       };
20443     } catch (Dali::DaliException e) {
20444       {
20445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20446       };
20447     } catch (...) {
20448       {
20449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20450       };
20451     }
20452   }
20453
20454   jresult = (void *)result;
20455   return jresult;
20456 }
20457
20458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20459   void * jresult ;
20460   Dali::WheelEvent::Type arg1 ;
20461   int arg2 ;
20462   unsigned int arg3 ;
20463   Dali::Vector2 arg4 ;
20464   int arg5 ;
20465   unsigned int arg6 ;
20466   Dali::Vector2 *argp4 ;
20467   Dali::WheelEvent result;
20468
20469   arg1 = (Dali::WheelEvent::Type)jarg1;
20470   arg2 = (int)jarg2;
20471   arg3 = (unsigned int)jarg3;
20472   argp4 = (Dali::Vector2 *)jarg4;
20473   if (!argp4) {
20474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20475     return 0;
20476   }
20477   arg4 = *argp4;
20478   arg5 = (int)jarg5;
20479   arg6 = (unsigned int)jarg6;
20480   {
20481     try {
20482       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20483     } CALL_CATCH_EXCEPTION(0);
20484   }
20485
20486   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20487   return jresult;
20488 }
20489
20490
20491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20492   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20493
20494   arg1 = (Dali::WheelEvent *)jarg1;
20495   {
20496     try {
20497       delete arg1;
20498     } CALL_CATCH_EXCEPTION();
20499   }
20500
20501 }
20502
20503
20504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20505   unsigned int jresult ;
20506   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20507   bool result;
20508
20509   arg1 = (Dali::WheelEvent *)jarg1;
20510   {
20511     try {
20512       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20513     } CALL_CATCH_EXCEPTION(0);
20514   }
20515
20516   jresult = result;
20517   return jresult;
20518 }
20519
20520
20521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
20522   unsigned int jresult ;
20523   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20524   bool result;
20525
20526   arg1 = (Dali::WheelEvent *)jarg1;
20527   {
20528     try {
20529       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
20530     } catch (std::out_of_range& e) {
20531       {
20532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20533       };
20534     } catch (std::exception& e) {
20535       {
20536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20537       };
20538     } catch (Dali::DaliException e) {
20539       {
20540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20541       };
20542     } catch (...) {
20543       {
20544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20545       };
20546     }
20547   }
20548
20549   jresult = result;
20550   return jresult;
20551 }
20552
20553
20554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20555   unsigned int jresult ;
20556   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20557   bool result;
20558
20559   arg1 = (Dali::WheelEvent *)jarg1;
20560   {
20561     try {
20562       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20563     } catch (std::out_of_range& e) {
20564       {
20565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20566       };
20567     } catch (std::exception& e) {
20568       {
20569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20570       };
20571     } catch (Dali::DaliException e) {
20572       {
20573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20574       };
20575     } catch (...) {
20576       {
20577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20578       };
20579     }
20580   }
20581
20582   jresult = result;
20583   return jresult;
20584 }
20585
20586
20587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20588   int jresult ;
20589   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20590   Dali::WheelEvent::Type result;
20591
20592   arg1 = (Dali::WheelEvent *)jarg1;
20593   {
20594     try {
20595       result = ((Dali::WheelEvent const *)arg1)->GetType();
20596     } catch (std::out_of_range& e) {
20597       {
20598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20599       };
20600     } catch (std::exception& e) {
20601       {
20602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20603       };
20604     } catch (Dali::DaliException e) {
20605       {
20606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20607       };
20608     } catch (...) {
20609       {
20610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20611       };
20612     }
20613   }
20614
20615   jresult = (int)result;
20616   return jresult;
20617 }
20618
20619
20620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20621   int jresult ;
20622   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20623   int result;
20624
20625   arg1 = (Dali::WheelEvent *)jarg1;
20626   {
20627     try {
20628       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20629     } catch (std::out_of_range& e) {
20630       {
20631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (std::exception& e) {
20634       {
20635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20636       };
20637     } catch (Dali::DaliException e) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20640       };
20641     } catch (...) {
20642       {
20643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20644       };
20645     }
20646   }
20647
20648   jresult = result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20654   unsigned int jresult ;
20655   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20656   unsigned int result;
20657
20658   arg1 = (Dali::WheelEvent *)jarg1;
20659   {
20660     try {
20661       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20662     } CALL_CATCH_EXCEPTION(0);
20663   }
20664
20665   jresult = result;
20666   return jresult;
20667 }
20668
20669
20670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20671   void * jresult ;
20672   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20673   Dali::Vector2 *result = 0 ;
20674
20675   arg1 = (Dali::WheelEvent *)jarg1;
20676   {
20677     try {
20678       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20679     } CALL_CATCH_EXCEPTION(0);
20680   }
20681
20682   jresult = (void *)result;
20683   return jresult;
20684 }
20685
20686
20687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20688   int jresult ;
20689   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20690   int result;
20691
20692   arg1 = (Dali::WheelEvent *)jarg1;
20693   {
20694     try {
20695       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20721   unsigned int jresult ;
20722   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20723   unsigned int result;
20724
20725   arg1 = (Dali::WheelEvent *)jarg1;
20726   {
20727     try {
20728       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20729     } catch (std::out_of_range& e) {
20730       {
20731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20732       };
20733     } catch (std::exception& e) {
20734       {
20735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20736       };
20737     } catch (Dali::DaliException e) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20740       };
20741     } catch (...) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20744       };
20745     }
20746   }
20747
20748   jresult = result;
20749   return jresult;
20750 }
20751
20752 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20753   char * jresult ;
20754   Dali::KeyEvent *arg1 = 0 ;
20755   std::string result;
20756
20757   arg1 = (Dali::KeyEvent *)jarg1;
20758   if (!arg1) {
20759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20760     return 0;
20761   }
20762   {
20763     try {
20764       result = arg1->GetDeviceName();
20765     } CALL_CATCH_EXCEPTION(0);
20766   }
20767
20768   jresult = SWIG_csharp_string_callback((&result)->c_str());
20769   return jresult;
20770 }
20771
20772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20773   int jresult ;
20774   Dali::KeyEvent *arg1 = 0 ;
20775   Dali::Device::Class::Type result;
20776
20777   arg1 = (Dali::KeyEvent *)jarg1;
20778   if (!arg1) {
20779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20780     return 0;
20781   }
20782   {
20783     try {
20784       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20785     } CALL_CATCH_EXCEPTION(0);
20786   }
20787
20788   jresult = (int)result;
20789   return jresult;
20790 }
20791
20792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20793   int jresult ;
20794   Dali::KeyEvent *arg1 = 0 ;
20795   Dali::Device::Subclass::Type result;
20796
20797   arg1 = (Dali::KeyEvent *)jarg1;
20798   if (!arg1) {
20799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20800     return 0;
20801   }
20802   {
20803     try {
20804       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20805     } CALL_CATCH_EXCEPTION(0);
20806   }
20807
20808   jresult = (int)result;
20809   return jresult;
20810 }
20811
20812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(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.Raise();
20825     } CALL_CATCH_EXCEPTION();
20826   }
20827
20828 }
20829
20830
20831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(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.Lower();
20844     } CALL_CATCH_EXCEPTION();
20845   }
20846
20847 }
20848
20849
20850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(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.RaiseToTop();
20863     } CALL_CATCH_EXCEPTION();
20864   }
20865
20866 }
20867
20868
20869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20870   Dali::Actor arg1 ;
20871   Dali::Actor *argp1 ;
20872
20873   argp1 = (Dali::Actor *)jarg1;
20874   if (!argp1) {
20875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20876     return ;
20877   }
20878   arg1 = *argp1;
20879   {
20880     try {
20881       arg1.LowerToBottom();
20882     } CALL_CATCH_EXCEPTION();
20883   }
20884
20885 }
20886
20887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20888   Dali::Actor arg1 ;
20889   Dali::Actor arg2 ;
20890   Dali::Actor *argp1 ;
20891   Dali::Actor *argp2 ;
20892
20893   argp1 = (Dali::Actor *)jarg1;
20894   if (!argp1) {
20895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20896     return ;
20897   }
20898   arg1 = *argp1;
20899   argp2 = (Dali::Actor *)jarg2;
20900   if (!argp2) {
20901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20902     return ;
20903   }
20904   arg2 = *argp2;
20905   {
20906     try {
20907       arg1.RaiseAbove(arg2);
20908     } CALL_CATCH_EXCEPTION();
20909   }
20910
20911 }
20912
20913
20914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20915   Dali::Actor arg1 ;
20916   Dali::Actor arg2 ;
20917   Dali::Actor *argp1 ;
20918   Dali::Actor *argp2 ;
20919
20920   argp1 = (Dali::Actor *)jarg1;
20921   if (!argp1) {
20922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20923     return ;
20924   }
20925   arg1 = *argp1;
20926   argp2 = (Dali::Actor *)jarg2;
20927   if (!argp2) {
20928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20929     return ;
20930   }
20931   arg2 = *argp2;
20932   {
20933     try {
20934       arg1.LowerBelow(arg2);
20935     } CALL_CATCH_EXCEPTION();
20936   }
20937
20938 }
20939
20940
20941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20942   void * jresult ;
20943   Dali::Actor arg1 ;
20944   Dali::Actor *argp1 ;
20945   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20946
20947   argp1 = (Dali::Actor *)jarg1;
20948   if (!argp1) {
20949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20950     return 0;
20951   }
20952   arg1 = *argp1;
20953   {
20954     try {
20955       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20956     } CALL_CATCH_EXCEPTION(0);
20957   }
20958
20959   jresult = (void *)result;
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20965   void * jresult ;
20966   Dali::Actor *arg1 ;
20967   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20968
20969   arg1 = (Dali::Actor *)jarg1;
20970   {
20971     try {
20972       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20973     } CALL_CATCH_EXCEPTION(0);
20974   }
20975
20976   jresult = (void *)result;
20977   return jresult;
20978 }
20979
20980
20981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20982   int jresult ;
20983   int result;
20984
20985   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20986   jresult = (int)result;
20987   return jresult;
20988 }
20989
20990
20991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20992   int jresult ;
20993   int result;
20994
20995   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
20996   jresult = (int)result;
20997   return jresult;
20998 }
20999
21000
21001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
21002   int jresult ;
21003   int result;
21004
21005   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
21006   jresult = (int)result;
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
21012   int jresult ;
21013   int result;
21014
21015   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
21016   jresult = (int)result;
21017   return jresult;
21018 }
21019
21020
21021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21022   int jresult ;
21023   int result;
21024
21025   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21026   jresult = (int)result;
21027   return jresult;
21028 }
21029
21030
21031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21032   int jresult ;
21033   int result;
21034
21035   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21036   jresult = (int)result;
21037   return jresult;
21038 }
21039
21040
21041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21042   int jresult ;
21043   int result;
21044
21045   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21046   jresult = (int)result;
21047   return jresult;
21048 }
21049
21050
21051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21052   int jresult ;
21053   int result;
21054
21055   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21056   jresult = (int)result;
21057   return jresult;
21058 }
21059
21060
21061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21062   int jresult ;
21063   int result;
21064
21065   result = (int)Dali::Actor::Property::SIZE;
21066   jresult = (int)result;
21067   return jresult;
21068 }
21069
21070
21071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21072   int jresult ;
21073   int result;
21074
21075   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21076   jresult = (int)result;
21077   return jresult;
21078 }
21079
21080
21081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21082   int jresult ;
21083   int result;
21084
21085   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21086   jresult = (int)result;
21087   return jresult;
21088 }
21089
21090
21091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21092   int jresult ;
21093   int result;
21094
21095   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21096   jresult = (int)result;
21097   return jresult;
21098 }
21099
21100
21101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21102   int jresult ;
21103   int result;
21104
21105   result = (int)Dali::Actor::Property::POSITION;
21106   jresult = (int)result;
21107   return jresult;
21108 }
21109
21110
21111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21112   int jresult ;
21113   int result;
21114
21115   result = (int)Dali::Actor::Property::POSITION_X;
21116   jresult = (int)result;
21117   return jresult;
21118 }
21119
21120
21121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21122   int jresult ;
21123   int result;
21124
21125   result = (int)Dali::Actor::Property::POSITION_Y;
21126   jresult = (int)result;
21127   return jresult;
21128 }
21129
21130
21131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21132   int jresult ;
21133   int result;
21134
21135   result = (int)Dali::Actor::Property::POSITION_Z;
21136   jresult = (int)result;
21137   return jresult;
21138 }
21139
21140
21141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21142   int jresult ;
21143   int result;
21144
21145   result = (int)Dali::Actor::Property::WORLD_POSITION;
21146   jresult = (int)result;
21147   return jresult;
21148 }
21149
21150
21151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21152   int jresult ;
21153   int result;
21154
21155   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21156   jresult = (int)result;
21157   return jresult;
21158 }
21159
21160
21161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21162   int jresult ;
21163   int result;
21164
21165   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21166   jresult = (int)result;
21167   return jresult;
21168 }
21169
21170
21171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21172   int jresult ;
21173   int result;
21174
21175   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21176   jresult = (int)result;
21177   return jresult;
21178 }
21179
21180
21181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21182   int jresult ;
21183   int result;
21184
21185   result = (int)Dali::Actor::Property::ORIENTATION;
21186   jresult = (int)result;
21187   return jresult;
21188 }
21189
21190
21191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21192   int jresult ;
21193   int result;
21194
21195   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21196   jresult = (int)result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21202   int jresult ;
21203   int result;
21204
21205   result = (int)Dali::Actor::Property::SCALE;
21206   jresult = (int)result;
21207   return jresult;
21208 }
21209
21210
21211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21212   int jresult ;
21213   int result;
21214
21215   result = (int)Dali::Actor::Property::SCALE_X;
21216   jresult = (int)result;
21217   return jresult;
21218 }
21219
21220
21221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21222   int jresult ;
21223   int result;
21224
21225   result = (int)Dali::Actor::Property::SCALE_Y;
21226   jresult = (int)result;
21227   return jresult;
21228 }
21229
21230
21231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21232   int jresult ;
21233   int result;
21234
21235   result = (int)Dali::Actor::Property::SCALE_Z;
21236   jresult = (int)result;
21237   return jresult;
21238 }
21239
21240
21241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21242   int jresult ;
21243   int result;
21244
21245   result = (int)Dali::Actor::Property::WORLD_SCALE;
21246   jresult = (int)result;
21247   return jresult;
21248 }
21249
21250
21251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21252   int jresult ;
21253   int result;
21254
21255   result = (int)Dali::Actor::Property::VISIBLE;
21256   jresult = (int)result;
21257   return jresult;
21258 }
21259
21260
21261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21262   int jresult ;
21263   int result;
21264
21265   result = (int)Dali::Actor::Property::COLOR;
21266   jresult = (int)result;
21267   return jresult;
21268 }
21269
21270
21271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21272   int jresult ;
21273   int result;
21274
21275   result = (int)Dali::Actor::Property::COLOR_RED;
21276   jresult = (int)result;
21277   return jresult;
21278 }
21279
21280
21281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21282   int jresult ;
21283   int result;
21284
21285   result = (int)Dali::Actor::Property::COLOR_GREEN;
21286   jresult = (int)result;
21287   return jresult;
21288 }
21289
21290
21291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21292   int jresult ;
21293   int result;
21294
21295   result = (int)Dali::Actor::Property::COLOR_BLUE;
21296   jresult = (int)result;
21297   return jresult;
21298 }
21299
21300
21301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21302   int jresult ;
21303   int result;
21304
21305   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21306   jresult = (int)result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21312   int jresult ;
21313   int result;
21314
21315   result = (int)Dali::Actor::Property::WORLD_COLOR;
21316   jresult = (int)result;
21317   return jresult;
21318 }
21319
21320
21321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21322   int jresult ;
21323   int result;
21324
21325   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21326   jresult = (int)result;
21327   return jresult;
21328 }
21329
21330
21331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21332   int jresult ;
21333   int result;
21334
21335   result = (int)Dali::Actor::Property::NAME;
21336   jresult = (int)result;
21337   return jresult;
21338 }
21339
21340
21341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21342   int jresult ;
21343   int result;
21344
21345   result = (int)Dali::Actor::Property::SENSITIVE;
21346   jresult = (int)result;
21347   return jresult;
21348 }
21349
21350
21351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21352   int jresult ;
21353   int result;
21354
21355   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21356   jresult = (int)result;
21357   return jresult;
21358 }
21359
21360
21361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21362   int jresult ;
21363   int result;
21364
21365   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21366   jresult = (int)result;
21367   return jresult;
21368 }
21369
21370
21371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21372   int jresult ;
21373   int result;
21374
21375   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21376   jresult = (int)result;
21377   return jresult;
21378 }
21379
21380
21381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21382   int jresult ;
21383   int result;
21384
21385   result = (int)Dali::Actor::Property::COLOR_MODE;
21386   jresult = (int)result;
21387   return jresult;
21388 }
21389
21390
21391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21392   int jresult ;
21393   int result;
21394
21395   result = (int)Dali::Actor::Property::DRAW_MODE;
21396   jresult = (int)result;
21397   return jresult;
21398 }
21399
21400
21401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21402   int jresult ;
21403   int result;
21404
21405   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21406   jresult = (int)result;
21407   return jresult;
21408 }
21409
21410
21411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21412   int jresult ;
21413   int result;
21414
21415   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21416   jresult = (int)result;
21417   return jresult;
21418 }
21419
21420
21421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21422   int jresult ;
21423   int result;
21424
21425   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21426   jresult = (int)result;
21427   return jresult;
21428 }
21429
21430
21431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21432   int jresult ;
21433   int result;
21434
21435   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21436   jresult = (int)result;
21437   return jresult;
21438 }
21439
21440
21441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21442   int jresult ;
21443   int result;
21444
21445   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21446   jresult = (int)result;
21447   return jresult;
21448 }
21449
21450
21451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21452   int jresult ;
21453   int result;
21454
21455   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21456   jresult = (int)result;
21457   return jresult;
21458 }
21459
21460
21461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21462   int jresult ;
21463   int result;
21464
21465   result = (int)Dali::Actor::Property::PADDING;
21466   jresult = (int)result;
21467   return jresult;
21468 }
21469
21470
21471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21472   int jresult ;
21473   int result;
21474
21475   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21476   jresult = (int)result;
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21482   int jresult ;
21483   int result;
21484
21485   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21486   jresult = (int)result;
21487   return jresult;
21488 }
21489
21490
21491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21492   int jresult ;
21493   int result;
21494
21495   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21496   jresult = (int)result;
21497   return jresult;
21498 }
21499
21500
21501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21502   int jresult ;
21503   int result;
21504
21505   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21506   jresult = (int)result;
21507   return jresult;
21508 }
21509
21510 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21511
21512   return Dali::Actor::Property::OPACITY;
21513 }
21514
21515 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21516
21517   return Dali::Actor::Property::SCREEN_POSITION;
21518 }
21519
21520 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21521
21522   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21523 }
21524
21525 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21526   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21527 }
21528
21529 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21530   return Dali::Actor::Property::LAYOUT_DIRECTION;
21531 }
21532
21533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21534   void * jresult ;
21535   Dali::Actor::Property *result = 0 ;
21536
21537   {
21538     try {
21539       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21540     } CALL_CATCH_EXCEPTION(0);
21541   }
21542
21543   jresult = (void *)result;
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21549   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21550
21551   arg1 = (Dali::Actor::Property *)jarg1;
21552   {
21553     try {
21554       delete arg1;
21555     } CALL_CATCH_EXCEPTION();
21556   }
21557
21558 }
21559
21560
21561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21562   void * jresult ;
21563   Dali::Actor *result = 0 ;
21564
21565   {
21566     try {
21567       result = (Dali::Actor *)new Dali::Actor();
21568     } CALL_CATCH_EXCEPTION(0);
21569   }
21570
21571   jresult = (void *)result;
21572   return jresult;
21573 }
21574
21575
21576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21577   void * jresult ;
21578   Dali::Actor result;
21579
21580   {
21581     try {
21582       result = Dali::Actor::New();
21583     } CALL_CATCH_EXCEPTION(0);
21584   }
21585
21586   jresult = new Dali::Actor((const Dali::Actor &)result);
21587   return jresult;
21588 }
21589
21590
21591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21592   void * jresult ;
21593   Dali::BaseHandle arg1 ;
21594   Dali::BaseHandle *argp1 ;
21595   Dali::Actor result;
21596
21597   argp1 = (Dali::BaseHandle *)jarg1;
21598   if (!argp1) {
21599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21600     return 0;
21601   }
21602   arg1 = *argp1;
21603   {
21604     try {
21605       result = Dali::Actor::DownCast(arg1);
21606     } CALL_CATCH_EXCEPTION(0);
21607   }
21608
21609   jresult = new Dali::Actor((const Dali::Actor &)result);
21610   return jresult;
21611 }
21612
21613
21614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21616
21617   arg1 = (Dali::Actor *)jarg1;
21618   {
21619     try {
21620       delete arg1;
21621     } CALL_CATCH_EXCEPTION();
21622   }
21623
21624 }
21625
21626
21627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21628   void * jresult ;
21629   Dali::Actor *arg1 = 0 ;
21630   Dali::Actor *result = 0 ;
21631
21632   arg1 = (Dali::Actor *)jarg1;
21633   if (!arg1) {
21634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21635     return 0;
21636   }
21637   {
21638     try {
21639       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21640     } CALL_CATCH_EXCEPTION(0);
21641   }
21642
21643   jresult = (void *)result;
21644   return jresult;
21645 }
21646
21647
21648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21649   void * jresult ;
21650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21651   Dali::Actor *arg2 = 0 ;
21652   Dali::Actor *result = 0 ;
21653
21654   arg1 = (Dali::Actor *)jarg1;
21655   arg2 = (Dali::Actor *)jarg2;
21656   if (!arg2) {
21657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21658     return 0;
21659   }
21660   {
21661     try {
21662       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21663     } CALL_CATCH_EXCEPTION(0);
21664   }
21665
21666   jresult = (void *)result;
21667   return jresult;
21668 }
21669
21670
21671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21672   char * jresult ;
21673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21674   std::string *result = 0 ;
21675   std::string name = "";
21676
21677   arg1 = (Dali::Actor *)jarg1;
21678   {
21679     try {
21680       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21681       result = (std::string *) &name;
21682       jresult = SWIG_csharp_string_callback(result->c_str());
21683     } CALL_CATCH_EXCEPTION(0);
21684   }
21685   return jresult;
21686 }
21687
21688
21689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21691   std::string *arg2 = 0 ;
21692
21693   arg1 = (Dali::Actor *)jarg1;
21694   if (!jarg2) {
21695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21696     return ;
21697   }
21698   std::string arg2_str(jarg2);
21699   arg2 = &arg2_str;
21700   {
21701     try {
21702       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21703     } CALL_CATCH_EXCEPTION();
21704   }
21705
21706
21707   //argout typemap for const std::string&
21708
21709 }
21710
21711
21712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21713   unsigned int jresult ;
21714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21715   unsigned int result;
21716
21717   arg1 = (Dali::Actor *)jarg1;
21718
21719   if(!arg1) {
21720     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21721     return -1;
21722   }
21723
21724   {
21725     try {
21726       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21727     } CALL_CATCH_EXCEPTION(0);
21728   }
21729
21730   jresult = result;
21731   return jresult;
21732 }
21733
21734
21735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21736   unsigned int jresult ;
21737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21738   bool result;
21739
21740   arg1 = (Dali::Actor *)jarg1;
21741   {
21742     try {
21743       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21744     } CALL_CATCH_EXCEPTION(0);
21745   }
21746
21747   jresult = result;
21748   return jresult;
21749 }
21750
21751
21752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
21753   unsigned int jresult ;
21754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21755   bool result;
21756
21757   arg1 = (Dali::Actor *)jarg1;
21758   {
21759     try {
21760       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
21761     } CALL_CATCH_EXCEPTION(0);
21762   }
21763
21764   jresult = result;
21765   return jresult;
21766 }
21767
21768
21769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
21770   unsigned int jresult ;
21771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21772   bool result;
21773
21774   arg1 = (Dali::Actor *)jarg1;
21775   {
21776     try {
21777       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
21778     } CALL_CATCH_EXCEPTION(0);
21779   }
21780
21781   jresult = result;
21782   return jresult;
21783 }
21784
21785
21786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21787   void * jresult ;
21788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21789   Dali::Layer result;
21790
21791   arg1 = (Dali::Actor *)jarg1;
21792   {
21793     try {
21794       result = (arg1)->GetLayer();
21795     } CALL_CATCH_EXCEPTION(0);
21796   }
21797
21798   jresult = new Dali::Layer((const Dali::Layer &)result);
21799   return jresult;
21800 }
21801
21802
21803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21805   Dali::Actor arg2 ;
21806   Dali::Actor *argp2 ;
21807
21808   arg1 = (Dali::Actor *)jarg1;
21809   argp2 = (Dali::Actor *)jarg2;
21810   if (!argp2) {
21811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21812     return ;
21813   }
21814   arg2 = *argp2;
21815   {
21816     try {
21817       (arg1)->Add(arg2);
21818     } CALL_CATCH_EXCEPTION();
21819   }
21820
21821 }
21822
21823
21824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21826   Dali::Actor arg2 ;
21827   Dali::Actor *argp2 ;
21828
21829   arg1 = (Dali::Actor *)jarg1;
21830   argp2 = (Dali::Actor *)jarg2;
21831   if (!argp2) {
21832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21833     return ;
21834   }
21835   arg2 = *argp2;
21836   {
21837     try {
21838       (arg1)->Remove(arg2);
21839     } CALL_CATCH_EXCEPTION();
21840   }
21841
21842 }
21843
21844
21845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21847
21848   arg1 = (Dali::Actor *)jarg1;
21849   {
21850     try {
21851       (arg1)->Unparent();
21852     } CALL_CATCH_EXCEPTION();
21853   }
21854
21855 }
21856
21857
21858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21859   unsigned int jresult ;
21860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21861   unsigned int result;
21862
21863   arg1 = (Dali::Actor *)jarg1;
21864   {
21865     try {
21866       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21867     } CALL_CATCH_EXCEPTION(0);
21868   }
21869
21870   jresult = result;
21871   return jresult;
21872 }
21873
21874
21875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21876   void * jresult ;
21877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21878   unsigned int arg2 ;
21879   Dali::Actor result;
21880
21881   arg1 = (Dali::Actor *)jarg1;
21882   arg2 = (unsigned int)jarg2;
21883   {
21884     try {
21885       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21886     } CALL_CATCH_EXCEPTION(0);
21887   }
21888
21889   jresult = new Dali::Actor((const Dali::Actor &)result);
21890   return jresult;
21891 }
21892
21893
21894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21895   void * jresult ;
21896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21897   std::string *arg2 = 0 ;
21898   Dali::Actor result;
21899
21900   arg1 = (Dali::Actor *)jarg1;
21901   if (!jarg2) {
21902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21903     return 0;
21904   }
21905   std::string arg2_str(jarg2);
21906   arg2 = &arg2_str;
21907   {
21908     try {
21909       result = (arg1)->FindChildByName((std::string const &)*arg2);
21910     } CALL_CATCH_EXCEPTION(0);
21911   }
21912
21913   jresult = new Dali::Actor((const Dali::Actor &)result);
21914
21915   //argout typemap for const std::string&
21916
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21922   void * jresult ;
21923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21924   unsigned int arg2 ;
21925   Dali::Actor result;
21926
21927   arg1 = (Dali::Actor *)jarg1;
21928   arg2 = (unsigned int)jarg2;
21929   {
21930     try {
21931       result = (arg1)->FindChildById(arg2);
21932     } CALL_CATCH_EXCEPTION(0);
21933   }
21934
21935   jresult = new Dali::Actor((const Dali::Actor &)result);
21936   return jresult;
21937 }
21938
21939
21940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21941   void * jresult ;
21942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21943   Dali::Actor result;
21944
21945   arg1 = (Dali::Actor *)jarg1;
21946   {
21947     try {
21948       result = ((Dali::Actor const *)arg1)->GetParent();
21949     } CALL_CATCH_EXCEPTION(0);
21950   }
21951
21952   jresult = new Dali::Actor((const Dali::Actor &)result);
21953   return jresult;
21954 }
21955
21956
21957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
21958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21959   Dali::Vector3 *arg2 = 0 ;
21960
21961   arg1 = (Dali::Actor *)jarg1;
21962   arg2 = (Dali::Vector3 *)jarg2;
21963   if (!arg2) {
21964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21965     return ;
21966   }
21967   {
21968     try {
21969       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21970     } CALL_CATCH_EXCEPTION();
21971   }
21972
21973 }
21974
21975
21976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21977   void * jresult ;
21978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21979   Dali::Vector3 result;
21980
21981   arg1 = (Dali::Actor *)jarg1;
21982   {
21983     try {
21984       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21985     } CALL_CATCH_EXCEPTION(0);
21986   }
21987
21988   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21989   return jresult;
21990 }
21991
21992
21993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
21994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21995   Dali::Vector3 *arg2 = 0 ;
21996
21997   arg1 = (Dali::Actor *)jarg1;
21998   arg2 = (Dali::Vector3 *)jarg2;
21999   if (!arg2) {
22000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22001     return ;
22002   }
22003   {
22004     try {
22005       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22006     } CALL_CATCH_EXCEPTION();
22007   }
22008
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22013   void * jresult ;
22014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22015   Dali::Vector3 result;
22016
22017   arg1 = (Dali::Actor *)jarg1;
22018   {
22019     try {
22020       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22021     } CALL_CATCH_EXCEPTION(0);
22022   }
22023
22024   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22025   return jresult;
22026 }
22027
22028
22029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22031   float arg2 ;
22032   float arg3 ;
22033
22034   arg1 = (Dali::Actor *)jarg1;
22035   arg2 = (float)jarg2;
22036   arg3 = (float)jarg3;
22037   {
22038     try {
22039       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22040     } CALL_CATCH_EXCEPTION();
22041   }
22042
22043 }
22044
22045
22046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22048   float arg2 ;
22049   float arg3 ;
22050   float arg4 ;
22051
22052   arg1 = (Dali::Actor *)jarg1;
22053   arg2 = (float)jarg2;
22054   arg3 = (float)jarg3;
22055   arg4 = (float)jarg4;
22056   {
22057     try {
22058       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22059     } CALL_CATCH_EXCEPTION();
22060   }
22061
22062 }
22063
22064
22065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22067   Dali::Vector2 *arg2 = 0 ;
22068
22069   arg1 = (Dali::Actor *)jarg1;
22070   arg2 = (Dali::Vector2 *)jarg2;
22071   if (!arg2) {
22072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22073     return ;
22074   }
22075   {
22076     try {
22077       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22078     } CALL_CATCH_EXCEPTION();
22079   }
22080
22081 }
22082
22083
22084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22086   Dali::Vector3 *arg2 = 0 ;
22087
22088   arg1 = (Dali::Actor *)jarg1;
22089   arg2 = (Dali::Vector3 *)jarg2;
22090   if (!arg2) {
22091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22092     return ;
22093   }
22094   {
22095     try {
22096       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22097     } CALL_CATCH_EXCEPTION();
22098   }
22099
22100 }
22101
22102
22103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22104   void * jresult ;
22105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22106   Dali::Vector3 result;
22107
22108   arg1 = (Dali::Actor *)jarg1;
22109   {
22110     try {
22111       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22112     } CALL_CATCH_EXCEPTION(0);
22113   }
22114
22115   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22116   return jresult;
22117 }
22118
22119
22120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22121   void * jresult ;
22122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22123   Dali::Vector3 result;
22124
22125   arg1 = (Dali::Actor *)jarg1;
22126   {
22127     try {
22128       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22129     } CALL_CATCH_EXCEPTION(0);
22130   }
22131
22132   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22138   void * jresult ;
22139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22140   Dali::Vector3 result;
22141
22142   arg1 = (Dali::Actor *)jarg1;
22143   {
22144     try {
22145       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22146     } CALL_CATCH_EXCEPTION(0);
22147   }
22148
22149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22150   return jresult;
22151 }
22152
22153
22154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22156   float arg2 ;
22157   float arg3 ;
22158
22159   arg1 = (Dali::Actor *)jarg1;
22160   arg2 = (float)jarg2;
22161   arg3 = (float)jarg3;
22162   {
22163     try {
22164       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22165     } CALL_CATCH_EXCEPTION();
22166   }
22167
22168 }
22169
22170
22171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22172   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22173   float arg2 ;
22174   float arg3 ;
22175   float arg4 ;
22176
22177   arg1 = (Dali::Actor *)jarg1;
22178   arg2 = (float)jarg2;
22179   arg3 = (float)jarg3;
22180   arg4 = (float)jarg4;
22181   {
22182     try {
22183       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22184     } CALL_CATCH_EXCEPTION();
22185   }
22186
22187 }
22188
22189
22190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22192   Dali::Vector3 *arg2 = 0 ;
22193
22194   arg1 = (Dali::Actor *)jarg1;
22195   arg2 = (Dali::Vector3 *)jarg2;
22196   if (!arg2) {
22197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22198     return ;
22199   }
22200   {
22201     try {
22202       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22203     } CALL_CATCH_EXCEPTION();
22204   }
22205
22206 }
22207
22208
22209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22211   float arg2 ;
22212
22213   arg1 = (Dali::Actor *)jarg1;
22214   arg2 = (float)jarg2;
22215   {
22216     try {
22217       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22218     } CALL_CATCH_EXCEPTION();
22219   }
22220
22221 }
22222
22223
22224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22226   float arg2 ;
22227
22228   arg1 = (Dali::Actor *)jarg1;
22229   arg2 = (float)jarg2;
22230   {
22231     try {
22232       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22233     } CALL_CATCH_EXCEPTION();
22234   }
22235
22236 }
22237
22238
22239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22241   float arg2 ;
22242
22243   arg1 = (Dali::Actor *)jarg1;
22244   arg2 = (float)jarg2;
22245   {
22246     try {
22247       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22248     } CALL_CATCH_EXCEPTION();
22249   }
22250
22251 }
22252
22253
22254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22256   Dali::Vector3 *arg2 = 0 ;
22257
22258   arg1 = (Dali::Actor *)jarg1;
22259   arg2 = (Dali::Vector3 *)jarg2;
22260   if (!arg2) {
22261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22262     return ;
22263   }
22264   {
22265     try {
22266       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22267     } CALL_CATCH_EXCEPTION();
22268   }
22269
22270 }
22271
22272
22273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22274   void * jresult ;
22275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22276   Dali::Vector3 result;
22277
22278   arg1 = (Dali::Actor *)jarg1;
22279   {
22280     try {
22281       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22282     } CALL_CATCH_EXCEPTION(0);
22283   }
22284
22285   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22286   return jresult;
22287 }
22288
22289
22290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22291   void * jresult ;
22292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22293   Dali::Vector3 result;
22294
22295   arg1 = (Dali::Actor *)jarg1;
22296   {
22297     try {
22298       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22299     } CALL_CATCH_EXCEPTION(0);
22300   }
22301
22302   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22303   return jresult;
22304 }
22305
22306
22307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22309   bool arg2 ;
22310
22311   arg1 = (Dali::Actor *)jarg1;
22312   arg2 = jarg2 ? true : false;
22313   {
22314     try {
22315       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22316     } CALL_CATCH_EXCEPTION();
22317   }
22318
22319 }
22320
22321
22322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22323   unsigned int jresult ;
22324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22325   bool result;
22326
22327   arg1 = (Dali::Actor *)jarg1;
22328   {
22329     try {
22330       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22331     } CALL_CATCH_EXCEPTION(0);
22332   }
22333
22334   jresult = result;
22335   return jresult;
22336 }
22337
22338
22339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22341   Dali::Degree *arg2 = 0 ;
22342   Dali::Vector3 *arg3 = 0 ;
22343
22344   arg1 = (Dali::Actor *)jarg1;
22345   arg2 = (Dali::Degree *)jarg2;
22346   if (!arg2) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22348     return ;
22349   }
22350   arg3 = (Dali::Vector3 *)jarg3;
22351   if (!arg3) {
22352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22353     return ;
22354   }
22355   {
22356     try {
22357       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22358     } CALL_CATCH_EXCEPTION();
22359   }
22360
22361 }
22362
22363
22364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22366   Dali::Radian *arg2 = 0 ;
22367   Dali::Vector3 *arg3 = 0 ;
22368
22369   arg1 = (Dali::Actor *)jarg1;
22370   arg2 = (Dali::Radian *)jarg2;
22371   if (!arg2) {
22372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22373     return ;
22374   }
22375   arg3 = (Dali::Vector3 *)jarg3;
22376   if (!arg3) {
22377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22378     return ;
22379   }
22380   {
22381     try {
22382       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22383     } CALL_CATCH_EXCEPTION();
22384   }
22385
22386 }
22387
22388
22389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22391   Dali::Quaternion *arg2 = 0 ;
22392
22393   arg1 = (Dali::Actor *)jarg1;
22394   arg2 = (Dali::Quaternion *)jarg2;
22395   if (!arg2) {
22396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22397     return ;
22398   }
22399   {
22400     try {
22401       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22402     } CALL_CATCH_EXCEPTION();
22403   }
22404
22405 }
22406
22407
22408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22410   Dali::Degree *arg2 = 0 ;
22411   Dali::Vector3 *arg3 = 0 ;
22412
22413   arg1 = (Dali::Actor *)jarg1;
22414   arg2 = (Dali::Degree *)jarg2;
22415   if (!arg2) {
22416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22417     return ;
22418   }
22419   arg3 = (Dali::Vector3 *)jarg3;
22420   if (!arg3) {
22421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22422     return ;
22423   }
22424   {
22425     try {
22426       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22427     } CALL_CATCH_EXCEPTION();
22428   }
22429
22430 }
22431
22432
22433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22435   Dali::Radian *arg2 = 0 ;
22436   Dali::Vector3 *arg3 = 0 ;
22437
22438   arg1 = (Dali::Actor *)jarg1;
22439   arg2 = (Dali::Radian *)jarg2;
22440   if (!arg2) {
22441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22442     return ;
22443   }
22444   arg3 = (Dali::Vector3 *)jarg3;
22445   if (!arg3) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22447     return ;
22448   }
22449   {
22450     try {
22451       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22452     } CALL_CATCH_EXCEPTION();
22453   }
22454
22455 }
22456
22457
22458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22460   Dali::Quaternion *arg2 = 0 ;
22461
22462   arg1 = (Dali::Actor *)jarg1;
22463   arg2 = (Dali::Quaternion *)jarg2;
22464   if (!arg2) {
22465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22466     return ;
22467   }
22468   {
22469     try {
22470       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22471     } CALL_CATCH_EXCEPTION();
22472   }
22473
22474 }
22475
22476
22477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22478   void * jresult ;
22479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22480   Dali::Quaternion result;
22481
22482   arg1 = (Dali::Actor *)jarg1;
22483   {
22484     try {
22485       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22486     } CALL_CATCH_EXCEPTION(0);
22487   }
22488
22489   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22490   return jresult;
22491 }
22492
22493
22494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22496   bool arg2 ;
22497
22498   arg1 = (Dali::Actor *)jarg1;
22499   arg2 = jarg2 ? true : false;
22500   {
22501     try {
22502       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22503     } CALL_CATCH_EXCEPTION();
22504   }
22505
22506 }
22507
22508
22509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22510   unsigned int jresult ;
22511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22512   bool result;
22513
22514   arg1 = (Dali::Actor *)jarg1;
22515   {
22516     try {
22517       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22518     } CALL_CATCH_EXCEPTION(0);
22519   }
22520
22521   jresult = result;
22522   return jresult;
22523 }
22524
22525
22526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22527   void * jresult ;
22528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22529   Dali::Quaternion result;
22530
22531   arg1 = (Dali::Actor *)jarg1;
22532   {
22533     try {
22534       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22535     } CALL_CATCH_EXCEPTION(0);
22536   }
22537
22538   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22539   return jresult;
22540 }
22541
22542
22543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22545   float arg2 ;
22546
22547   arg1 = (Dali::Actor *)jarg1;
22548   arg2 = (float)jarg2;
22549   {
22550     try {
22551       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22552     } CALL_CATCH_EXCEPTION();
22553   }
22554
22555 }
22556
22557
22558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22560   float arg2 ;
22561   float arg3 ;
22562   float arg4 ;
22563
22564   arg1 = (Dali::Actor *)jarg1;
22565   arg2 = (float)jarg2;
22566   arg3 = (float)jarg3;
22567   arg4 = (float)jarg4;
22568   {
22569     try {
22570       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22571     } CALL_CATCH_EXCEPTION();
22572   }
22573
22574 }
22575
22576
22577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(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)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22590     } CALL_CATCH_EXCEPTION();
22591   }
22592
22593 }
22594
22595
22596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22598   Dali::Vector3 *arg2 = 0 ;
22599
22600   arg1 = (Dali::Actor *)jarg1;
22601   arg2 = (Dali::Vector3 *)jarg2;
22602   if (!arg2) {
22603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22604     return ;
22605   }
22606   {
22607     try {
22608       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22609     } CALL_CATCH_EXCEPTION();
22610   }
22611
22612 }
22613
22614
22615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22616   void * jresult ;
22617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22618   Dali::Vector3 result;
22619
22620   arg1 = (Dali::Actor *)jarg1;
22621   {
22622     try {
22623       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22624     } CALL_CATCH_EXCEPTION(0);
22625   }
22626
22627   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22628   return jresult;
22629 }
22630
22631
22632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
22633   void * jresult ;
22634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22635   Dali::Vector3 result;
22636
22637   arg1 = (Dali::Actor *)jarg1;
22638   {
22639     try {
22640       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
22641     } CALL_CATCH_EXCEPTION(0);
22642   }
22643
22644   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22645   return jresult;
22646 }
22647
22648
22649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
22650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22651   bool arg2 ;
22652
22653   arg1 = (Dali::Actor *)jarg1;
22654   arg2 = jarg2 ? true : false;
22655   {
22656     try {
22657       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22658     } CALL_CATCH_EXCEPTION();
22659   }
22660
22661 }
22662
22663
22664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22665   unsigned int jresult ;
22666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22667   bool result;
22668
22669   arg1 = (Dali::Actor *)jarg1;
22670   {
22671     try {
22672       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22673     } CALL_CATCH_EXCEPTION(0);
22674   }
22675
22676   jresult = result;
22677   return jresult;
22678 }
22679
22680
22681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22682   void * jresult ;
22683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22684   Dali::Matrix result;
22685
22686   arg1 = (Dali::Actor *)jarg1;
22687   {
22688     try {
22689       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22690     } CALL_CATCH_EXCEPTION(0);
22691   }
22692
22693   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22694   return jresult;
22695 }
22696
22697
22698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22700   bool arg2 ;
22701
22702   arg1 = (Dali::Actor *)jarg1;
22703   arg2 = jarg2 ? true : false;
22704   {
22705     try {
22706       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22707     } CALL_CATCH_EXCEPTION();
22708   }
22709
22710 }
22711
22712
22713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22714   unsigned int jresult ;
22715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22716   bool result;
22717
22718   arg1 = (Dali::Actor *)jarg1;
22719   {
22720     try {
22721       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22722     } CALL_CATCH_EXCEPTION(0);
22723   }
22724
22725   jresult = result;
22726   return jresult;
22727 }
22728
22729
22730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22732   float arg2 ;
22733
22734   arg1 = (Dali::Actor *)jarg1;
22735   arg2 = (float)jarg2;
22736   {
22737     try {
22738       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22739     } CALL_CATCH_EXCEPTION();
22740   }
22741
22742 }
22743
22744
22745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22746   float jresult ;
22747   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22748   float result;
22749
22750   arg1 = (Dali::Actor *)jarg1;
22751   {
22752     try {
22753       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22754     } CALL_CATCH_EXCEPTION(0);
22755   }
22756
22757   jresult = result;
22758   return jresult;
22759 }
22760
22761
22762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22764   Dali::Vector4 *arg2 = 0 ;
22765
22766   arg1 = (Dali::Actor *)jarg1;
22767   arg2 = (Dali::Vector4 *)jarg2;
22768   if (!arg2) {
22769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22770     return ;
22771   }
22772   {
22773     try {
22774       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22775     } CALL_CATCH_EXCEPTION();
22776   }
22777
22778 }
22779
22780
22781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22782   void * jresult ;
22783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22784   Dali::Vector4 result;
22785
22786   arg1 = (Dali::Actor *)jarg1;
22787   {
22788     try {
22789       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22790     } CALL_CATCH_EXCEPTION(0);
22791   }
22792
22793   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22794   return jresult;
22795 }
22796
22797
22798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22800   Dali::ColorMode arg2 ;
22801
22802   arg1 = (Dali::Actor *)jarg1;
22803   arg2 = (Dali::ColorMode)jarg2;
22804   {
22805     try {
22806       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22807     } CALL_CATCH_EXCEPTION();
22808   }
22809
22810 }
22811
22812
22813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22814   int jresult ;
22815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22816   Dali::ColorMode result;
22817
22818   arg1 = (Dali::Actor *)jarg1;
22819   {
22820     try {
22821       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22822     } CALL_CATCH_EXCEPTION(0);
22823   }
22824
22825   jresult = (int)result;
22826   return jresult;
22827 }
22828
22829
22830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22831   void * jresult ;
22832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22833   Dali::Vector4 result;
22834
22835   arg1 = (Dali::Actor *)jarg1;
22836   {
22837     try {
22838       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22839     } CALL_CATCH_EXCEPTION(0);
22840   }
22841
22842   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22843   return jresult;
22844 }
22845
22846
22847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22849   Dali::DrawMode::Type arg2 ;
22850
22851   arg1 = (Dali::Actor *)jarg1;
22852   arg2 = (Dali::DrawMode::Type)jarg2;
22853   {
22854     try {
22855       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22856     } CALL_CATCH_EXCEPTION();
22857   }
22858
22859 }
22860
22861
22862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22863   int jresult ;
22864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22865   Dali::DrawMode::Type result;
22866
22867   arg1 = (Dali::Actor *)jarg1;
22868   {
22869     try {
22870       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22871     } CALL_CATCH_EXCEPTION(0);
22872   }
22873
22874   jresult = (int)result;
22875   return jresult;
22876 }
22877
22878
22879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22881   bool arg2 ;
22882
22883   arg1 = (Dali::Actor *)jarg1;
22884   arg2 = jarg2 ? true : false;
22885   {
22886     try {
22887       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22888     } CALL_CATCH_EXCEPTION();
22889   }
22890
22891 }
22892
22893
22894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22895   unsigned int jresult ;
22896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22897   bool result;
22898
22899   arg1 = (Dali::Actor *)jarg1;
22900   {
22901     try {
22902       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22903     } CALL_CATCH_EXCEPTION(0);
22904   }
22905
22906   jresult = result;
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22912   unsigned int jresult ;
22913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22914   float *arg2 = 0 ;
22915   float *arg3 = 0 ;
22916   float arg4 ;
22917   float arg5 ;
22918   bool result;
22919
22920   arg1 = (Dali::Actor *)jarg1;
22921   arg2 = (float *)jarg2;
22922   arg3 = (float *)jarg3;
22923   arg4 = (float)jarg4;
22924   arg5 = (float)jarg5;
22925   {
22926     try {
22927       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22928     } CALL_CATCH_EXCEPTION(0);
22929   }
22930
22931   jresult = result;
22932   return jresult;
22933 }
22934
22935
22936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22938   bool arg2 ;
22939
22940   arg1 = (Dali::Actor *)jarg1;
22941   arg2 = jarg2 ? true : false;
22942   {
22943     try {
22944       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22945     } CALL_CATCH_EXCEPTION();
22946   }
22947
22948 }
22949
22950
22951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22952   unsigned int jresult ;
22953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22954   bool result;
22955
22956   arg1 = (Dali::Actor *)jarg1;
22957   {
22958     try {
22959       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22960     } CALL_CATCH_EXCEPTION(0);
22961   }
22962
22963   jresult = result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22970   bool arg2 ;
22971
22972   arg1 = (Dali::Actor *)jarg1;
22973   arg2 = jarg2 ? true : false;
22974   {
22975     try {
22976       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22977     } CALL_CATCH_EXCEPTION();
22978   }
22979
22980 }
22981
22982
22983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22984   unsigned int jresult ;
22985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22986   bool result;
22987
22988   arg1 = (Dali::Actor *)jarg1;
22989   {
22990     try {
22991       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22992     } CALL_CATCH_EXCEPTION(0);
22993   }
22994
22995   jresult = result;
22996   return jresult;
22997 }
22998
22999
23000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
23001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23002   Dali::ResizePolicy::Type arg2 ;
23003   Dali::Dimension::Type arg3 ;
23004
23005   arg1 = (Dali::Actor *)jarg1;
23006   arg2 = (Dali::ResizePolicy::Type)jarg2;
23007   arg3 = (Dali::Dimension::Type)jarg3;
23008   {
23009     try {
23010       (arg1)->SetResizePolicy(arg2,arg3);
23011     } CALL_CATCH_EXCEPTION();
23012   }
23013
23014 }
23015
23016
23017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
23018   int jresult ;
23019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23020   Dali::Dimension::Type arg2 ;
23021   Dali::ResizePolicy::Type result;
23022
23023   arg1 = (Dali::Actor *)jarg1;
23024   arg2 = (Dali::Dimension::Type)jarg2;
23025   {
23026     try {
23027       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23028     } CALL_CATCH_EXCEPTION(0);
23029   }
23030
23031   jresult = (int)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23037   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23038   Dali::SizeScalePolicy::Type arg2 ;
23039
23040   arg1 = (Dali::Actor *)jarg1;
23041   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23042   {
23043     try {
23044       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23045     } CALL_CATCH_EXCEPTION();
23046   }
23047
23048 }
23049
23050
23051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23052   int jresult ;
23053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23054   Dali::SizeScalePolicy::Type result;
23055
23056   arg1 = (Dali::Actor *)jarg1;
23057   {
23058     try {
23059       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23060     } CALL_CATCH_EXCEPTION(0);
23061   }
23062
23063   jresult = (int)result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23070   Dali::Vector3 *arg2 = 0 ;
23071
23072   arg1 = (Dali::Actor *)jarg1;
23073   arg2 = (Dali::Vector3 *)jarg2;
23074   if (!arg2) {
23075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23076     return ;
23077   }
23078   {
23079     try {
23080       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23081     } CALL_CATCH_EXCEPTION();
23082   }
23083
23084 }
23085
23086
23087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23088   void * jresult ;
23089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23090   Dali::Vector3 result;
23091
23092   arg1 = (Dali::Actor *)jarg1;
23093   {
23094     try {
23095       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23096     } CALL_CATCH_EXCEPTION(0);
23097   }
23098
23099   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23100   return jresult;
23101 }
23102
23103
23104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(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)->GetHeightForWidth(arg2);
23115     } CALL_CATCH_EXCEPTION(0);
23116   }
23117
23118   jresult = result;
23119   return jresult;
23120 }
23121
23122
23123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23124   float jresult ;
23125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23126   float arg2 ;
23127   float result;
23128
23129   arg1 = (Dali::Actor *)jarg1;
23130   arg2 = (float)jarg2;
23131   {
23132     try {
23133       result = (float)(arg1)->GetWidthForHeight(arg2);
23134     } CALL_CATCH_EXCEPTION(0);
23135   }
23136
23137   jresult = result;
23138   return jresult;
23139 }
23140
23141
23142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23143   float jresult ;
23144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23145   Dali::Dimension::Type arg2 ;
23146   float result;
23147
23148   arg1 = (Dali::Actor *)jarg1;
23149   arg2 = (Dali::Dimension::Type)jarg2;
23150   {
23151     try {
23152       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23153     } CALL_CATCH_EXCEPTION(0);
23154   }
23155
23156   jresult = result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(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 const & type is null", 0);
23169     return ;
23170   }
23171   {
23172     try {
23173       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23174     } CALL_CATCH_EXCEPTION();
23175   }
23176
23177 }
23178
23179
23180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23182   Dali::Padding *arg2 = 0 ;
23183
23184   arg1 = (Dali::Actor *)jarg1;
23185   arg2 = (Dali::Padding *)jarg2;
23186   if (!arg2) {
23187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23188     return ;
23189   }
23190   {
23191     try {
23192       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23193     } CALL_CATCH_EXCEPTION();
23194   }
23195
23196 }
23197
23198
23199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23201   Dali::Vector2 *arg2 = 0 ;
23202
23203   arg1 = (Dali::Actor *)jarg1;
23204   arg2 = (Dali::Vector2 *)jarg2;
23205   if (!arg2) {
23206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23207     return ;
23208   }
23209   {
23210     try {
23211       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23212     } CALL_CATCH_EXCEPTION();
23213   }
23214
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23219   void * jresult ;
23220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23221   Dali::Vector2 result;
23222
23223   arg1 = (Dali::Actor *)jarg1;
23224   {
23225     try {
23226       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23227     } CALL_CATCH_EXCEPTION(0);
23228   }
23229
23230   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23236   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23237   Dali::Vector2 *arg2 = 0 ;
23238
23239   arg1 = (Dali::Actor *)jarg1;
23240   arg2 = (Dali::Vector2 *)jarg2;
23241   if (!arg2) {
23242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23243     return ;
23244   }
23245   {
23246     try {
23247       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23248     } CALL_CATCH_EXCEPTION();
23249   }
23250
23251 }
23252
23253
23254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23255   void * jresult ;
23256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23257   Dali::Vector2 result;
23258
23259   arg1 = (Dali::Actor *)jarg1;
23260   {
23261     try {
23262       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
23263     } CALL_CATCH_EXCEPTION(0);
23264   }
23265
23266   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23272   int jresult ;
23273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23274   int result;
23275
23276   arg1 = (Dali::Actor *)jarg1;
23277   {
23278     try {
23279       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23280       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23281     } CALL_CATCH_EXCEPTION(0);
23282   }
23283
23284   jresult = result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23290   unsigned int jresult ;
23291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23292   Dali::Renderer *arg2 = 0 ;
23293   unsigned int result;
23294
23295   arg1 = (Dali::Actor *)jarg1;
23296   arg2 = (Dali::Renderer *)jarg2;
23297   if (!arg2) {
23298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23299     return 0;
23300   }
23301   {
23302     try {
23303       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23304     } CALL_CATCH_EXCEPTION(0);
23305   }
23306
23307   jresult = result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23313   unsigned int jresult ;
23314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23315   unsigned int result;
23316
23317   arg1 = (Dali::Actor *)jarg1;
23318   {
23319     try {
23320       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23321     } CALL_CATCH_EXCEPTION(0);
23322   }
23323
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23330   void * jresult ;
23331   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23332   unsigned int arg2 ;
23333   Dali::Renderer result;
23334
23335   arg1 = (Dali::Actor *)jarg1;
23336   arg2 = (unsigned int)jarg2;
23337   {
23338     try {
23339       result = (arg1)->GetRendererAt(arg2);
23340     } CALL_CATCH_EXCEPTION(0);
23341   }
23342
23343   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23350   Dali::Renderer *arg2 = 0 ;
23351
23352   arg1 = (Dali::Actor *)jarg1;
23353   arg2 = (Dali::Renderer *)jarg2;
23354   if (!arg2) {
23355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23356     return ;
23357   }
23358   {
23359     try {
23360       (arg1)->RemoveRenderer(*arg2);
23361     } CALL_CATCH_EXCEPTION();
23362   }
23363
23364 }
23365
23366
23367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23369   unsigned int arg2 ;
23370
23371   arg1 = (Dali::Actor *)jarg1;
23372   arg2 = (unsigned int)jarg2;
23373   {
23374     try {
23375       (arg1)->RemoveRenderer(arg2);
23376     } CALL_CATCH_EXCEPTION();
23377   }
23378
23379 }
23380
23381
23382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23383   void * jresult ;
23384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23385   Dali::Actor::TouchEventSignalType *result = 0 ;
23386
23387   arg1 = (Dali::Actor *)jarg1;
23388   {
23389     try {
23390       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
23391     } CALL_CATCH_EXCEPTION(0);
23392   }
23393
23394   jresult = (void *)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23400   void * jresult ;
23401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23402   Dali::Actor::HoverSignalType *result = 0 ;
23403
23404   arg1 = (Dali::Actor *)jarg1;
23405   {
23406     try {
23407       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23408     } CALL_CATCH_EXCEPTION(0);
23409   }
23410
23411   jresult = (void *)result;
23412   return jresult;
23413 }
23414
23415
23416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23417   void * jresult ;
23418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23419   Dali::Actor::WheelEventSignalType *result = 0 ;
23420
23421   arg1 = (Dali::Actor *)jarg1;
23422   {
23423     try {
23424       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23425     } CALL_CATCH_EXCEPTION(0);
23426   }
23427
23428   jresult = (void *)result;
23429   return jresult;
23430 }
23431
23432
23433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23434   void * jresult ;
23435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23436   Dali::Actor::OnSceneSignalType *result = 0 ;
23437
23438   arg1 = (Dali::Actor *)jarg1;
23439   {
23440     try {
23441       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23442     } CALL_CATCH_EXCEPTION(0);
23443   }
23444
23445   jresult = (void *)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23451   void * jresult ;
23452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23453   Dali::Actor::OffSceneSignalType *result = 0 ;
23454
23455   arg1 = (Dali::Actor *)jarg1;
23456   {
23457     try {
23458       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23459     } CALL_CATCH_EXCEPTION(0);
23460   }
23461
23462   jresult = (void *)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23468   void * jresult ;
23469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23470   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23471
23472   arg1 = (Dali::Actor *)jarg1;
23473   {
23474     try {
23475       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23476     } CALL_CATCH_EXCEPTION(0);
23477   }
23478
23479   jresult = (void *)result;
23480   return jresult;
23481 }
23482
23483
23484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23485   Dali::Actor *arg1 = 0 ;
23486
23487   arg1 = (Dali::Actor *)jarg1;
23488   if (!arg1) {
23489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23490     return ;
23491   }
23492   {
23493     try {
23494       Dali::UnparentAndReset(*arg1);
23495     } CALL_CATCH_EXCEPTION();
23496   }
23497
23498 }
23499
23500
23501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23502   int jresult ;
23503   int result;
23504
23505   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23506   jresult = (int)result;
23507   return jresult;
23508 }
23509
23510
23511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23512   int jresult ;
23513   int result;
23514
23515   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23516   jresult = (int)result;
23517   return jresult;
23518 }
23519
23520
23521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23522   int jresult ;
23523   int result;
23524
23525   result = (int)Dali::Layer::Property::BEHAVIOR;
23526   jresult = (int)result;
23527   return jresult;
23528 }
23529
23530
23531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23532   void * jresult ;
23533   Dali::Layer::Property *result = 0 ;
23534
23535   {
23536     try {
23537       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23538     } CALL_CATCH_EXCEPTION(0);
23539   }
23540
23541   jresult = (void *)result;
23542   return jresult;
23543 }
23544
23545
23546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23547   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23548
23549   arg1 = (Dali::Layer::Property *)jarg1;
23550   {
23551     try {
23552       delete arg1;
23553     } CALL_CATCH_EXCEPTION();
23554   }
23555
23556 }
23557
23558
23559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23560   void * jresult ;
23561   Dali::Layer *result = 0 ;
23562
23563   {
23564     try {
23565       result = (Dali::Layer *)new Dali::Layer();
23566     } CALL_CATCH_EXCEPTION(0);
23567   }
23568
23569   jresult = (void *)result;
23570   return jresult;
23571 }
23572
23573
23574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23575   void * jresult ;
23576   Dali::Layer result;
23577
23578   {
23579     try {
23580       result = Dali::Layer::New();
23581     } CALL_CATCH_EXCEPTION(0);
23582   }
23583
23584   jresult = new Dali::Layer((const Dali::Layer &)result);
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23590   void * jresult ;
23591   Dali::BaseHandle arg1 ;
23592   Dali::BaseHandle *argp1 ;
23593   Dali::Layer result;
23594
23595   argp1 = (Dali::BaseHandle *)jarg1;
23596   if (!argp1) {
23597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23598     return 0;
23599   }
23600   arg1 = *argp1;
23601   {
23602     try {
23603       result = Dali::Layer::DownCast(arg1);
23604     } CALL_CATCH_EXCEPTION(0);
23605   }
23606
23607   jresult = new Dali::Layer((const Dali::Layer &)result);
23608   return jresult;
23609 }
23610
23611
23612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23613   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23614
23615   arg1 = (Dali::Layer *)jarg1;
23616   {
23617     try {
23618       delete arg1;
23619     } CALL_CATCH_EXCEPTION();
23620   }
23621
23622 }
23623
23624
23625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23626   void * jresult ;
23627   Dali::Layer *arg1 = 0 ;
23628   Dali::Layer *result = 0 ;
23629
23630   arg1 = (Dali::Layer *)jarg1;
23631   if (!arg1) {
23632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23633     return 0;
23634   }
23635   {
23636     try {
23637       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23638     } CALL_CATCH_EXCEPTION(0);
23639   }
23640
23641   jresult = (void *)result;
23642   return jresult;
23643 }
23644
23645
23646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23647   void * jresult ;
23648   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23649   Dali::Layer *arg2 = 0 ;
23650   Dali::Layer *result = 0 ;
23651
23652   arg1 = (Dali::Layer *)jarg1;
23653   arg2 = (Dali::Layer *)jarg2;
23654   if (!arg2) {
23655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23656     return 0;
23657   }
23658   {
23659     try {
23660       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23661     } CALL_CATCH_EXCEPTION(0);
23662   }
23663
23664   jresult = (void *)result;
23665   return jresult;
23666 }
23667
23668
23669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23670   unsigned int jresult ;
23671   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23672   unsigned int result;
23673
23674   arg1 = (Dali::Layer *)jarg1;
23675   {
23676     try {
23677       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23678     } CALL_CATCH_EXCEPTION(0);
23679   }
23680
23681   jresult = result;
23682   return jresult;
23683 }
23684
23685
23686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23687   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23688
23689   arg1 = (Dali::Layer *)jarg1;
23690   {
23691     try {
23692       (arg1)->Raise();
23693     } CALL_CATCH_EXCEPTION();
23694   }
23695
23696 }
23697
23698
23699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23700   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23701
23702   arg1 = (Dali::Layer *)jarg1;
23703   {
23704     try {
23705       (arg1)->Lower();
23706     } CALL_CATCH_EXCEPTION();
23707   }
23708
23709 }
23710
23711
23712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23713   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23714   Dali::Layer arg2 ;
23715   Dali::Layer *argp2 ;
23716
23717   arg1 = (Dali::Layer *)jarg1;
23718   argp2 = (Dali::Layer *)jarg2;
23719   if (!argp2) {
23720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23721     return ;
23722   }
23723   arg2 = *argp2;
23724   {
23725     try {
23726       (arg1)->RaiseAbove(arg2);
23727     } CALL_CATCH_EXCEPTION();
23728   }
23729
23730 }
23731
23732
23733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23734   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23735   Dali::Layer arg2 ;
23736   Dali::Layer *argp2 ;
23737
23738   arg1 = (Dali::Layer *)jarg1;
23739   argp2 = (Dali::Layer *)jarg2;
23740   if (!argp2) {
23741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23742     return ;
23743   }
23744   arg2 = *argp2;
23745   {
23746     try {
23747       (arg1)->LowerBelow(arg2);
23748     } CALL_CATCH_EXCEPTION();
23749   }
23750
23751 }
23752
23753
23754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23755   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23756
23757   arg1 = (Dali::Layer *)jarg1;
23758   {
23759     try {
23760       (arg1)->RaiseToTop();
23761     } CALL_CATCH_EXCEPTION();
23762   }
23763
23764 }
23765
23766
23767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23768   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23769
23770   arg1 = (Dali::Layer *)jarg1;
23771   {
23772     try {
23773       (arg1)->LowerToBottom();
23774     } CALL_CATCH_EXCEPTION();
23775   }
23776
23777 }
23778
23779
23780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23781   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23782   Dali::Layer arg2 ;
23783   Dali::Layer *argp2 ;
23784
23785   arg1 = (Dali::Layer *)jarg1;
23786   argp2 = (Dali::Layer *)jarg2;
23787   if (!argp2) {
23788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23789     return ;
23790   }
23791   arg2 = *argp2;
23792   {
23793     try {
23794       (arg1)->MoveAbove(arg2);
23795     } CALL_CATCH_EXCEPTION();
23796   }
23797
23798 }
23799
23800
23801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23802   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23803   Dali::Layer arg2 ;
23804   Dali::Layer *argp2 ;
23805
23806   arg1 = (Dali::Layer *)jarg1;
23807   argp2 = (Dali::Layer *)jarg2;
23808   if (!argp2) {
23809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23810     return ;
23811   }
23812   arg2 = *argp2;
23813   {
23814     try {
23815       (arg1)->MoveBelow(arg2);
23816     } CALL_CATCH_EXCEPTION();
23817   }
23818
23819 }
23820
23821
23822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23823   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23824   Dali::Layer::Behavior arg2 ;
23825
23826   arg1 = (Dali::Layer *)jarg1;
23827   arg2 = (Dali::Layer::Behavior)jarg2;
23828   {
23829     try {
23830       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23831     } CALL_CATCH_EXCEPTION();
23832   }
23833
23834 }
23835
23836
23837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23838   int jresult ;
23839   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23840   Dali::Layer::Behavior result;
23841
23842   arg1 = (Dali::Layer *)jarg1;
23843   {
23844     try {
23845       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23846     } CALL_CATCH_EXCEPTION(0);
23847   }
23848
23849   jresult = (int)result;
23850   return jresult;
23851 }
23852
23853
23854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23855   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23856   bool arg2 ;
23857
23858   arg1 = (Dali::Layer *)jarg1;
23859   arg2 = jarg2 ? true : false;
23860   {
23861     try {
23862       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23863     } CALL_CATCH_EXCEPTION();
23864   }
23865
23866 }
23867
23868
23869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23870   unsigned int jresult ;
23871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23872   bool result;
23873
23874   arg1 = (Dali::Layer *)jarg1;
23875   {
23876     try {
23877       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23878     } CALL_CATCH_EXCEPTION(0);
23879   }
23880
23881   jresult = result;
23882   return jresult;
23883 }
23884
23885
23886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23887   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23888   int arg2 ;
23889   int arg3 ;
23890   int arg4 ;
23891   int arg5 ;
23892
23893   arg1 = (Dali::Layer *)jarg1;
23894   arg2 = (int)jarg2;
23895   arg3 = (int)jarg3;
23896   arg4 = (int)jarg4;
23897   arg5 = (int)jarg5;
23898   {
23899     try {
23900       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23901     } CALL_CATCH_EXCEPTION();
23902   }
23903
23904 }
23905
23906
23907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23908   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23909   Dali::ClippingBox arg2 ;
23910   Dali::ClippingBox *argp2 ;
23911
23912   arg1 = (Dali::Layer *)jarg1;
23913   argp2 = (Dali::ClippingBox *)jarg2;
23914   if (!argp2) {
23915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23916     return ;
23917   }
23918   arg2 = *argp2;
23919   {
23920     try {
23921       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23922     } CALL_CATCH_EXCEPTION();
23923   }
23924
23925 }
23926
23927
23928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23929   void * jresult ;
23930   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23931   Dali::ClippingBox result;
23932
23933   arg1 = (Dali::Layer *)jarg1;
23934   {
23935     try {
23936       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23937     } CALL_CATCH_EXCEPTION(0);
23938   }
23939
23940   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23941   return jresult;
23942 }
23943
23944
23945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23946   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23947   bool arg2 ;
23948
23949   arg1 = (Dali::Layer *)jarg1;
23950   arg2 = jarg2 ? true : false;
23951   {
23952     try {
23953       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23954     } CALL_CATCH_EXCEPTION();
23955   }
23956
23957 }
23958
23959
23960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23961   unsigned int jresult ;
23962   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23963   bool result;
23964
23965   arg1 = (Dali::Layer *)jarg1;
23966   {
23967     try {
23968       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23969     } CALL_CATCH_EXCEPTION(0);
23970   }
23971
23972   jresult = result;
23973   return jresult;
23974 }
23975
23976
23977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23978   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23979   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23980
23981   arg1 = (Dali::Layer *)jarg1;
23982   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23983   {
23984     try {
23985       (arg1)->SetSortFunction(arg2);
23986     } CALL_CATCH_EXCEPTION();
23987   }
23988
23989 }
23990
23991
23992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23993   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23994   bool arg2 ;
23995
23996   arg1 = (Dali::Layer *)jarg1;
23997   arg2 = jarg2 ? true : false;
23998   {
23999     try {
24000       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
24001     } CALL_CATCH_EXCEPTION();
24002   }
24003
24004 }
24005
24006
24007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
24008   unsigned int jresult ;
24009   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24010   bool result;
24011
24012   arg1 = (Dali::Layer *)jarg1;
24013   {
24014     try {
24015       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
24016     } CALL_CATCH_EXCEPTION(0);
24017   }
24018
24019   jresult = result;
24020   return jresult;
24021 }
24022
24023
24024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
24025   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24026   bool arg2 ;
24027
24028   arg1 = (Dali::Layer *)jarg1;
24029   arg2 = jarg2 ? true : false;
24030   {
24031     try {
24032       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24033     } CALL_CATCH_EXCEPTION();
24034   }
24035
24036 }
24037
24038
24039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24040   unsigned int jresult ;
24041   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24042   bool result;
24043
24044   arg1 = (Dali::Layer *)jarg1;
24045   {
24046     try {
24047       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24048     } CALL_CATCH_EXCEPTION(0);
24049   }
24050
24051   jresult = result;
24052   return jresult;
24053 }
24054
24055
24056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24057   void * jresult ;
24058   Dali::Stage result;
24059
24060   {
24061     try {
24062       result = Dali::Stage::GetCurrent();
24063     } CALL_CATCH_EXCEPTION(0);
24064   }
24065
24066   jresult = new Dali::Stage((const Dali::Stage &)result);
24067   return jresult;
24068 }
24069
24070
24071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24072   unsigned int jresult ;
24073   bool result;
24074
24075   {
24076     try {
24077       result = (bool)Dali::Stage::IsInstalled();
24078     } CALL_CATCH_EXCEPTION(0);
24079   }
24080
24081   jresult = result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24087   void * jresult ;
24088   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24089   Dali::Vector2 result;
24090
24091   arg1 = (Dali::Stage *)jarg1;
24092   {
24093     try {
24094       result = ((Dali::Stage const *)arg1)->GetDpi();
24095     } CALL_CATCH_EXCEPTION(0);
24096   }
24097
24098   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24104   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24105   float arg2 ;
24106
24107   arg1 = (Dali::Stage *)jarg1;
24108   arg2 = (float)jarg2;
24109   {
24110     try {
24111       (arg1)->KeepRendering(arg2);
24112     } CALL_CATCH_EXCEPTION();
24113   }
24114
24115 }
24116
24117
24118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24119   void * jresult ;
24120   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24121   Dali::Stage::KeyEventSignalType *result = 0 ;
24122
24123   arg1 = (Dali::Stage *)jarg1;
24124   {
24125     try {
24126       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24127     } CALL_CATCH_EXCEPTION(0);
24128   }
24129
24130   jresult = (void *)result;
24131   return jresult;
24132 }
24133
24134
24135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24136   void * jresult ;
24137   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24138   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24139
24140   arg1 = (Dali::Stage *)jarg1;
24141   {
24142     try {
24143       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24144     } CALL_CATCH_EXCEPTION(0);
24145   }
24146
24147   jresult = (void *)result;
24148   return jresult;
24149 }
24150
24151
24152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24153   void * jresult ;
24154   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24155   Dali::Stage::TouchEventSignalType *result = 0 ;
24156
24157   arg1 = (Dali::Stage *)jarg1;
24158   {
24159     try {
24160       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
24161     } CALL_CATCH_EXCEPTION(0);
24162   }
24163
24164   jresult = (void *)result;
24165   return jresult;
24166 }
24167
24168
24169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24170   void * jresult ;
24171   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24172   Dali::Stage::WheelEventSignalType *result = 0 ;
24173
24174   arg1 = (Dali::Stage *)jarg1;
24175   {
24176     try {
24177       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24178     } CALL_CATCH_EXCEPTION(0);
24179   }
24180
24181   jresult = (void *)result;
24182   return jresult;
24183 }
24184
24185
24186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24187   void * jresult ;
24188   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24189   Dali::Stage::ContextStatusSignal *result = 0 ;
24190
24191   arg1 = (Dali::Stage *)jarg1;
24192   {
24193     try {
24194       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24195     } CALL_CATCH_EXCEPTION(0);
24196   }
24197
24198   jresult = (void *)result;
24199   return jresult;
24200 }
24201
24202
24203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
24204   void * jresult ;
24205   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24206   Dali::Stage::ContextStatusSignal *result = 0 ;
24207
24208   arg1 = (Dali::Stage *)jarg1;
24209   {
24210     try {
24211       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
24212     } CALL_CATCH_EXCEPTION(0);
24213   }
24214
24215   jresult = (void *)result;
24216   return jresult;
24217 }
24218
24219
24220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24221   void * jresult ;
24222   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24223   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24224
24225   arg1 = (Dali::Stage *)jarg1;
24226   {
24227     try {
24228       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24229     } CALL_CATCH_EXCEPTION(0);
24230   }
24231
24232   jresult = (void *)result;
24233   return jresult;
24234 }
24235
24236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24237   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24238   Dali::DevelStage::Rendering arg2 ;
24239
24240   arg1 = (Dali::Stage *)jarg1;
24241   arg2 = (Dali::DevelStage::Rendering)jarg2;
24242   {
24243     try {
24244       DevelStage::SetRenderingBehavior(*arg1,arg2);
24245     } CALL_CATCH_EXCEPTION();
24246   }
24247
24248 }
24249
24250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24251
24252   int jresult ;
24253   int result ;
24254   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24255
24256   arg1 = (Dali::Stage *)jarg1;
24257   {
24258     try {
24259       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24260     } CALL_CATCH_EXCEPTION(0);
24261   }
24262
24263   jresult = result;
24264   return jresult;
24265 }
24266
24267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24268   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24269
24270   arg1 = (Dali::RelayoutContainer *)jarg1;
24271   {
24272     try {
24273       delete arg1;
24274     } CALL_CATCH_EXCEPTION();
24275   }
24276
24277 }
24278
24279
24280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24281   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24282   Dali::Actor *arg2 = 0 ;
24283   Dali::Vector2 *arg3 = 0 ;
24284
24285   arg1 = (Dali::RelayoutContainer *)jarg1;
24286   arg2 = (Dali::Actor *)jarg2;
24287   if (!arg2) {
24288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24289     return ;
24290   }
24291   arg3 = (Dali::Vector2 *)jarg3;
24292   if (!arg3) {
24293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24294     return ;
24295   }
24296   {
24297     try {
24298       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24299     } CALL_CATCH_EXCEPTION();
24300   }
24301
24302 }
24303
24304
24305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24306   void * jresult ;
24307   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24308   Dali::CustomActor result;
24309
24310   arg1 = (Dali::CustomActorImpl *)jarg1;
24311   {
24312     try {
24313       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24314     } CALL_CATCH_EXCEPTION(0);
24315   }
24316
24317   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24318   return jresult;
24319 }
24320
24321
24322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24323   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24324   int arg2 ;
24325
24326   arg1 = (Dali::CustomActorImpl *)jarg1;
24327   arg2 = (int)jarg2;
24328   {
24329     try {
24330       (arg1)->OnSceneConnection(arg2);
24331     } CALL_CATCH_EXCEPTION();
24332   }
24333
24334 }
24335
24336
24337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24338   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24339
24340   arg1 = (Dali::CustomActorImpl *)jarg1;
24341   {
24342     try {
24343       (arg1)->OnSceneDisconnection();
24344     } CALL_CATCH_EXCEPTION();
24345   }
24346
24347 }
24348
24349
24350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(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)->OnChildAdd(*arg2);
24363     } CALL_CATCH_EXCEPTION();
24364   }
24365
24366 }
24367
24368
24369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24371   Dali::Actor *arg2 = 0 ;
24372
24373   arg1 = (Dali::CustomActorImpl *)jarg1;
24374   arg2 = (Dali::Actor *)jarg2;
24375   if (!arg2) {
24376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24377     return ;
24378   }
24379   {
24380     try {
24381       (arg1)->OnChildRemove(*arg2);
24382     } CALL_CATCH_EXCEPTION();
24383   }
24384
24385 }
24386
24387
24388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24389   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24390   Dali::Property::Index arg2 ;
24391   Dali::Property::Value arg3 ;
24392   Dali::Property::Value *argp3 ;
24393
24394   arg1 = (Dali::CustomActorImpl *)jarg1;
24395   arg2 = (Dali::Property::Index)jarg2;
24396   argp3 = (Dali::Property::Value *)jarg3;
24397   if (!argp3) {
24398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24399     return ;
24400   }
24401   arg3 = *argp3;
24402   {
24403     try {
24404       (arg1)->OnPropertySet(arg2,arg3);
24405     } CALL_CATCH_EXCEPTION();
24406   }
24407
24408 }
24409
24410
24411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24412   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24413   Dali::Vector3 *arg2 = 0 ;
24414
24415   arg1 = (Dali::CustomActorImpl *)jarg1;
24416   arg2 = (Dali::Vector3 *)jarg2;
24417   if (!arg2) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24419     return ;
24420   }
24421   {
24422     try {
24423       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24424     } CALL_CATCH_EXCEPTION();
24425   }
24426
24427 }
24428
24429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24430   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24431   Dali::Animation *arg2 = 0 ;
24432   Dali::Vector3 *arg3 = 0 ;
24433
24434   arg1 = (Dali::CustomActorImpl *)jarg1;
24435   arg2 = (Dali::Animation *)jarg2;
24436   if (!arg2) {
24437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24438     return ;
24439   }
24440   arg3 = (Dali::Vector3 *)jarg3;
24441   if (!arg3) {
24442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24443     return ;
24444   }
24445   {
24446     try {
24447       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24448     } CALL_CATCH_EXCEPTION();
24449   }
24450 }
24451
24452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24453   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24454   Dali::Vector2 *arg2 = 0 ;
24455   Dali::RelayoutContainer *arg3 = 0 ;
24456
24457   arg1 = (Dali::CustomActorImpl *)jarg1;
24458   arg2 = (Dali::Vector2 *)jarg2;
24459   if (!arg2) {
24460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24461     return ;
24462   }
24463   arg3 = (Dali::RelayoutContainer *)jarg3;
24464   if (!arg3) {
24465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24466     return ;
24467   }
24468   {
24469     try {
24470       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24471     } CALL_CATCH_EXCEPTION();
24472   }
24473
24474 }
24475
24476
24477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24478   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24479   Dali::ResizePolicy::Type arg2 ;
24480   Dali::Dimension::Type arg3 ;
24481
24482   arg1 = (Dali::CustomActorImpl *)jarg1;
24483   arg2 = (Dali::ResizePolicy::Type)jarg2;
24484   arg3 = (Dali::Dimension::Type)jarg3;
24485   {
24486     try {
24487       (arg1)->OnSetResizePolicy(arg2,arg3);
24488     } CALL_CATCH_EXCEPTION();
24489   }
24490
24491 }
24492
24493
24494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24495   void * jresult ;
24496   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24497   Dali::Vector3 result;
24498
24499   arg1 = (Dali::CustomActorImpl *)jarg1;
24500   {
24501     try {
24502       result = (arg1)->GetNaturalSize();
24503     } CALL_CATCH_EXCEPTION(0);
24504   }
24505
24506   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24507   return jresult;
24508 }
24509
24510
24511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24512   float jresult ;
24513   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24514   Dali::Actor *arg2 = 0 ;
24515   Dali::Dimension::Type arg3 ;
24516   float result;
24517
24518   arg1 = (Dali::CustomActorImpl *)jarg1;
24519   arg2 = (Dali::Actor *)jarg2;
24520   if (!arg2) {
24521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24522     return 0;
24523   }
24524   arg3 = (Dali::Dimension::Type)jarg3;
24525   {
24526     try {
24527       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24528     } CALL_CATCH_EXCEPTION(0);
24529   }
24530
24531   jresult = result;
24532   return jresult;
24533 }
24534
24535
24536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24537   float jresult ;
24538   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24539   float arg2 ;
24540   float result;
24541
24542   arg1 = (Dali::CustomActorImpl *)jarg1;
24543   arg2 = (float)jarg2;
24544   {
24545     try {
24546       result = (float)(arg1)->GetHeightForWidth(arg2);
24547     } CALL_CATCH_EXCEPTION(0);
24548   }
24549
24550   jresult = result;
24551   return jresult;
24552 }
24553
24554
24555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24556   float jresult ;
24557   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24558   float arg2 ;
24559   float result;
24560
24561   arg1 = (Dali::CustomActorImpl *)jarg1;
24562   arg2 = (float)jarg2;
24563   {
24564     try {
24565       result = (float)(arg1)->GetWidthForHeight(arg2);
24566     } CALL_CATCH_EXCEPTION(0);
24567   }
24568
24569   jresult = result;
24570   return jresult;
24571 }
24572
24573
24574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24575   unsigned int jresult ;
24576   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24577   Dali::Dimension::Type arg2 ;
24578   bool result;
24579
24580   arg1 = (Dali::CustomActorImpl *)jarg1;
24581   arg2 = (Dali::Dimension::Type)jarg2;
24582   {
24583     try {
24584       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24585     } CALL_CATCH_EXCEPTION(0);
24586   }
24587
24588   jresult = result;
24589   return jresult;
24590 }
24591
24592
24593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24594   unsigned int jresult ;
24595   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24596   bool result;
24597
24598   arg1 = (Dali::CustomActorImpl *)jarg1;
24599   {
24600     try {
24601       result = (bool)(arg1)->RelayoutDependentOnChildren();
24602     } CALL_CATCH_EXCEPTION(0);
24603   }
24604
24605   jresult = result;
24606   return jresult;
24607 }
24608
24609
24610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24611   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24612   Dali::Dimension::Type arg2 ;
24613
24614   arg1 = (Dali::CustomActorImpl *)jarg1;
24615   arg2 = (Dali::Dimension::Type)jarg2;
24616   {
24617     try {
24618       (arg1)->OnCalculateRelayoutSize(arg2);
24619     } CALL_CATCH_EXCEPTION();
24620   }
24621
24622 }
24623
24624
24625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24626   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24627   float arg2 ;
24628   Dali::Dimension::Type arg3 ;
24629
24630   arg1 = (Dali::CustomActorImpl *)jarg1;
24631   arg2 = (float)jarg2;
24632   arg3 = (Dali::Dimension::Type)jarg3;
24633   {
24634     try {
24635       (arg1)->OnLayoutNegotiated(arg2,arg3);
24636     } CALL_CATCH_EXCEPTION();
24637   }
24638
24639 }
24640
24641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
24642   unsigned int jresult ;
24643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24644   bool result;
24645
24646   arg1 = (Dali::CustomActorImpl *)jarg1;
24647   {
24648     try {
24649       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
24650     } CALL_CATCH_EXCEPTION(0);
24651   }
24652
24653   jresult = result;
24654   return jresult;
24655 }
24656
24657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24658   void * jresult ;
24659   Dali::CustomActor *result = 0 ;
24660
24661   {
24662     try {
24663       result = (Dali::CustomActor *)new Dali::CustomActor();
24664     } CALL_CATCH_EXCEPTION(0);
24665   }
24666
24667   jresult = (void *)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24673   void * jresult ;
24674   Dali::BaseHandle arg1 ;
24675   Dali::BaseHandle *argp1 ;
24676   Dali::CustomActor result;
24677
24678   argp1 = (Dali::BaseHandle *)jarg1;
24679   if (!argp1) {
24680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24681     return 0;
24682   }
24683   arg1 = *argp1;
24684   {
24685     try {
24686       result = Dali::CustomActor::DownCast(arg1);
24687     } CALL_CATCH_EXCEPTION(0);
24688   }
24689
24690   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24691   return jresult;
24692 }
24693
24694
24695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24696   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24697
24698   arg1 = (Dali::CustomActor *)jarg1;
24699   {
24700     try {
24701       delete arg1;
24702     } CALL_CATCH_EXCEPTION();
24703   }
24704
24705 }
24706
24707
24708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24709   void * jresult ;
24710   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24711   Dali::CustomActorImpl *result = 0 ;
24712
24713   arg1 = (Dali::CustomActor *)jarg1;
24714   {
24715     try {
24716       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24717     } CALL_CATCH_EXCEPTION(0);
24718   }
24719
24720   jresult = (void *)result;
24721   return jresult;
24722 }
24723
24724
24725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24726   void * jresult ;
24727   Dali::CustomActorImpl *arg1 = 0 ;
24728   Dali::CustomActor *result = 0 ;
24729
24730   arg1 = (Dali::CustomActorImpl *)jarg1;
24731   if (!arg1) {
24732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24733     return 0;
24734   }
24735   {
24736     try {
24737       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24738     } CALL_CATCH_EXCEPTION(0);
24739   }
24740
24741   jresult = (void *)result;
24742   return jresult;
24743 }
24744
24745
24746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24747   void * jresult ;
24748   Dali::CustomActor *arg1 = 0 ;
24749   Dali::CustomActor *result = 0 ;
24750
24751   arg1 = (Dali::CustomActor *)jarg1;
24752   if (!arg1) {
24753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24754     return 0;
24755   }
24756   {
24757     try {
24758       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24759     } CALL_CATCH_EXCEPTION(0);
24760   }
24761
24762   jresult = (void *)result;
24763   return jresult;
24764 }
24765
24766
24767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24768   void * jresult ;
24769   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24770   Dali::CustomActor *arg2 = 0 ;
24771   Dali::CustomActor *result = 0 ;
24772
24773   arg1 = (Dali::CustomActor *)jarg1;
24774   arg2 = (Dali::CustomActor *)jarg2;
24775   if (!arg2) {
24776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24777     return 0;
24778   }
24779   {
24780     try {
24781       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24782     } CALL_CATCH_EXCEPTION(0);
24783   }
24784
24785   jresult = (void *)result;
24786   return jresult;
24787 }
24788
24789
24790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24791   int jresult ;
24792   int result;
24793
24794   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24795   jresult = (int)result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24801   int jresult ;
24802   int result;
24803
24804   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24805   jresult = (int)result;
24806   return jresult;
24807 }
24808
24809
24810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24811   int jresult ;
24812   int result;
24813
24814   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24815   jresult = (int)result;
24816   return jresult;
24817 }
24818
24819
24820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24821   int jresult ;
24822   int result;
24823
24824   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24825   jresult = (int)result;
24826   return jresult;
24827 }
24828
24829
24830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24831   int jresult ;
24832   int result;
24833
24834   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24835   jresult = (int)result;
24836   return jresult;
24837 }
24838
24839
24840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24841   int jresult ;
24842   int result;
24843
24844   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24845   jresult = (int)result;
24846   return jresult;
24847 }
24848
24849
24850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24851   int jresult ;
24852   int result;
24853
24854   result = (int)Dali::PanGestureDetector::Property::PANNING;
24855   jresult = (int)result;
24856   return jresult;
24857 }
24858
24859
24860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24861   void * jresult ;
24862   Dali::PanGestureDetector::Property *result = 0 ;
24863
24864   {
24865     try {
24866       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24867     } CALL_CATCH_EXCEPTION(0);
24868   }
24869
24870   jresult = (void *)result;
24871   return jresult;
24872 }
24873
24874
24875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
24876   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
24877
24878   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
24879   {
24880     try {
24881       delete arg1;
24882     } CALL_CATCH_EXCEPTION();
24883   }
24884
24885 }
24886
24887
24888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
24889   void * jresult ;
24890   Dali::Radian *result = 0 ;
24891
24892   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
24893   jresult = (void *)result;
24894   return jresult;
24895 }
24896
24897
24898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
24899   void * jresult ;
24900   Dali::Radian *result = 0 ;
24901
24902   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
24903   jresult = (void *)result;
24904   return jresult;
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
24909   void * jresult ;
24910   Dali::Radian *result = 0 ;
24911
24912   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
24913   jresult = (void *)result;
24914   return jresult;
24915 }
24916
24917
24918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
24919   void * jresult ;
24920   Dali::Radian *result = 0 ;
24921
24922   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
24923   jresult = (void *)result;
24924   return jresult;
24925 }
24926
24927
24928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
24929   void * jresult ;
24930   Dali::Radian *result = 0 ;
24931
24932   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
24933   jresult = (void *)result;
24934   return jresult;
24935 }
24936
24937
24938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
24939   void * jresult ;
24940   Dali::Radian *result = 0 ;
24941
24942   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
24943   jresult = (void *)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
24949   void * jresult ;
24950   Dali::Radian *result = 0 ;
24951
24952   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
24953   jresult = (void *)result;
24954   return jresult;
24955 }
24956
24957
24958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
24959   void * jresult ;
24960   Dali::PanGestureDetector *result = 0 ;
24961
24962   {
24963     try {
24964       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
24965     } CALL_CATCH_EXCEPTION(0);
24966   }
24967
24968   jresult = (void *)result;
24969   return jresult;
24970 }
24971
24972
24973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
24974   void * jresult ;
24975   Dali::PanGestureDetector result;
24976
24977   {
24978     try {
24979       result = Dali::PanGestureDetector::New();
24980     } CALL_CATCH_EXCEPTION(0);
24981   }
24982
24983   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
24984   return jresult;
24985 }
24986
24987
24988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
24989   void * jresult ;
24990   Dali::BaseHandle arg1 ;
24991   Dali::BaseHandle *argp1 ;
24992   Dali::PanGestureDetector result;
24993
24994   argp1 = (Dali::BaseHandle *)jarg1;
24995   if (!argp1) {
24996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24997     return 0;
24998   }
24999   arg1 = *argp1;
25000   {
25001     try {
25002       result = Dali::PanGestureDetector::DownCast(arg1);
25003     } CALL_CATCH_EXCEPTION(0);
25004   }
25005
25006   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25007   return jresult;
25008 }
25009
25010
25011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25012   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25013
25014   arg1 = (Dali::PanGestureDetector *)jarg1;
25015   {
25016     try {
25017       delete arg1;
25018     } CALL_CATCH_EXCEPTION();
25019   }
25020
25021 }
25022
25023
25024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25025   void * jresult ;
25026   Dali::PanGestureDetector *arg1 = 0 ;
25027   Dali::PanGestureDetector *result = 0 ;
25028
25029   arg1 = (Dali::PanGestureDetector *)jarg1;
25030   if (!arg1) {
25031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25032     return 0;
25033   }
25034   {
25035     try {
25036       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25037     } CALL_CATCH_EXCEPTION(0);
25038   }
25039
25040   jresult = (void *)result;
25041   return jresult;
25042 }
25043
25044
25045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25046   void * jresult ;
25047   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25048   Dali::PanGestureDetector *arg2 = 0 ;
25049   Dali::PanGestureDetector *result = 0 ;
25050
25051   arg1 = (Dali::PanGestureDetector *)jarg1;
25052   arg2 = (Dali::PanGestureDetector *)jarg2;
25053   if (!arg2) {
25054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25055     return 0;
25056   }
25057   {
25058     try {
25059       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25060     } CALL_CATCH_EXCEPTION(0);
25061   }
25062
25063   jresult = (void *)result;
25064   return jresult;
25065 }
25066
25067
25068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25069   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25070   unsigned int arg2 ;
25071
25072   arg1 = (Dali::PanGestureDetector *)jarg1;
25073   arg2 = (unsigned int)jarg2;
25074   {
25075     try {
25076       (arg1)->SetMinimumTouchesRequired(arg2);
25077     } CALL_CATCH_EXCEPTION();
25078   }
25079
25080 }
25081
25082
25083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25084   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25085   unsigned int arg2 ;
25086
25087   arg1 = (Dali::PanGestureDetector *)jarg1;
25088   arg2 = (unsigned int)jarg2;
25089   {
25090     try {
25091       (arg1)->SetMaximumTouchesRequired(arg2);
25092     } CALL_CATCH_EXCEPTION();
25093   }
25094
25095 }
25096
25097
25098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25099   unsigned int jresult ;
25100   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25101   unsigned int result;
25102
25103   arg1 = (Dali::PanGestureDetector *)jarg1;
25104   {
25105     try {
25106       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25107     } CALL_CATCH_EXCEPTION(0);
25108   }
25109
25110   jresult = result;
25111   return jresult;
25112 }
25113
25114
25115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25116   unsigned int jresult ;
25117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25118   unsigned int result;
25119
25120   arg1 = (Dali::PanGestureDetector *)jarg1;
25121   {
25122     try {
25123       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25124     } CALL_CATCH_EXCEPTION(0);
25125   }
25126
25127   jresult = result;
25128   return jresult;
25129 }
25130
25131
25132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25133   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25134   Dali::Radian arg2 ;
25135   Dali::Radian arg3 ;
25136   Dali::Radian *argp2 ;
25137   Dali::Radian *argp3 ;
25138
25139   arg1 = (Dali::PanGestureDetector *)jarg1;
25140   argp2 = (Dali::Radian *)jarg2;
25141   if (!argp2) {
25142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25143     return ;
25144   }
25145   arg2 = *argp2;
25146   argp3 = (Dali::Radian *)jarg3;
25147   if (!argp3) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25149     return ;
25150   }
25151   arg3 = *argp3;
25152   {
25153     try {
25154       (arg1)->AddAngle(arg2,arg3);
25155     } CALL_CATCH_EXCEPTION();
25156   }
25157
25158 }
25159
25160
25161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25162   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25163   Dali::Radian arg2 ;
25164   Dali::Radian *argp2 ;
25165
25166   arg1 = (Dali::PanGestureDetector *)jarg1;
25167   argp2 = (Dali::Radian *)jarg2;
25168   if (!argp2) {
25169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25170     return ;
25171   }
25172   arg2 = *argp2;
25173   {
25174     try {
25175       (arg1)->AddAngle(arg2);
25176     } CALL_CATCH_EXCEPTION();
25177   }
25178
25179 }
25180
25181
25182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25183   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25184   Dali::Radian arg2 ;
25185   Dali::Radian arg3 ;
25186   Dali::Radian *argp2 ;
25187   Dali::Radian *argp3 ;
25188
25189   arg1 = (Dali::PanGestureDetector *)jarg1;
25190   argp2 = (Dali::Radian *)jarg2;
25191   if (!argp2) {
25192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25193     return ;
25194   }
25195   arg2 = *argp2;
25196   argp3 = (Dali::Radian *)jarg3;
25197   if (!argp3) {
25198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25199     return ;
25200   }
25201   arg3 = *argp3;
25202   {
25203     try {
25204       (arg1)->AddDirection(arg2,arg3);
25205     } CALL_CATCH_EXCEPTION();
25206   }
25207
25208 }
25209
25210
25211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25212   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25213   Dali::Radian arg2 ;
25214   Dali::Radian *argp2 ;
25215
25216   arg1 = (Dali::PanGestureDetector *)jarg1;
25217   argp2 = (Dali::Radian *)jarg2;
25218   if (!argp2) {
25219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25220     return ;
25221   }
25222   arg2 = *argp2;
25223   {
25224     try {
25225       (arg1)->AddDirection(arg2);
25226     } CALL_CATCH_EXCEPTION();
25227   }
25228
25229 }
25230
25231
25232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25233   unsigned long jresult ;
25234   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25235   size_t result;
25236
25237   arg1 = (Dali::PanGestureDetector *)jarg1;
25238   {
25239     try {
25240       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25241     } CALL_CATCH_EXCEPTION(0);
25242   }
25243
25244   jresult = (unsigned long)result;
25245   return jresult;
25246 }
25247
25248
25249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25250   void * jresult ;
25251   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25252   size_t arg2 ;
25253   Dali::PanGestureDetector::AngleThresholdPair result;
25254
25255   arg1 = (Dali::PanGestureDetector *)jarg1;
25256   arg2 = (size_t)jarg2;
25257   {
25258     try {
25259       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25260     } CALL_CATCH_EXCEPTION(0);
25261   }
25262
25263   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25264   return jresult;
25265 }
25266
25267
25268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25269   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25270
25271   arg1 = (Dali::PanGestureDetector *)jarg1;
25272   {
25273     try {
25274       (arg1)->ClearAngles();
25275     } CALL_CATCH_EXCEPTION();
25276   }
25277
25278 }
25279
25280
25281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25282   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25283   Dali::Radian arg2 ;
25284   Dali::Radian *argp2 ;
25285
25286   arg1 = (Dali::PanGestureDetector *)jarg1;
25287   argp2 = (Dali::Radian *)jarg2;
25288   if (!argp2) {
25289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25290     return ;
25291   }
25292   arg2 = *argp2;
25293   {
25294     try {
25295       (arg1)->RemoveAngle(arg2);
25296     } CALL_CATCH_EXCEPTION();
25297   }
25298
25299 }
25300
25301
25302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25303   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25304   Dali::Radian arg2 ;
25305   Dali::Radian *argp2 ;
25306
25307   arg1 = (Dali::PanGestureDetector *)jarg1;
25308   argp2 = (Dali::Radian *)jarg2;
25309   if (!argp2) {
25310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25311     return ;
25312   }
25313   arg2 = *argp2;
25314   {
25315     try {
25316       (arg1)->RemoveDirection(arg2);
25317     } CALL_CATCH_EXCEPTION();
25318   }
25319
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25324   void * jresult ;
25325   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25326   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25327
25328   arg1 = (Dali::PanGestureDetector *)jarg1;
25329   {
25330     try {
25331       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25332     } CALL_CATCH_EXCEPTION(0);
25333   }
25334
25335   jresult = (void *)result;
25336   return jresult;
25337 }
25338
25339
25340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25341   Dali::PanGesture *arg1 = 0 ;
25342
25343   arg1 = (Dali::PanGesture *)jarg1;
25344   if (!arg1) {
25345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25346     return ;
25347   }
25348   {
25349     try {
25350       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25351     } CALL_CATCH_EXCEPTION();
25352   }
25353
25354 }
25355
25356
25357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25358   void * jresult ;
25359   Dali::PanGesture *result = 0 ;
25360
25361   {
25362     try {
25363       result = (Dali::PanGesture *)new Dali::PanGesture();
25364     } CALL_CATCH_EXCEPTION(0);
25365   }
25366
25367   jresult = (void *)result;
25368   return jresult;
25369 }
25370
25371 // Need to delete this
25372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25373   void * jresult ;
25374   Dali::GestureState arg1 ;
25375   Dali::PanGesture *result = 0 ;
25376
25377   arg1 = (Dali::GestureState)jarg1;
25378   {
25379     try {
25380       result = (Dali::PanGesture *)new Dali::PanGesture();
25381     } catch (std::out_of_range& e) {
25382       {
25383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (std::exception& e) {
25386       {
25387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25388       };
25389     } catch (Dali::DaliException e) {
25390       {
25391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25392       };
25393     } catch (...) {
25394       {
25395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25396       };
25397     }
25398   }
25399
25400   jresult = (void *)result;
25401   return jresult;
25402 }
25403
25404
25405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25406   void * jresult ;
25407   Dali::PanGesture *arg1 = 0 ;
25408   Dali::PanGesture *result = 0 ;
25409
25410   arg1 = (Dali::PanGesture *)jarg1;
25411   if (!arg1) {
25412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25413     return 0;
25414   }
25415   {
25416     try {
25417       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25418     } CALL_CATCH_EXCEPTION(0);
25419   }
25420
25421   jresult = (void *)result;
25422   return jresult;
25423 }
25424
25425
25426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25427   void * jresult ;
25428   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25429   Dali::PanGesture *arg2 = 0 ;
25430   Dali::PanGesture *result = 0 ;
25431
25432   arg1 = (Dali::PanGesture *)jarg1;
25433   arg2 = (Dali::PanGesture *)jarg2;
25434   if (!arg2) {
25435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25436     return 0;
25437   }
25438   {
25439     try {
25440       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25441     } CALL_CATCH_EXCEPTION(0);
25442   }
25443
25444   jresult = (void *)result;
25445   return jresult;
25446 }
25447
25448
25449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25450   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25451
25452   arg1 = (Dali::PanGesture *)jarg1;
25453   {
25454     try {
25455       delete arg1;
25456     } CALL_CATCH_EXCEPTION();
25457   }
25458
25459 }
25460
25461
25462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25463   void * jresult ;
25464   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25465   Dali::Vector2 result;
25466
25467   arg1 = (Dali::PanGesture *)jarg1;
25468   {
25469     try {
25470       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (Dali::DaliException e) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25495   void * jresult ;
25496   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25497   Dali::Vector2 result;
25498
25499   arg1 = (Dali::PanGesture *)jarg1;
25500   {
25501     try {
25502       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
25503     } catch (std::out_of_range& e) {
25504       {
25505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25506       };
25507     } catch (std::exception& e) {
25508       {
25509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25510       };
25511     } catch (Dali::DaliException e) {
25512       {
25513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25514       };
25515     } catch (...) {
25516       {
25517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25518       };
25519     }
25520   }
25521   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25522   return jresult;
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25527   void * jresult ;
25528   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25529   Dali::Vector2 result;
25530
25531   arg1 = (Dali::PanGesture *)jarg1;
25532   {
25533     try {
25534       result = ((Dali::PanGesture const *)arg1)->GetPosition();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (Dali::DaliException e) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25546       };
25547     } catch (...) {
25548       {
25549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25550       };
25551     }
25552   }
25553   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25554   return jresult;
25555 }
25556
25557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25558   void * jresult ;
25559   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25560   Dali::Vector2 result;
25561
25562   arg1 = (Dali::PanGesture *)jarg1;
25563   {
25564     try {
25565       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
25566     } catch (std::out_of_range& e) {
25567       {
25568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25569       };
25570     } catch (std::exception& e) {
25571       {
25572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25573       };
25574     } catch (Dali::DaliException e) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25581       };
25582     }
25583   }
25584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25585   return jresult;
25586 }
25587
25588
25589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25590   void * jresult ;
25591   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25592   Dali::Vector2 result;
25593
25594   arg1 = (Dali::PanGesture *)jarg1;
25595   {
25596     try {
25597       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
25598     } catch (std::out_of_range& e) {
25599       {
25600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25601       };
25602     } catch (std::exception& e) {
25603       {
25604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25605       };
25606     } catch (Dali::DaliException e) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25609       };
25610     } catch (...) {
25611       {
25612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25613       };
25614     }
25615   }
25616   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25617   return jresult;
25618 }
25619
25620
25621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25622   void * jresult ;
25623   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25624   Dali::Vector2 result;
25625
25626   arg1 = (Dali::PanGesture *)jarg1;
25627   {
25628     try {
25629       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
25630     } catch (std::out_of_range& e) {
25631       {
25632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25633       };
25634     } catch (std::exception& e) {
25635       {
25636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25637       };
25638     } catch (Dali::DaliException e) {
25639       {
25640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25641       };
25642     } catch (...) {
25643       {
25644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25645       };
25646     }
25647   }
25648   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25649   return jresult;
25650 }
25651
25652
25653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25654   unsigned int jresult ;
25655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25656   unsigned int result;
25657
25658   arg1 = (Dali::PanGesture *)jarg1;
25659   result = (unsigned int) ((arg1)->GetNumberOfTouches());
25660   jresult = result;
25661   return jresult;
25662 }
25663
25664
25665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25666   float jresult ;
25667   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25668   float result;
25669
25670   arg1 = (Dali::PanGesture *)jarg1;
25671   {
25672     try {
25673       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25674     } CALL_CATCH_EXCEPTION(0);
25675   }
25676
25677   jresult = result;
25678   return jresult;
25679 }
25680
25681
25682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
25683   float jresult ;
25684   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25685   float result;
25686
25687   arg1 = (Dali::PanGesture *)jarg1;
25688   {
25689     try {
25690       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
25691     } CALL_CATCH_EXCEPTION(0);
25692   }
25693
25694   jresult = result;
25695   return jresult;
25696 }
25697
25698
25699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
25700   float jresult ;
25701   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25702   float result;
25703
25704   arg1 = (Dali::PanGesture *)jarg1;
25705   {
25706     try {
25707       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
25708     } CALL_CATCH_EXCEPTION(0);
25709   }
25710
25711   jresult = result;
25712   return jresult;
25713 }
25714
25715
25716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
25717   float jresult ;
25718   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25719   float result;
25720
25721   arg1 = (Dali::PanGesture *)jarg1;
25722   {
25723     try {
25724       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
25725     } CALL_CATCH_EXCEPTION(0);
25726   }
25727
25728   jresult = result;
25729   return jresult;
25730 }
25731
25732
25733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25734   void * jresult ;
25735   Dali::PinchGestureDetector *result = 0 ;
25736
25737   {
25738     try {
25739       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25740     } CALL_CATCH_EXCEPTION(0);
25741   }
25742
25743   jresult = (void *)result;
25744   return jresult;
25745 }
25746
25747
25748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25749   void * jresult ;
25750   Dali::PinchGestureDetector result;
25751
25752   {
25753     try {
25754       result = Dali::PinchGestureDetector::New();
25755     } CALL_CATCH_EXCEPTION(0);
25756   }
25757
25758   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25759   return jresult;
25760 }
25761
25762
25763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25764   void * jresult ;
25765   Dali::BaseHandle arg1 ;
25766   Dali::BaseHandle *argp1 ;
25767   Dali::PinchGestureDetector result;
25768
25769   argp1 = (Dali::BaseHandle *)jarg1;
25770   if (!argp1) {
25771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25772     return 0;
25773   }
25774   arg1 = *argp1;
25775   {
25776     try {
25777       result = Dali::PinchGestureDetector::DownCast(arg1);
25778     } CALL_CATCH_EXCEPTION(0);
25779   }
25780
25781   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25782   return jresult;
25783 }
25784
25785
25786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25787   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25788
25789   arg1 = (Dali::PinchGestureDetector *)jarg1;
25790   {
25791     try {
25792       delete arg1;
25793     } CALL_CATCH_EXCEPTION();
25794   }
25795
25796 }
25797
25798
25799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25800   void * jresult ;
25801   Dali::PinchGestureDetector *arg1 = 0 ;
25802   Dali::PinchGestureDetector *result = 0 ;
25803
25804   arg1 = (Dali::PinchGestureDetector *)jarg1;
25805   if (!arg1) {
25806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25807     return 0;
25808   }
25809   {
25810     try {
25811       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25812     } CALL_CATCH_EXCEPTION(0);
25813   }
25814
25815   jresult = (void *)result;
25816   return jresult;
25817 }
25818
25819
25820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25821   void * jresult ;
25822   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25823   Dali::PinchGestureDetector *arg2 = 0 ;
25824   Dali::PinchGestureDetector *result = 0 ;
25825
25826   arg1 = (Dali::PinchGestureDetector *)jarg1;
25827   arg2 = (Dali::PinchGestureDetector *)jarg2;
25828   if (!arg2) {
25829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25830     return 0;
25831   }
25832   {
25833     try {
25834       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25835     } CALL_CATCH_EXCEPTION(0);
25836   }
25837
25838   jresult = (void *)result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25844   void * jresult ;
25845   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25846   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25847
25848   arg1 = (Dali::PinchGestureDetector *)jarg1;
25849   {
25850     try {
25851       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25852     } CALL_CATCH_EXCEPTION(0);
25853   }
25854
25855   jresult = (void *)result;
25856   return jresult;
25857 }
25858
25859
25860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
25861   void * jresult ;
25862   Dali::PinchGesture *result = 0 ;
25863
25864   {
25865     try {
25866       result = (Dali::PinchGesture *)new Dali::PinchGesture();
25867     } CALL_CATCH_EXCEPTION(0);
25868   }
25869
25870   jresult = (void *)result;
25871   return jresult;
25872 }
25873
25874
25875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25876   void * jresult ;
25877   Dali::PinchGesture *arg1 = 0 ;
25878   Dali::PinchGesture *result = 0 ;
25879
25880   arg1 = (Dali::PinchGesture *)jarg1;
25881   if (!arg1) {
25882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25883     return 0;
25884   }
25885   {
25886     try {
25887       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
25888     } CALL_CATCH_EXCEPTION(0);
25889   }
25890
25891   jresult = (void *)result;
25892   return jresult;
25893 }
25894
25895
25896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
25897   void * jresult ;
25898   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25899   Dali::PinchGesture *arg2 = 0 ;
25900   Dali::PinchGesture *result = 0 ;
25901
25902   arg1 = (Dali::PinchGesture *)jarg1;
25903   arg2 = (Dali::PinchGesture *)jarg2;
25904   if (!arg2) {
25905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25906     return 0;
25907   }
25908   {
25909     try {
25910       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
25911     } CALL_CATCH_EXCEPTION(0);
25912   }
25913
25914   jresult = (void *)result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
25920   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25921
25922   arg1 = (Dali::PinchGesture *)jarg1;
25923   {
25924     try {
25925       delete arg1;
25926     } CALL_CATCH_EXCEPTION();
25927   }
25928
25929 }
25930
25931
25932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
25933   float jresult ;
25934   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25935   float result;
25936
25937   arg1 = (Dali::PinchGesture *)jarg1;
25938   result = (float) ((arg1)->GetScale());
25939   jresult = result;
25940   return jresult;
25941 }
25942
25943
25944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
25945   float jresult ;
25946   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25947   float result;
25948
25949   arg1 = (Dali::PinchGesture *)jarg1;
25950   result = (float) ((arg1)->GetSpeed());
25951   jresult = result;
25952   return jresult;
25953 }
25954
25955
25956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
25957   void * jresult ;
25958   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25959   Dali::Vector2 result;
25960
25961   arg1 = (Dali::PinchGesture *)jarg1;
25962   {
25963     try {
25964       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
25965     } catch (std::out_of_range& e) {
25966       {
25967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25968       };
25969     } catch (std::exception& e) {
25970       {
25971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25972       };
25973     } catch (Dali::DaliException e) {
25974       {
25975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25976       };
25977     } catch (...) {
25978       {
25979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25980       };
25981     }
25982   }
25983   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25984   return jresult;
25985 }
25986
25987
25988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
25989   void * jresult ;
25990   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25991   Dali::Vector2 result;
25992
25993   arg1 = (Dali::PinchGesture *)jarg1;
25994   {
25995     try {
25996       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26004       };
26005     } catch (Dali::DaliException e) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26008       };
26009     } catch (...) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26012       };
26013     }
26014   }
26015   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26016   return jresult;
26017 }
26018
26019
26020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26021   void * jresult ;
26022   Dali::TapGestureDetector *result = 0 ;
26023
26024   {
26025     try {
26026       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26027     } CALL_CATCH_EXCEPTION(0);
26028   }
26029
26030   jresult = (void *)result;
26031   return jresult;
26032 }
26033
26034
26035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26036   void * jresult ;
26037   Dali::TapGestureDetector result;
26038
26039   {
26040     try {
26041       result = Dali::TapGestureDetector::New();
26042     } CALL_CATCH_EXCEPTION(0);
26043   }
26044
26045   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26046   return jresult;
26047 }
26048
26049
26050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26051   void * jresult ;
26052   unsigned int arg1 ;
26053   Dali::TapGestureDetector result;
26054
26055   arg1 = (unsigned int)jarg1;
26056   {
26057     try {
26058       result = Dali::TapGestureDetector::New(arg1);
26059     } CALL_CATCH_EXCEPTION(0);
26060   }
26061
26062   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26063   return jresult;
26064 }
26065
26066
26067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26068   void * jresult ;
26069   Dali::BaseHandle arg1 ;
26070   Dali::BaseHandle *argp1 ;
26071   Dali::TapGestureDetector result;
26072
26073   argp1 = (Dali::BaseHandle *)jarg1;
26074   if (!argp1) {
26075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26076     return 0;
26077   }
26078   arg1 = *argp1;
26079   {
26080     try {
26081       result = Dali::TapGestureDetector::DownCast(arg1);
26082     } CALL_CATCH_EXCEPTION(0);
26083   }
26084
26085   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26086   return jresult;
26087 }
26088
26089
26090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26091   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26092
26093   arg1 = (Dali::TapGestureDetector *)jarg1;
26094   {
26095     try {
26096       delete arg1;
26097     } CALL_CATCH_EXCEPTION();
26098   }
26099
26100 }
26101
26102
26103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26104   void * jresult ;
26105   Dali::TapGestureDetector *arg1 = 0 ;
26106   Dali::TapGestureDetector *result = 0 ;
26107
26108   arg1 = (Dali::TapGestureDetector *)jarg1;
26109   if (!arg1) {
26110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26111     return 0;
26112   }
26113   {
26114     try {
26115       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26116     } CALL_CATCH_EXCEPTION(0);
26117   }
26118
26119   jresult = (void *)result;
26120   return jresult;
26121 }
26122
26123
26124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26125   void * jresult ;
26126   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26127   Dali::TapGestureDetector *arg2 = 0 ;
26128   Dali::TapGestureDetector *result = 0 ;
26129
26130   arg1 = (Dali::TapGestureDetector *)jarg1;
26131   arg2 = (Dali::TapGestureDetector *)jarg2;
26132   if (!arg2) {
26133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26134     return 0;
26135   }
26136   {
26137     try {
26138       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26139     } CALL_CATCH_EXCEPTION(0);
26140   }
26141
26142   jresult = (void *)result;
26143   return jresult;
26144 }
26145
26146
26147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26148   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26149   unsigned int arg2 ;
26150
26151   arg1 = (Dali::TapGestureDetector *)jarg1;
26152   arg2 = (unsigned int)jarg2;
26153   {
26154     try {
26155       (arg1)->SetMinimumTapsRequired(arg2);
26156     } CALL_CATCH_EXCEPTION();
26157   }
26158
26159 }
26160
26161
26162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26163   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26164   unsigned int arg2 ;
26165
26166   arg1 = (Dali::TapGestureDetector *)jarg1;
26167   arg2 = (unsigned int)jarg2;
26168   {
26169     try {
26170       (arg1)->SetMaximumTapsRequired(arg2);
26171     } CALL_CATCH_EXCEPTION();
26172   }
26173
26174 }
26175
26176
26177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26178   unsigned int jresult ;
26179   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26180   unsigned int result;
26181
26182   arg1 = (Dali::TapGestureDetector *)jarg1;
26183   {
26184     try {
26185       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26186     } CALL_CATCH_EXCEPTION(0);
26187   }
26188
26189   jresult = result;
26190   return jresult;
26191 }
26192
26193
26194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
26195   unsigned int jresult ;
26196   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26197   unsigned int result;
26198
26199   arg1 = (Dali::TapGestureDetector *)jarg1;
26200   {
26201     try {
26202       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
26203     } CALL_CATCH_EXCEPTION(0);
26204   }
26205
26206   jresult = result;
26207   return jresult;
26208 }
26209
26210
26211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26212   void * jresult ;
26213   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26214   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26215
26216   arg1 = (Dali::TapGestureDetector *)jarg1;
26217   {
26218     try {
26219       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26220     } CALL_CATCH_EXCEPTION(0);
26221   }
26222
26223   jresult = (void *)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26229   void * jresult ;
26230   Dali::TapGesture *result = 0 ;
26231
26232   {
26233     try {
26234       result = (Dali::TapGesture *)new Dali::TapGesture();
26235     } CALL_CATCH_EXCEPTION(0);
26236   }
26237
26238   jresult = (void *)result;
26239   return jresult;
26240 }
26241
26242
26243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26244   void * jresult ;
26245   Dali::TapGesture *arg1 = 0 ;
26246   Dali::TapGesture *result = 0 ;
26247
26248   arg1 = (Dali::TapGesture *)jarg1;
26249   if (!arg1) {
26250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26251     return 0;
26252   }
26253   {
26254     try {
26255       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26256     } CALL_CATCH_EXCEPTION(0);
26257   }
26258
26259   jresult = (void *)result;
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26265   void * jresult ;
26266   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26267   Dali::TapGesture *arg2 = 0 ;
26268   Dali::TapGesture *result = 0 ;
26269
26270   arg1 = (Dali::TapGesture *)jarg1;
26271   arg2 = (Dali::TapGesture *)jarg2;
26272   if (!arg2) {
26273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26274     return 0;
26275   }
26276   {
26277     try {
26278       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26279     } CALL_CATCH_EXCEPTION(0);
26280   }
26281
26282   jresult = (void *)result;
26283   return jresult;
26284 }
26285
26286
26287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26288   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26289
26290   arg1 = (Dali::TapGesture *)jarg1;
26291   {
26292     try {
26293       delete arg1;
26294     } CALL_CATCH_EXCEPTION();
26295   }
26296
26297 }
26298
26299
26300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26301   unsigned int jresult ;
26302   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26303   unsigned int result;
26304
26305   arg1 = (Dali::TapGesture *)jarg1;
26306   result = (unsigned int) ((arg1)->GetNumberOfTaps());
26307   jresult = result;
26308   return jresult;
26309 }
26310
26311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26312   unsigned int jresult ;
26313   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26314   unsigned int result;
26315
26316   arg1 = (Dali::TapGesture *)jarg1;
26317   result = (unsigned int) ((arg1)->GetNumberOfTouches());
26318   jresult = result;
26319   return jresult;
26320 }
26321
26322
26323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26324   void * jresult ;
26325   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26326   Dali::Vector2 result;
26327
26328   arg1 = (Dali::TapGesture *)jarg1;
26329   {
26330     try {
26331       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
26332     } catch (std::out_of_range& e) {
26333       {
26334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26335       };
26336     } catch (std::exception& e) {
26337       {
26338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26339       };
26340     } catch (Dali::DaliException e) {
26341       {
26342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26343       };
26344     } catch (...) {
26345       {
26346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26347       };
26348     }
26349   }
26350   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26351   return jresult;
26352 }
26353
26354
26355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26356   void * jresult ;
26357   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26358   Dali::Vector2 result;
26359
26360   arg1 = (Dali::TapGesture *)jarg1;
26361   {
26362     try {
26363       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
26364     } catch (std::out_of_range& e) {
26365       {
26366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26367       };
26368     } catch (std::exception& e) {
26369       {
26370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26371       };
26372     } catch (Dali::DaliException e) {
26373       {
26374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26375       };
26376     } catch (...) {
26377       {
26378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26379       };
26380     }
26381   }
26382   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26388   void * jresult ;
26389   Dali::AlphaFunction *result = 0 ;
26390
26391   {
26392     try {
26393       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26394     } CALL_CATCH_EXCEPTION(0);
26395   }
26396
26397   jresult = (void *)result;
26398   return jresult;
26399 }
26400
26401
26402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26403   void * jresult ;
26404   Dali::AlphaFunction::BuiltinFunction arg1 ;
26405   Dali::AlphaFunction *result = 0 ;
26406
26407   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26408   {
26409     try {
26410       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26411     } CALL_CATCH_EXCEPTION(0);
26412   }
26413
26414   jresult = (void *)result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
26420   void * jresult ;
26421   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26422   Dali::AlphaFunction *result = 0 ;
26423
26424   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
26425   {
26426     try {
26427       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26428     } CALL_CATCH_EXCEPTION(0);
26429   }
26430
26431   jresult = (void *)result;
26432   return jresult;
26433 }
26434
26435
26436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
26437   void * jresult ;
26438   Dali::Vector2 *arg1 = 0 ;
26439   Dali::Vector2 *arg2 = 0 ;
26440   Dali::AlphaFunction *result = 0 ;
26441
26442   arg1 = (Dali::Vector2 *)jarg1;
26443   if (!arg1) {
26444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26445     return 0;
26446   }
26447   arg2 = (Dali::Vector2 *)jarg2;
26448   if (!arg2) {
26449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26450     return 0;
26451   }
26452   {
26453     try {
26454       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26455     } CALL_CATCH_EXCEPTION(0);
26456   }
26457
26458   jresult = (void *)result;
26459   return jresult;
26460 }
26461
26462
26463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26464   void * jresult ;
26465   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26466   Dali::Vector4 result;
26467
26468   arg1 = (Dali::AlphaFunction *)jarg1;
26469   {
26470     try {
26471       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26472     } CALL_CATCH_EXCEPTION(0);
26473   }
26474
26475   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26476   return jresult;
26477 }
26478
26479
26480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26481   void * jresult ;
26482   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26483   Dali::AlphaFunctionPrototype result;
26484
26485   arg1 = (Dali::AlphaFunction *)jarg1;
26486   {
26487     try {
26488       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26489     } CALL_CATCH_EXCEPTION(0);
26490   }
26491
26492   jresult = (void *)result;
26493   return jresult;
26494 }
26495
26496
26497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26498   int jresult ;
26499   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26500   Dali::AlphaFunction::BuiltinFunction result;
26501
26502   arg1 = (Dali::AlphaFunction *)jarg1;
26503   {
26504     try {
26505       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26506     } CALL_CATCH_EXCEPTION(0);
26507   }
26508
26509   jresult = (int)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26515   int jresult ;
26516   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26517   Dali::AlphaFunction::Mode result;
26518
26519   arg1 = (Dali::AlphaFunction *)jarg1;
26520   {
26521     try {
26522       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26523     } CALL_CATCH_EXCEPTION(0);
26524   }
26525
26526   jresult = (int)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26532   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26533
26534   arg1 = (Dali::AlphaFunction *)jarg1;
26535   {
26536     try {
26537       delete arg1;
26538     } CALL_CATCH_EXCEPTION();
26539   }
26540
26541 }
26542
26543
26544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26545   void * jresult ;
26546   Dali::KeyFrames result;
26547
26548   {
26549     try {
26550       result = Dali::KeyFrames::New();
26551     } CALL_CATCH_EXCEPTION(0);
26552   }
26553
26554   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26560   void * jresult ;
26561   Dali::BaseHandle arg1 ;
26562   Dali::BaseHandle *argp1 ;
26563   Dali::KeyFrames result;
26564
26565   argp1 = (Dali::BaseHandle *)jarg1;
26566   if (!argp1) {
26567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26568     return 0;
26569   }
26570   arg1 = *argp1;
26571   {
26572     try {
26573       result = Dali::KeyFrames::DownCast(arg1);
26574     } CALL_CATCH_EXCEPTION(0);
26575   }
26576
26577   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26578   return jresult;
26579 }
26580
26581
26582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26583   void * jresult ;
26584   Dali::KeyFrames *result = 0 ;
26585
26586   {
26587     try {
26588       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26589     } CALL_CATCH_EXCEPTION(0);
26590   }
26591
26592   jresult = (void *)result;
26593   return jresult;
26594 }
26595
26596
26597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26598   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26599
26600   arg1 = (Dali::KeyFrames *)jarg1;
26601   {
26602     try {
26603       delete arg1;
26604     } CALL_CATCH_EXCEPTION();
26605   }
26606
26607 }
26608
26609
26610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26611   void * jresult ;
26612   Dali::KeyFrames *arg1 = 0 ;
26613   Dali::KeyFrames *result = 0 ;
26614
26615   arg1 = (Dali::KeyFrames *)jarg1;
26616   if (!arg1) {
26617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26618     return 0;
26619   }
26620   {
26621     try {
26622       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26623     } CALL_CATCH_EXCEPTION(0);
26624   }
26625
26626   jresult = (void *)result;
26627   return jresult;
26628 }
26629
26630
26631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26632   void * jresult ;
26633   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26634   Dali::KeyFrames *arg2 = 0 ;
26635   Dali::KeyFrames *result = 0 ;
26636
26637   arg1 = (Dali::KeyFrames *)jarg1;
26638   arg2 = (Dali::KeyFrames *)jarg2;
26639   if (!arg2) {
26640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26641     return 0;
26642   }
26643   {
26644     try {
26645       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26646     } CALL_CATCH_EXCEPTION(0);
26647   }
26648
26649   jresult = (void *)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26655   int jresult ;
26656   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26657   Dali::Property::Type result;
26658
26659   arg1 = (Dali::KeyFrames *)jarg1;
26660   {
26661     try {
26662       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26663     } CALL_CATCH_EXCEPTION(0);
26664   }
26665
26666   jresult = (int)result;
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26672   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26673   float arg2 ;
26674   Dali::Property::Value arg3 ;
26675   Dali::Property::Value *argp3 ;
26676
26677   arg1 = (Dali::KeyFrames *)jarg1;
26678   arg2 = (float)jarg2;
26679   argp3 = (Dali::Property::Value *)jarg3;
26680   if (!argp3) {
26681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26682     return ;
26683   }
26684   arg3 = *argp3;
26685   {
26686     try {
26687       (arg1)->Add(arg2,arg3);
26688     } CALL_CATCH_EXCEPTION();
26689   }
26690
26691 }
26692
26693
26694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26695   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26696   float arg2 ;
26697   Dali::Property::Value arg3 ;
26698   Dali::AlphaFunction arg4 ;
26699   Dali::Property::Value *argp3 ;
26700   Dali::AlphaFunction *argp4 ;
26701
26702   arg1 = (Dali::KeyFrames *)jarg1;
26703   arg2 = (float)jarg2;
26704   argp3 = (Dali::Property::Value *)jarg3;
26705   if (!argp3) {
26706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26707     return ;
26708   }
26709   arg3 = *argp3;
26710   argp4 = (Dali::AlphaFunction *)jarg4;
26711   if (!argp4) {
26712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26713     return ;
26714   }
26715   arg4 = *argp4;
26716   {
26717     try {
26718       (arg1)->Add(arg2,arg3,arg4);
26719     } CALL_CATCH_EXCEPTION();
26720   }
26721
26722 }
26723
26724
26725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26726   int jresult ;
26727   int result;
26728
26729   result = (int)Dali::Path::Property::POINTS;
26730   jresult = (int)result;
26731   return jresult;
26732 }
26733
26734
26735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26736   int jresult ;
26737   int result;
26738
26739   result = (int)Dali::Path::Property::CONTROL_POINTS;
26740   jresult = (int)result;
26741   return jresult;
26742 }
26743
26744
26745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26746   void * jresult ;
26747   Dali::Path::Property *result = 0 ;
26748
26749   {
26750     try {
26751       result = (Dali::Path::Property *)new Dali::Path::Property();
26752     } CALL_CATCH_EXCEPTION(0);
26753   }
26754
26755   jresult = (void *)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26761   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26762
26763   arg1 = (Dali::Path::Property *)jarg1;
26764   {
26765     try {
26766       delete arg1;
26767     } CALL_CATCH_EXCEPTION();
26768   }
26769
26770 }
26771
26772
26773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26774   void * jresult ;
26775   Dali::Path result;
26776
26777   {
26778     try {
26779       result = Dali::Path::New();
26780     } CALL_CATCH_EXCEPTION(0);
26781   }
26782
26783   jresult = new Dali::Path((const Dali::Path &)result);
26784   return jresult;
26785 }
26786
26787
26788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26789   void * jresult ;
26790   Dali::BaseHandle arg1 ;
26791   Dali::BaseHandle *argp1 ;
26792   Dali::Path result;
26793
26794   argp1 = (Dali::BaseHandle *)jarg1;
26795   if (!argp1) {
26796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26797     return 0;
26798   }
26799   arg1 = *argp1;
26800   {
26801     try {
26802       result = Dali::Path::DownCast(arg1);
26803     } CALL_CATCH_EXCEPTION(0);
26804   }
26805
26806   jresult = new Dali::Path((const Dali::Path &)result);
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26812   void * jresult ;
26813   Dali::Path *result = 0 ;
26814
26815   {
26816     try {
26817       result = (Dali::Path *)new Dali::Path();
26818     } CALL_CATCH_EXCEPTION(0);
26819   }
26820
26821   jresult = (void *)result;
26822   return jresult;
26823 }
26824
26825
26826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26827   Dali::Path *arg1 = (Dali::Path *) 0 ;
26828
26829   arg1 = (Dali::Path *)jarg1;
26830   {
26831     try {
26832       delete arg1;
26833     } CALL_CATCH_EXCEPTION();
26834   }
26835
26836 }
26837
26838
26839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26840   void * jresult ;
26841   Dali::Path *arg1 = 0 ;
26842   Dali::Path *result = 0 ;
26843
26844   arg1 = (Dali::Path *)jarg1;
26845   if (!arg1) {
26846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26847     return 0;
26848   }
26849   {
26850     try {
26851       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26852     } CALL_CATCH_EXCEPTION(0);
26853   }
26854
26855   jresult = (void *)result;
26856   return jresult;
26857 }
26858
26859
26860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26861   void * jresult ;
26862   Dali::Path *arg1 = (Dali::Path *) 0 ;
26863   Dali::Path *arg2 = 0 ;
26864   Dali::Path *result = 0 ;
26865
26866   arg1 = (Dali::Path *)jarg1;
26867   arg2 = (Dali::Path *)jarg2;
26868   if (!arg2) {
26869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26870     return 0;
26871   }
26872   {
26873     try {
26874       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26875     } CALL_CATCH_EXCEPTION(0);
26876   }
26877
26878   jresult = (void *)result;
26879   return jresult;
26880 }
26881
26882
26883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
26884   Dali::Path *arg1 = (Dali::Path *) 0 ;
26885   Dali::Vector3 *arg2 = 0 ;
26886
26887   arg1 = (Dali::Path *)jarg1;
26888   arg2 = (Dali::Vector3 *)jarg2;
26889   if (!arg2) {
26890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26891     return ;
26892   }
26893   {
26894     try {
26895       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
26896     } CALL_CATCH_EXCEPTION();
26897   }
26898
26899 }
26900
26901
26902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
26903   Dali::Path *arg1 = (Dali::Path *) 0 ;
26904   Dali::Vector3 *arg2 = 0 ;
26905
26906   arg1 = (Dali::Path *)jarg1;
26907   arg2 = (Dali::Vector3 *)jarg2;
26908   if (!arg2) {
26909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26910     return ;
26911   }
26912   {
26913     try {
26914       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
26915     } CALL_CATCH_EXCEPTION();
26916   }
26917
26918 }
26919
26920
26921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
26922   Dali::Path *arg1 = (Dali::Path *) 0 ;
26923   float arg2 ;
26924
26925   arg1 = (Dali::Path *)jarg1;
26926   arg2 = (float)jarg2;
26927   {
26928     try {
26929       (arg1)->GenerateControlPoints(arg2);
26930     } CALL_CATCH_EXCEPTION();
26931   }
26932
26933 }
26934
26935
26936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26937   Dali::Path *arg1 = (Dali::Path *) 0 ;
26938   float arg2 ;
26939   Dali::Vector3 *arg3 = 0 ;
26940   Dali::Vector3 *arg4 = 0 ;
26941
26942   arg1 = (Dali::Path *)jarg1;
26943   arg2 = (float)jarg2;
26944   arg3 = (Dali::Vector3 *)jarg3;
26945   if (!arg3) {
26946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
26947     return ;
26948   }
26949   arg4 = (Dali::Vector3 *)jarg4;
26950   if (!arg4) {
26951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
26952     return ;
26953   }
26954   {
26955     try {
26956       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
26957     } CALL_CATCH_EXCEPTION();
26958   }
26959
26960 }
26961
26962
26963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
26964   void * jresult ;
26965   Dali::Path *arg1 = (Dali::Path *) 0 ;
26966   size_t arg2 ;
26967   Dali::Vector3 *result = 0 ;
26968
26969   arg1 = (Dali::Path *)jarg1;
26970   arg2 = (size_t)jarg2;
26971   {
26972     try {
26973       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
26974     } CALL_CATCH_EXCEPTION(0);
26975   }
26976
26977   jresult = (void *)result;
26978   return jresult;
26979 }
26980
26981
26982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
26983   void * jresult ;
26984   Dali::Path *arg1 = (Dali::Path *) 0 ;
26985   size_t arg2 ;
26986   Dali::Vector3 *result = 0 ;
26987
26988   arg1 = (Dali::Path *)jarg1;
26989   arg2 = (size_t)jarg2;
26990   {
26991     try {
26992       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
26993     } CALL_CATCH_EXCEPTION(0);
26994   }
26995
26996   jresult = (void *)result;
26997   return jresult;
26998 }
26999
27000
27001 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27002   unsigned long jresult ;
27003   Dali::Path *arg1 = (Dali::Path *) 0 ;
27004   size_t result;
27005
27006   arg1 = (Dali::Path *)jarg1;
27007   {
27008     try {
27009       result = ((Dali::Path const *)arg1)->GetPointCount();
27010     } CALL_CATCH_EXCEPTION(0);
27011   }
27012
27013   jresult = (unsigned long)result;
27014   return jresult;
27015 }
27016
27017
27018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27019   void * jresult ;
27020   float arg1 ;
27021   Dali::TimePeriod *result = 0 ;
27022
27023   arg1 = (float)jarg1;
27024   {
27025     try {
27026       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27027     } CALL_CATCH_EXCEPTION(0);
27028   }
27029
27030   jresult = (void *)result;
27031   return jresult;
27032 }
27033
27034
27035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27036   void * jresult ;
27037   float arg1 ;
27038   float arg2 ;
27039   Dali::TimePeriod *result = 0 ;
27040
27041   arg1 = (float)jarg1;
27042   arg2 = (float)jarg2;
27043   {
27044     try {
27045       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27046     } CALL_CATCH_EXCEPTION(0);
27047   }
27048
27049   jresult = (void *)result;
27050   return jresult;
27051 }
27052
27053
27054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27055   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27056
27057   arg1 = (Dali::TimePeriod *)jarg1;
27058   {
27059     try {
27060       delete arg1;
27061     } CALL_CATCH_EXCEPTION();
27062   }
27063
27064 }
27065
27066
27067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27068   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27069   float arg2 ;
27070
27071   arg1 = (Dali::TimePeriod *)jarg1;
27072   arg2 = (float)jarg2;
27073   if (arg1) (arg1)->delaySeconds = arg2;
27074 }
27075
27076
27077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27078   float jresult ;
27079   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27080   float result;
27081
27082   arg1 = (Dali::TimePeriod *)jarg1;
27083   result = (float) ((arg1)->delaySeconds);
27084   jresult = result;
27085   return jresult;
27086 }
27087
27088
27089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27090   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27091   float arg2 ;
27092
27093   arg1 = (Dali::TimePeriod *)jarg1;
27094   arg2 = (float)jarg2;
27095   if (arg1) (arg1)->durationSeconds = arg2;
27096 }
27097
27098
27099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27100   float jresult ;
27101   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27102   float result;
27103
27104   arg1 = (Dali::TimePeriod *)jarg1;
27105   result = (float) ((arg1)->durationSeconds);
27106   jresult = result;
27107   return jresult;
27108 }
27109
27110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27111   int jresult ;
27112   int result;
27113
27114   result = (int)Dali::LinearConstrainer::Property::VALUE;
27115   jresult = (int)result;
27116   return jresult;
27117 }
27118
27119
27120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27121   int jresult ;
27122   int result;
27123
27124   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27125   jresult = (int)result;
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27131   void * jresult ;
27132   Dali::LinearConstrainer::Property *result = 0 ;
27133
27134   {
27135     try {
27136       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27137     } CALL_CATCH_EXCEPTION(0);
27138   }
27139
27140   jresult = (void *)result;
27141   return jresult;
27142 }
27143
27144
27145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27146   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27147
27148   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27149   {
27150     try {
27151       delete arg1;
27152     } CALL_CATCH_EXCEPTION();
27153   }
27154
27155 }
27156
27157
27158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27159   void * jresult ;
27160   Dali::LinearConstrainer result;
27161
27162   {
27163     try {
27164       result = Dali::LinearConstrainer::New();
27165     } CALL_CATCH_EXCEPTION(0);
27166   }
27167
27168   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27169   return jresult;
27170 }
27171
27172
27173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27174   void * jresult ;
27175   Dali::BaseHandle arg1 ;
27176   Dali::BaseHandle *argp1 ;
27177   Dali::LinearConstrainer result;
27178
27179   argp1 = (Dali::BaseHandle *)jarg1;
27180   if (!argp1) {
27181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27182     return 0;
27183   }
27184   arg1 = *argp1;
27185   {
27186     try {
27187       result = Dali::LinearConstrainer::DownCast(arg1);
27188     } CALL_CATCH_EXCEPTION(0);
27189   }
27190
27191   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27192   return jresult;
27193 }
27194
27195
27196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27197   void * jresult ;
27198   Dali::LinearConstrainer *result = 0 ;
27199
27200   {
27201     try {
27202       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27203     } CALL_CATCH_EXCEPTION(0);
27204   }
27205
27206   jresult = (void *)result;
27207   return jresult;
27208 }
27209
27210
27211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27212   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27213
27214   arg1 = (Dali::LinearConstrainer *)jarg1;
27215   {
27216     try {
27217       delete arg1;
27218     } CALL_CATCH_EXCEPTION();
27219   }
27220
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27225   void * jresult ;
27226   Dali::LinearConstrainer *arg1 = 0 ;
27227   Dali::LinearConstrainer *result = 0 ;
27228
27229   arg1 = (Dali::LinearConstrainer *)jarg1;
27230   if (!arg1) {
27231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27232     return 0;
27233   }
27234   {
27235     try {
27236       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27237     } CALL_CATCH_EXCEPTION(0);
27238   }
27239
27240   jresult = (void *)result;
27241   return jresult;
27242 }
27243
27244
27245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27246   void * jresult ;
27247   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27248   Dali::LinearConstrainer *arg2 = 0 ;
27249   Dali::LinearConstrainer *result = 0 ;
27250
27251   arg1 = (Dali::LinearConstrainer *)jarg1;
27252   arg2 = (Dali::LinearConstrainer *)jarg2;
27253   if (!arg2) {
27254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27255     return 0;
27256   }
27257   {
27258     try {
27259       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27260     } CALL_CATCH_EXCEPTION(0);
27261   }
27262
27263   jresult = (void *)result;
27264   return jresult;
27265 }
27266
27267
27268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27269   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27270   SwigValueWrapper< Dali::Property > arg2 ;
27271   SwigValueWrapper< Dali::Property > arg3 ;
27272   Dali::Vector2 *arg4 = 0 ;
27273   Dali::Vector2 *arg5 = 0 ;
27274   Dali::Property *argp2 ;
27275   Dali::Property *argp3 ;
27276
27277   arg1 = (Dali::LinearConstrainer *)jarg1;
27278   argp2 = (Dali::Property *)jarg2;
27279   if (!argp2) {
27280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27281     return ;
27282   }
27283   arg2 = *argp2;
27284   argp3 = (Dali::Property *)jarg3;
27285   if (!argp3) {
27286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27287     return ;
27288   }
27289   arg3 = *argp3;
27290   arg4 = (Dali::Vector2 *)jarg4;
27291   if (!arg4) {
27292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27293     return ;
27294   }
27295   arg5 = (Dali::Vector2 *)jarg5;
27296   if (!arg5) {
27297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27298     return ;
27299   }
27300   {
27301     try {
27302       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27303     } CALL_CATCH_EXCEPTION();
27304   }
27305
27306 }
27307
27308
27309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27310   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27311   SwigValueWrapper< Dali::Property > arg2 ;
27312   SwigValueWrapper< Dali::Property > arg3 ;
27313   Dali::Vector2 *arg4 = 0 ;
27314   Dali::Property *argp2 ;
27315   Dali::Property *argp3 ;
27316
27317   arg1 = (Dali::LinearConstrainer *)jarg1;
27318   argp2 = (Dali::Property *)jarg2;
27319   if (!argp2) {
27320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27321     return ;
27322   }
27323   arg2 = *argp2;
27324   argp3 = (Dali::Property *)jarg3;
27325   if (!argp3) {
27326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27327     return ;
27328   }
27329   arg3 = *argp3;
27330   arg4 = (Dali::Vector2 *)jarg4;
27331   if (!arg4) {
27332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27333     return ;
27334   }
27335   {
27336     try {
27337       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27338     } CALL_CATCH_EXCEPTION();
27339   }
27340
27341 }
27342
27343
27344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27345   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27346   Dali::Handle *arg2 = 0 ;
27347
27348   arg1 = (Dali::LinearConstrainer *)jarg1;
27349   arg2 = (Dali::Handle *)jarg2;
27350   if (!arg2) {
27351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27352     return ;
27353   }
27354   {
27355     try {
27356       (arg1)->Remove(*arg2);
27357     } CALL_CATCH_EXCEPTION();
27358   }
27359
27360 }
27361
27362
27363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27364   int jresult ;
27365   int result;
27366
27367   result = (int)Dali::PathConstrainer::Property::FORWARD;
27368   jresult = (int)result;
27369   return jresult;
27370 }
27371
27372
27373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27374   int jresult ;
27375   int result;
27376
27377   result = (int)Dali::PathConstrainer::Property::POINTS;
27378   jresult = (int)result;
27379   return jresult;
27380 }
27381
27382
27383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27384   int jresult ;
27385   int result;
27386
27387   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27388   jresult = (int)result;
27389   return jresult;
27390 }
27391
27392
27393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27394   void * jresult ;
27395   Dali::PathConstrainer::Property *result = 0 ;
27396
27397   {
27398     try {
27399       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27400     } CALL_CATCH_EXCEPTION(0);
27401   }
27402
27403   jresult = (void *)result;
27404   return jresult;
27405 }
27406
27407
27408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27409   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27410
27411   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27412   {
27413     try {
27414       delete arg1;
27415     } CALL_CATCH_EXCEPTION();
27416   }
27417
27418 }
27419
27420
27421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27422   void * jresult ;
27423   Dali::PathConstrainer result;
27424
27425   {
27426     try {
27427       result = Dali::PathConstrainer::New();
27428     } CALL_CATCH_EXCEPTION(0);
27429   }
27430
27431   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27437   void * jresult ;
27438   Dali::BaseHandle arg1 ;
27439   Dali::BaseHandle *argp1 ;
27440   Dali::PathConstrainer result;
27441
27442   argp1 = (Dali::BaseHandle *)jarg1;
27443   if (!argp1) {
27444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27445     return 0;
27446   }
27447   arg1 = *argp1;
27448   {
27449     try {
27450       result = Dali::PathConstrainer::DownCast(arg1);
27451     } CALL_CATCH_EXCEPTION(0);
27452   }
27453
27454   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27455   return jresult;
27456 }
27457
27458
27459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27460   void * jresult ;
27461   Dali::PathConstrainer *result = 0 ;
27462
27463   {
27464     try {
27465       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27466     } CALL_CATCH_EXCEPTION(0);
27467   }
27468
27469   jresult = (void *)result;
27470   return jresult;
27471 }
27472
27473
27474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27475   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27476
27477   arg1 = (Dali::PathConstrainer *)jarg1;
27478   {
27479     try {
27480       delete arg1;
27481     } CALL_CATCH_EXCEPTION();
27482   }
27483
27484 }
27485
27486
27487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27488   void * jresult ;
27489   Dali::PathConstrainer *arg1 = 0 ;
27490   Dali::PathConstrainer *result = 0 ;
27491
27492   arg1 = (Dali::PathConstrainer *)jarg1;
27493   if (!arg1) {
27494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27495     return 0;
27496   }
27497   {
27498     try {
27499       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27500     } CALL_CATCH_EXCEPTION(0);
27501   }
27502
27503   jresult = (void *)result;
27504   return jresult;
27505 }
27506
27507
27508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27509   void * jresult ;
27510   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27511   Dali::PathConstrainer *arg2 = 0 ;
27512   Dali::PathConstrainer *result = 0 ;
27513
27514   arg1 = (Dali::PathConstrainer *)jarg1;
27515   arg2 = (Dali::PathConstrainer *)jarg2;
27516   if (!arg2) {
27517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27518     return 0;
27519   }
27520   {
27521     try {
27522       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27523     } CALL_CATCH_EXCEPTION(0);
27524   }
27525
27526   jresult = (void *)result;
27527   return jresult;
27528 }
27529
27530
27531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27532   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27533   SwigValueWrapper< Dali::Property > arg2 ;
27534   SwigValueWrapper< Dali::Property > arg3 ;
27535   Dali::Vector2 *arg4 = 0 ;
27536   Dali::Vector2 *arg5 = 0 ;
27537   Dali::Property *argp2 ;
27538   Dali::Property *argp3 ;
27539
27540   arg1 = (Dali::PathConstrainer *)jarg1;
27541   argp2 = (Dali::Property *)jarg2;
27542   if (!argp2) {
27543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27544     return ;
27545   }
27546   arg2 = *argp2;
27547   argp3 = (Dali::Property *)jarg3;
27548   if (!argp3) {
27549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27550     return ;
27551   }
27552   arg3 = *argp3;
27553   arg4 = (Dali::Vector2 *)jarg4;
27554   if (!arg4) {
27555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27556     return ;
27557   }
27558   arg5 = (Dali::Vector2 *)jarg5;
27559   if (!arg5) {
27560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27561     return ;
27562   }
27563   {
27564     try {
27565       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27566     } CALL_CATCH_EXCEPTION();
27567   }
27568
27569 }
27570
27571
27572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27573   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27574   SwigValueWrapper< Dali::Property > arg2 ;
27575   SwigValueWrapper< Dali::Property > arg3 ;
27576   Dali::Vector2 *arg4 = 0 ;
27577   Dali::Property *argp2 ;
27578   Dali::Property *argp3 ;
27579
27580   arg1 = (Dali::PathConstrainer *)jarg1;
27581   argp2 = (Dali::Property *)jarg2;
27582   if (!argp2) {
27583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27584     return ;
27585   }
27586   arg2 = *argp2;
27587   argp3 = (Dali::Property *)jarg3;
27588   if (!argp3) {
27589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27590     return ;
27591   }
27592   arg3 = *argp3;
27593   arg4 = (Dali::Vector2 *)jarg4;
27594   if (!arg4) {
27595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27596     return ;
27597   }
27598   {
27599     try {
27600       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27601     } CALL_CATCH_EXCEPTION();
27602   }
27603
27604 }
27605
27606
27607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27608   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27609   Dali::Handle *arg2 = 0 ;
27610
27611   arg1 = (Dali::PathConstrainer *)jarg1;
27612   arg2 = (Dali::Handle *)jarg2;
27613   if (!arg2) {
27614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27615     return ;
27616   }
27617   {
27618     try {
27619       (arg1)->Remove(*arg2);
27620     } CALL_CATCH_EXCEPTION();
27621   }
27622
27623 }
27624
27625
27626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27627   int jresult ;
27628   Dali::FittingMode::Type result;
27629
27630   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27631   jresult = (int)result;
27632   return jresult;
27633 }
27634
27635
27636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27637   int jresult ;
27638   Dali::SamplingMode::Type result;
27639
27640   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27641   jresult = (int)result;
27642   return jresult;
27643 }
27644
27645
27646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27647   unsigned int jresult ;
27648   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27649   bool result;
27650
27651   arg1 = (Dali::NativeImageInterface *)jarg1;
27652   {
27653     try {
27654       result = (bool)(arg1)->CreateResource();
27655     } CALL_CATCH_EXCEPTION(0);
27656   }
27657
27658   jresult = result;
27659   return jresult;
27660 }
27661
27662
27663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27664   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27665
27666   arg1 = (Dali::NativeImageInterface *)jarg1;
27667   {
27668     try {
27669       (arg1)->DestroyResource();
27670     } CALL_CATCH_EXCEPTION();
27671   }
27672
27673 }
27674
27675
27676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27677   unsigned int jresult ;
27678   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27679   unsigned int result;
27680
27681   arg1 = (Dali::NativeImageInterface *)jarg1;
27682   {
27683     try {
27684       result = (unsigned int)(arg1)->TargetTexture();
27685     } CALL_CATCH_EXCEPTION(0);
27686   }
27687
27688   jresult = result;
27689   return jresult;
27690 }
27691
27692
27693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27694   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27695
27696   arg1 = (Dali::NativeImageInterface *)jarg1;
27697   {
27698     try {
27699       (arg1)->PrepareTexture();
27700     } CALL_CATCH_EXCEPTION();
27701   }
27702
27703 }
27704
27705
27706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27707   unsigned int jresult ;
27708   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27709   unsigned int result;
27710
27711   arg1 = (Dali::NativeImageInterface *)jarg1;
27712   {
27713     try {
27714       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27715     } CALL_CATCH_EXCEPTION(0);
27716   }
27717
27718   jresult = result;
27719   return jresult;
27720 }
27721
27722
27723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
27724   unsigned int jresult ;
27725   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27726   unsigned int result;
27727
27728   arg1 = (Dali::NativeImageInterface *)jarg1;
27729   {
27730     try {
27731       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
27732     } CALL_CATCH_EXCEPTION(0);
27733   }
27734
27735   jresult = result;
27736   return jresult;
27737 }
27738
27739
27740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27741   unsigned int jresult ;
27742   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27743   bool result;
27744
27745   arg1 = (Dali::NativeImageInterface *)jarg1;
27746   {
27747     try {
27748       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27749     } CALL_CATCH_EXCEPTION(0);
27750   }
27751
27752   jresult = result;
27753   return jresult;
27754 }
27755
27756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27757   int jresult ;
27758   int result;
27759
27760   result = (int)Dali::CameraActor::Property::TYPE;
27761   jresult = (int)result;
27762   return jresult;
27763 }
27764
27765
27766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27767   int jresult ;
27768   int result;
27769
27770   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27771   jresult = (int)result;
27772   return jresult;
27773 }
27774
27775
27776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27777   int jresult ;
27778   int result;
27779
27780   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27781   jresult = (int)result;
27782   return jresult;
27783 }
27784
27785
27786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27787   int jresult ;
27788   int result;
27789
27790   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27791   jresult = (int)result;
27792   return jresult;
27793 }
27794
27795
27796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27797   int jresult ;
27798   int result;
27799
27800   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27801   jresult = (int)result;
27802   return jresult;
27803 }
27804
27805
27806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27807   int jresult ;
27808   int result;
27809
27810   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27811   jresult = (int)result;
27812   return jresult;
27813 }
27814
27815
27816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27817   int jresult ;
27818   int result;
27819
27820   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27821   jresult = (int)result;
27822   return jresult;
27823 }
27824
27825
27826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27827   int jresult ;
27828   int result;
27829
27830   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27831   jresult = (int)result;
27832   return jresult;
27833 }
27834
27835
27836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27837   int jresult ;
27838   int result;
27839
27840   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27841   jresult = (int)result;
27842   return jresult;
27843 }
27844
27845
27846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27847   int jresult ;
27848   int result;
27849
27850   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27851   jresult = (int)result;
27852   return jresult;
27853 }
27854
27855
27856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27857   int jresult ;
27858   int result;
27859
27860   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27861   jresult = (int)result;
27862   return jresult;
27863 }
27864
27865
27866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27867   int jresult ;
27868   int result;
27869
27870   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27871   jresult = (int)result;
27872   return jresult;
27873 }
27874
27875
27876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27877   int jresult ;
27878   int result;
27879
27880   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
27881   jresult = (int)result;
27882   return jresult;
27883 }
27884
27885
27886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
27887   int jresult ;
27888   int result;
27889
27890   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
27891   jresult = (int)result;
27892   return jresult;
27893 }
27894
27895
27896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
27897   void * jresult ;
27898   Dali::CameraActor::Property *result = 0 ;
27899
27900   {
27901     try {
27902       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
27903     } CALL_CATCH_EXCEPTION(0);
27904   }
27905
27906   jresult = (void *)result;
27907   return jresult;
27908 }
27909
27910
27911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
27912   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
27913
27914   arg1 = (Dali::CameraActor::Property *)jarg1;
27915   {
27916     try {
27917       delete arg1;
27918     } CALL_CATCH_EXCEPTION();
27919   }
27920
27921 }
27922
27923
27924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
27925   void * jresult ;
27926   Dali::CameraActor *result = 0 ;
27927
27928   {
27929     try {
27930       result = (Dali::CameraActor *)new Dali::CameraActor();
27931     } CALL_CATCH_EXCEPTION(0);
27932   }
27933
27934   jresult = (void *)result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
27940   void * jresult ;
27941   Dali::CameraActor result;
27942
27943   {
27944     try {
27945       result = Dali::CameraActor::New();
27946     } CALL_CATCH_EXCEPTION(0);
27947   }
27948
27949   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27950   return jresult;
27951 }
27952
27953
27954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
27955   void * jresult ;
27956   Dali::Size *arg1 = 0 ;
27957   Dali::CameraActor result;
27958
27959   arg1 = (Dali::Size *)jarg1;
27960   if (!arg1) {
27961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
27962     return 0;
27963   }
27964   {
27965     try {
27966       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
27967     } CALL_CATCH_EXCEPTION(0);
27968   }
27969
27970   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
27976   void * jresult ;
27977   Dali::BaseHandle arg1 ;
27978   Dali::BaseHandle *argp1 ;
27979   Dali::CameraActor result;
27980
27981   argp1 = (Dali::BaseHandle *)jarg1;
27982   if (!argp1) {
27983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27984     return 0;
27985   }
27986   arg1 = *argp1;
27987   {
27988     try {
27989       result = Dali::CameraActor::DownCast(arg1);
27990     } CALL_CATCH_EXCEPTION(0);
27991   }
27992
27993   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
27999   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28000
28001   arg1 = (Dali::CameraActor *)jarg1;
28002   {
28003     try {
28004       delete arg1;
28005     } CALL_CATCH_EXCEPTION();
28006   }
28007
28008 }
28009
28010
28011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28012   void * jresult ;
28013   Dali::CameraActor *arg1 = 0 ;
28014   Dali::CameraActor *result = 0 ;
28015
28016   arg1 = (Dali::CameraActor *)jarg1;
28017   if (!arg1) {
28018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28019     return 0;
28020   }
28021   {
28022     try {
28023       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28024     } CALL_CATCH_EXCEPTION(0);
28025   }
28026
28027   jresult = (void *)result;
28028   return jresult;
28029 }
28030
28031
28032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28033   void * jresult ;
28034   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28035   Dali::CameraActor *arg2 = 0 ;
28036   Dali::CameraActor *result = 0 ;
28037
28038   arg1 = (Dali::CameraActor *)jarg1;
28039   arg2 = (Dali::CameraActor *)jarg2;
28040   if (!arg2) {
28041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28042     return 0;
28043   }
28044   {
28045     try {
28046       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28047     } CALL_CATCH_EXCEPTION(0);
28048   }
28049
28050   jresult = (void *)result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28056   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28057   Dali::Camera::Type arg2 ;
28058
28059   arg1 = (Dali::CameraActor *)jarg1;
28060   arg2 = (Dali::Camera::Type)jarg2;
28061   {
28062     try {
28063       (arg1)->SetType(arg2);
28064     } CALL_CATCH_EXCEPTION();
28065   }
28066
28067 }
28068
28069
28070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28071   int jresult ;
28072   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28073   Dali::Camera::Type result;
28074
28075   arg1 = (Dali::CameraActor *)jarg1;
28076   {
28077     try {
28078       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28079     } CALL_CATCH_EXCEPTION(0);
28080   }
28081
28082   jresult = (int)result;
28083   return jresult;
28084 }
28085
28086
28087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28088   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28089   Dali::Camera::ProjectionMode arg2 ;
28090
28091   arg1 = (Dali::CameraActor *)jarg1;
28092   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28093   {
28094     try {
28095       (arg1)->SetProjectionMode(arg2);
28096     } CALL_CATCH_EXCEPTION();
28097   }
28098
28099 }
28100
28101
28102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28103   int jresult ;
28104   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28105   Dali::Camera::ProjectionMode result;
28106
28107   arg1 = (Dali::CameraActor *)jarg1;
28108   {
28109     try {
28110       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28111     } CALL_CATCH_EXCEPTION(0);
28112   }
28113
28114   jresult = (int)result;
28115   return jresult;
28116 }
28117
28118
28119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28120   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28121   float arg2 ;
28122
28123   arg1 = (Dali::CameraActor *)jarg1;
28124   arg2 = (float)jarg2;
28125   {
28126     try {
28127       (arg1)->SetFieldOfView(arg2);
28128     } CALL_CATCH_EXCEPTION();
28129   }
28130
28131 }
28132
28133
28134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28135   float jresult ;
28136   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28137   float result;
28138
28139   arg1 = (Dali::CameraActor *)jarg1;
28140   {
28141     try {
28142       result = (float)(arg1)->GetFieldOfView();
28143     } CALL_CATCH_EXCEPTION(0);
28144   }
28145
28146   jresult = result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28152   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28153   float arg2 ;
28154
28155   arg1 = (Dali::CameraActor *)jarg1;
28156   arg2 = (float)jarg2;
28157   {
28158     try {
28159       (arg1)->SetAspectRatio(arg2);
28160     } CALL_CATCH_EXCEPTION();
28161   }
28162
28163 }
28164
28165
28166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28167   float jresult ;
28168   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28169   float result;
28170
28171   arg1 = (Dali::CameraActor *)jarg1;
28172   {
28173     try {
28174       result = (float)(arg1)->GetAspectRatio();
28175     } CALL_CATCH_EXCEPTION(0);
28176   }
28177
28178   jresult = result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28184   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28185   float arg2 ;
28186
28187   arg1 = (Dali::CameraActor *)jarg1;
28188   arg2 = (float)jarg2;
28189   {
28190     try {
28191       (arg1)->SetNearClippingPlane(arg2);
28192     } CALL_CATCH_EXCEPTION();
28193   }
28194
28195 }
28196
28197
28198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28199   float jresult ;
28200   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28201   float result;
28202
28203   arg1 = (Dali::CameraActor *)jarg1;
28204   {
28205     try {
28206       result = (float)(arg1)->GetNearClippingPlane();
28207     } CALL_CATCH_EXCEPTION(0);
28208   }
28209
28210   jresult = result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28216   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28217   float arg2 ;
28218
28219   arg1 = (Dali::CameraActor *)jarg1;
28220   arg2 = (float)jarg2;
28221   {
28222     try {
28223       (arg1)->SetFarClippingPlane(arg2);
28224     } CALL_CATCH_EXCEPTION();
28225   }
28226
28227 }
28228
28229
28230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28231   float jresult ;
28232   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28233   float result;
28234
28235   arg1 = (Dali::CameraActor *)jarg1;
28236   {
28237     try {
28238       result = (float)(arg1)->GetFarClippingPlane();
28239     } CALL_CATCH_EXCEPTION(0);
28240   }
28241
28242   jresult = result;
28243   return jresult;
28244 }
28245
28246
28247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28249   Dali::Vector3 *arg2 = 0 ;
28250
28251   arg1 = (Dali::CameraActor *)jarg1;
28252   arg2 = (Dali::Vector3 *)jarg2;
28253   if (!arg2) {
28254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28255     return ;
28256   }
28257   {
28258     try {
28259       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28260     } CALL_CATCH_EXCEPTION();
28261   }
28262
28263 }
28264
28265
28266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28267   void * jresult ;
28268   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28269   Dali::Vector3 result;
28270
28271   arg1 = (Dali::CameraActor *)jarg1;
28272   {
28273     try {
28274       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28275     } CALL_CATCH_EXCEPTION(0);
28276   }
28277
28278   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28279   return jresult;
28280 }
28281
28282
28283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28284   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28285   bool arg2 ;
28286
28287   arg1 = (Dali::CameraActor *)jarg1;
28288   arg2 = jarg2 ? true : false;
28289   {
28290     try {
28291       (arg1)->SetInvertYAxis(arg2);
28292     } CALL_CATCH_EXCEPTION();
28293   }
28294
28295 }
28296
28297
28298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28299   unsigned int jresult ;
28300   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28301   bool result;
28302
28303   arg1 = (Dali::CameraActor *)jarg1;
28304   {
28305     try {
28306       result = (bool)(arg1)->GetInvertYAxis();
28307     } CALL_CATCH_EXCEPTION(0);
28308   }
28309
28310   jresult = result;
28311   return jresult;
28312 }
28313
28314
28315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28316   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28317   Dali::Size *arg2 = 0 ;
28318
28319   arg1 = (Dali::CameraActor *)jarg1;
28320   arg2 = (Dali::Size *)jarg2;
28321   if (!arg2) {
28322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28323     return ;
28324   }
28325   {
28326     try {
28327       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28328     } CALL_CATCH_EXCEPTION();
28329   }
28330
28331 }
28332
28333
28334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28336   Dali::Size *arg2 = 0 ;
28337
28338   arg1 = (Dali::CameraActor *)jarg1;
28339   arg2 = (Dali::Size *)jarg2;
28340   if (!arg2) {
28341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28342     return ;
28343   }
28344   {
28345     try {
28346       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28347     } CALL_CATCH_EXCEPTION();
28348   }
28349
28350 }
28351
28352
28353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28354   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28355   float arg2 ;
28356   float arg3 ;
28357   float arg4 ;
28358   float arg5 ;
28359   float arg6 ;
28360   float arg7 ;
28361
28362   arg1 = (Dali::CameraActor *)jarg1;
28363   arg2 = (float)jarg2;
28364   arg3 = (float)jarg3;
28365   arg4 = (float)jarg4;
28366   arg5 = (float)jarg5;
28367   arg6 = (float)jarg6;
28368   arg7 = (float)jarg7;
28369   {
28370     try {
28371       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28372     } CALL_CATCH_EXCEPTION();
28373   }
28374
28375 }
28376
28377
28378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28379   void * jresult ;
28380   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28381
28382   {
28383     try {
28384       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28385     } CALL_CATCH_EXCEPTION(0);
28386   }
28387
28388   jresult = (void *)result;
28389   return jresult;
28390 }
28391
28392
28393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28394   void * jresult ;
28395   std::string arg1 ;
28396   Dali::Property::Value arg2 ;
28397   Dali::Property::Value *argp2 ;
28398   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28399
28400   if (!jarg1) {
28401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28402     return 0;
28403   }
28404   (&arg1)->assign(jarg1);
28405   argp2 = (Dali::Property::Value *)jarg2;
28406   if (!argp2) {
28407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28408     return 0;
28409   }
28410   arg2 = *argp2;
28411   {
28412     try {
28413       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28414     } CALL_CATCH_EXCEPTION(0);
28415   }
28416
28417   jresult = (void *)result;
28418   return jresult;
28419 }
28420
28421
28422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28423   void * jresult ;
28424   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28425   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28426
28427   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28428   if (!arg1) {
28429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28430     return 0;
28431   }
28432   {
28433     try {
28434       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);
28435     } CALL_CATCH_EXCEPTION(0);
28436   }
28437
28438   jresult = (void *)result;
28439   return jresult;
28440 }
28441
28442
28443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28444   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28445   std::string *arg2 = 0 ;
28446
28447   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28448   if (!jarg2) {
28449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28450     return ;
28451   }
28452   std::string arg2_str(jarg2);
28453   arg2 = &arg2_str;
28454   if (arg1) (arg1)->first = *arg2;
28455
28456   //argout typemap for const std::string&
28457
28458 }
28459
28460
28461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28462   char * jresult ;
28463   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28464   std::string *result = 0 ;
28465
28466   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28467   result = (std::string *) & ((arg1)->first);
28468   jresult = SWIG_csharp_string_callback(result->c_str());
28469   return jresult;
28470 }
28471
28472
28473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28474   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28475   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28476
28477   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28478   arg2 = (Dali::Property::Value *)jarg2;
28479   if (arg1) (arg1)->second = *arg2;
28480 }
28481
28482
28483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28484   void * jresult ;
28485   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28486   Dali::Property::Value *result = 0 ;
28487
28488   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28489   result = (Dali::Property::Value *)& ((arg1)->second);
28490   jresult = (void *)result;
28491   return jresult;
28492 }
28493
28494
28495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28496   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28497
28498   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28499   {
28500     try {
28501       delete arg1;
28502     } CALL_CATCH_EXCEPTION();
28503   }
28504
28505 }
28506
28507
28508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28509   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28510
28511   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28512   {
28513     try {
28514       (arg1)->clear();
28515     } CALL_CATCH_EXCEPTION();
28516   }
28517
28518 }
28519
28520
28521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28522   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28523   Dali::TouchPoint *arg2 = 0 ;
28524
28525   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28526   arg2 = (Dali::TouchPoint *)jarg2;
28527   if (!arg2) {
28528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28529     return ;
28530   }
28531   {
28532     try {
28533       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28534     } CALL_CATCH_EXCEPTION();
28535   }
28536
28537 }
28538
28539
28540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28541   unsigned long jresult ;
28542   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28543   std::vector< Dali::TouchPoint >::size_type result;
28544
28545   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28546   {
28547     try {
28548       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28549     } CALL_CATCH_EXCEPTION(0);
28550   }
28551
28552   jresult = (unsigned long)result;
28553   return jresult;
28554 }
28555
28556
28557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
28558   unsigned long jresult ;
28559   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28560   std::vector< Dali::TouchPoint >::size_type result;
28561
28562   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28563   {
28564     try {
28565       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
28566     } CALL_CATCH_EXCEPTION(0);
28567   }
28568
28569   jresult = (unsigned long)result;
28570   return jresult;
28571 }
28572
28573
28574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28575   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28576   std::vector< Dali::TouchPoint >::size_type arg2 ;
28577
28578   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28579   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28580   {
28581     try {
28582       (arg1)->reserve(arg2);
28583     } CALL_CATCH_EXCEPTION();
28584   }
28585
28586 }
28587
28588
28589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28590   void * jresult ;
28591   std::vector< Dali::TouchPoint > *result = 0 ;
28592
28593   {
28594     try {
28595       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28596     } CALL_CATCH_EXCEPTION(0);
28597   }
28598
28599   jresult = (void *)result;
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28605   void * jresult ;
28606   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28607   std::vector< Dali::TouchPoint > *result = 0 ;
28608
28609   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28610   if (!arg1) {
28611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28612     return 0;
28613   }
28614   {
28615     try {
28616       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28617     } CALL_CATCH_EXCEPTION(0);
28618   }
28619
28620   jresult = (void *)result;
28621   return jresult;
28622 }
28623
28624
28625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28626   void * jresult ;
28627   int arg1 ;
28628   std::vector< Dali::TouchPoint > *result = 0 ;
28629
28630   arg1 = (int)jarg1;
28631   {
28632     try {
28633       try {
28634         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28635       }
28636       catch(std::out_of_range &_e) {
28637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28638         return 0;
28639       }
28640
28641     } CALL_CATCH_EXCEPTION(0);
28642   }
28643
28644   jresult = (void *)result;
28645   return jresult;
28646 }
28647
28648
28649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28650   void * jresult ;
28651   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28652   int arg2 ;
28653   SwigValueWrapper< Dali::TouchPoint > result;
28654
28655   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28656   arg2 = (int)jarg2;
28657   {
28658     try {
28659       try {
28660         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28661       }
28662       catch(std::out_of_range &_e) {
28663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28664         return 0;
28665       }
28666
28667     } CALL_CATCH_EXCEPTION(0);
28668   }
28669
28670   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28676   void * jresult ;
28677   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28678   int arg2 ;
28679   Dali::TouchPoint *result = 0 ;
28680
28681   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28682   arg2 = (int)jarg2;
28683   {
28684     try {
28685       try {
28686         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28687       }
28688       catch(std::out_of_range &_e) {
28689         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28690         return 0;
28691       }
28692
28693     } CALL_CATCH_EXCEPTION(0);
28694   }
28695
28696   jresult = (void *)result;
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28702   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28703   int arg2 ;
28704   Dali::TouchPoint *arg3 = 0 ;
28705
28706   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28707   arg2 = (int)jarg2;
28708   arg3 = (Dali::TouchPoint *)jarg3;
28709   if (!arg3) {
28710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28711     return ;
28712   }
28713   {
28714     try {
28715       try {
28716         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28717       }
28718       catch(std::out_of_range &_e) {
28719         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28720         return ;
28721       }
28722
28723     } CALL_CATCH_EXCEPTION();
28724   }
28725
28726 }
28727
28728
28729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28730   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28731   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28732
28733   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28734   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28735   if (!arg2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28737     return ;
28738   }
28739   {
28740     try {
28741       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28742     } CALL_CATCH_EXCEPTION();
28743   }
28744
28745 }
28746
28747
28748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28749   void * jresult ;
28750   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28751   int arg2 ;
28752   int arg3 ;
28753   std::vector< Dali::TouchPoint > *result = 0 ;
28754
28755   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28756   arg2 = (int)jarg2;
28757   arg3 = (int)jarg3;
28758   {
28759     try {
28760       try {
28761         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28762       }
28763       catch(std::out_of_range &_e) {
28764         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28765         return 0;
28766       }
28767       catch(std::invalid_argument &_e) {
28768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28769         return 0;
28770       }
28771
28772     } CALL_CATCH_EXCEPTION(0);
28773   }
28774
28775   jresult = (void *)result;
28776   return jresult;
28777 }
28778
28779
28780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28781   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28782   int arg2 ;
28783   Dali::TouchPoint *arg3 = 0 ;
28784
28785   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28786   arg2 = (int)jarg2;
28787   arg3 = (Dali::TouchPoint *)jarg3;
28788   if (!arg3) {
28789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28790     return ;
28791   }
28792   {
28793     try {
28794       try {
28795         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28796       }
28797       catch(std::out_of_range &_e) {
28798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28799         return ;
28800       }
28801
28802     } CALL_CATCH_EXCEPTION();
28803   }
28804
28805 }
28806
28807
28808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28809   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28810   int arg2 ;
28811   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28812
28813   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28814   arg2 = (int)jarg2;
28815   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28816   if (!arg3) {
28817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28818     return ;
28819   }
28820   {
28821     try {
28822       try {
28823         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28824       }
28825       catch(std::out_of_range &_e) {
28826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28827         return ;
28828       }
28829
28830     } CALL_CATCH_EXCEPTION();
28831   }
28832
28833 }
28834
28835
28836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28837   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28838   int arg2 ;
28839
28840   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28841   arg2 = (int)jarg2;
28842   {
28843     try {
28844       try {
28845         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28846       }
28847       catch(std::out_of_range &_e) {
28848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28849         return ;
28850       }
28851
28852     } CALL_CATCH_EXCEPTION();
28853   }
28854
28855 }
28856
28857
28858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28859   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28860   int arg2 ;
28861   int arg3 ;
28862
28863   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28864   arg2 = (int)jarg2;
28865   arg3 = (int)jarg3;
28866   {
28867     try {
28868       try {
28869         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28870       }
28871       catch(std::out_of_range &_e) {
28872         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28873         return ;
28874       }
28875       catch(std::invalid_argument &_e) {
28876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28877         return ;
28878       }
28879
28880     } CALL_CATCH_EXCEPTION();
28881   }
28882
28883 }
28884
28885
28886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
28887   void * jresult ;
28888   Dali::TouchPoint *arg1 = 0 ;
28889   int arg2 ;
28890   std::vector< Dali::TouchPoint > *result = 0 ;
28891
28892   arg1 = (Dali::TouchPoint *)jarg1;
28893   if (!arg1) {
28894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28895     return 0;
28896   }
28897   arg2 = (int)jarg2;
28898   {
28899     try {
28900       try {
28901         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
28902       }
28903       catch(std::out_of_range &_e) {
28904         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28905         return 0;
28906       }
28907
28908     } CALL_CATCH_EXCEPTION(0);
28909   }
28910
28911   jresult = (void *)result;
28912   return jresult;
28913 }
28914
28915
28916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
28917   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28918
28919   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28920   {
28921     try {
28922       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
28923     } CALL_CATCH_EXCEPTION();
28924   }
28925
28926 }
28927
28928
28929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
28930   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28931   int arg2 ;
28932   int arg3 ;
28933
28934   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28935   arg2 = (int)jarg2;
28936   arg3 = (int)jarg3;
28937   {
28938     try {
28939       try {
28940         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
28941       }
28942       catch(std::out_of_range &_e) {
28943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28944         return ;
28945       }
28946       catch(std::invalid_argument &_e) {
28947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28948         return ;
28949       }
28950
28951     } CALL_CATCH_EXCEPTION();
28952   }
28953
28954 }
28955
28956
28957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
28958   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28959   int arg2 ;
28960   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28961
28962   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28963   arg2 = (int)jarg2;
28964   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28965   if (!arg3) {
28966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28967     return ;
28968   }
28969   {
28970     try {
28971       try {
28972         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28973       }
28974       catch(std::out_of_range &_e) {
28975         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28976         return ;
28977       }
28978
28979     } CALL_CATCH_EXCEPTION();
28980   }
28981
28982 }
28983
28984
28985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
28986   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28987
28988   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28989   {
28990     try {
28991       delete arg1;
28992     } CALL_CATCH_EXCEPTION();
28993   }
28994
28995 }
28996
28997
28998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
28999   void * jresult ;
29000   Dali::Rect< int > *result = 0 ;
29001
29002   {
29003     try {
29004       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29005     } CALL_CATCH_EXCEPTION(0);
29006   }
29007
29008   jresult = (void *)result;
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29014   void * jresult ;
29015   int arg1 ;
29016   int arg2 ;
29017   int arg3 ;
29018   int arg4 ;
29019   Dali::Rect< int > *result = 0 ;
29020
29021   arg1 = (int)jarg1;
29022   arg2 = (int)jarg2;
29023   arg3 = (int)jarg3;
29024   arg4 = (int)jarg4;
29025   {
29026     try {
29027       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29028     } CALL_CATCH_EXCEPTION(0);
29029   }
29030
29031   jresult = (void *)result;
29032   return jresult;
29033 }
29034
29035
29036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29037   void * jresult ;
29038   Dali::Rect< int > *arg1 = 0 ;
29039   Dali::Rect< int > *result = 0 ;
29040
29041   arg1 = (Dali::Rect< int > *)jarg1;
29042   if (!arg1) {
29043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29044     return 0;
29045   }
29046   {
29047     try {
29048       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29049     } CALL_CATCH_EXCEPTION(0);
29050   }
29051
29052   jresult = (void *)result;
29053   return jresult;
29054 }
29055
29056
29057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29058   void * jresult ;
29059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29060   Dali::Rect< int > *arg2 = 0 ;
29061   Dali::Rect< int > *result = 0 ;
29062
29063   arg1 = (Dali::Rect< int > *)jarg1;
29064   arg2 = (Dali::Rect< int > *)jarg2;
29065   if (!arg2) {
29066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29067     return 0;
29068   }
29069   {
29070     try {
29071       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29072     } CALL_CATCH_EXCEPTION(0);
29073   }
29074
29075   jresult = (void *)result;
29076   return jresult;
29077 }
29078
29079
29080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29081   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29082   int arg2 ;
29083   int arg3 ;
29084   int arg4 ;
29085   int arg5 ;
29086
29087   arg1 = (Dali::Rect< int > *)jarg1;
29088   arg2 = (int)jarg2;
29089   arg3 = (int)jarg3;
29090   arg4 = (int)jarg4;
29091   arg5 = (int)jarg5;
29092   {
29093     try {
29094       (arg1)->Set(arg2,arg3,arg4,arg5);
29095     } CALL_CATCH_EXCEPTION();
29096   }
29097
29098 }
29099
29100
29101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29102   unsigned int jresult ;
29103   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29104   bool result;
29105
29106   arg1 = (Dali::Rect< int > *)jarg1;
29107   {
29108     try {
29109       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29110     } CALL_CATCH_EXCEPTION(0);
29111   }
29112
29113   jresult = result;
29114   return jresult;
29115 }
29116
29117
29118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29119   int jresult ;
29120   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29121   int result;
29122
29123   arg1 = (Dali::Rect< int > *)jarg1;
29124   {
29125     try {
29126       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29127     } CALL_CATCH_EXCEPTION(0);
29128   }
29129
29130   jresult = result;
29131   return jresult;
29132 }
29133
29134
29135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
29136   int jresult ;
29137   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29138   int result;
29139
29140   arg1 = (Dali::Rect< int > *)jarg1;
29141   {
29142     try {
29143       result = (int)((Dali::Rect< int > const *)arg1)->Right();
29144     } CALL_CATCH_EXCEPTION(0);
29145   }
29146
29147   jresult = result;
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
29153   int jresult ;
29154   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29155   int result;
29156
29157   arg1 = (Dali::Rect< int > *)jarg1;
29158   {
29159     try {
29160       result = (int)((Dali::Rect< int > const *)arg1)->Top();
29161     } CALL_CATCH_EXCEPTION(0);
29162   }
29163
29164   jresult = result;
29165   return jresult;
29166 }
29167
29168
29169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
29170   int jresult ;
29171   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29172   int result;
29173
29174   arg1 = (Dali::Rect< int > *)jarg1;
29175   {
29176     try {
29177       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
29178     } CALL_CATCH_EXCEPTION(0);
29179   }
29180
29181   jresult = result;
29182   return jresult;
29183 }
29184
29185
29186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
29187   int jresult ;
29188   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29189   int result;
29190
29191   arg1 = (Dali::Rect< int > *)jarg1;
29192   {
29193     try {
29194       result = (int)((Dali::Rect< int > const *)arg1)->Area();
29195     } CALL_CATCH_EXCEPTION(0);
29196   }
29197
29198   jresult = result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29204   unsigned int jresult ;
29205   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29206   Dali::Rect< int > *arg2 = 0 ;
29207   bool result;
29208
29209   arg1 = (Dali::Rect< int > *)jarg1;
29210   arg2 = (Dali::Rect< int > *)jarg2;
29211   if (!arg2) {
29212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29213     return 0;
29214   }
29215   {
29216     try {
29217       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29218     } CALL_CATCH_EXCEPTION(0);
29219   }
29220
29221   jresult = result;
29222   return jresult;
29223 }
29224
29225
29226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29227   unsigned int jresult ;
29228   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29229   Dali::Rect< int > *arg2 = 0 ;
29230   bool result;
29231
29232   arg1 = (Dali::Rect< int > *)jarg1;
29233   arg2 = (Dali::Rect< int > *)jarg2;
29234   if (!arg2) {
29235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29236     return 0;
29237   }
29238   {
29239     try {
29240       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29241     } CALL_CATCH_EXCEPTION(0);
29242   }
29243
29244   jresult = result;
29245   return jresult;
29246 }
29247
29248
29249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29250   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29251   int arg2 ;
29252
29253   arg1 = (Dali::Rect< int > *)jarg1;
29254   arg2 = (int)jarg2;
29255   if (arg1) (arg1)->x = arg2;
29256 }
29257
29258
29259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29260   int jresult ;
29261   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29262   int result;
29263
29264   arg1 = (Dali::Rect< int > *)jarg1;
29265   result = (int) ((arg1)->x);
29266   jresult = result;
29267   return jresult;
29268 }
29269
29270
29271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29272   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29273   int arg2 ;
29274
29275   arg1 = (Dali::Rect< int > *)jarg1;
29276   arg2 = (int)jarg2;
29277   if (arg1) (arg1)->left = arg2;
29278 }
29279
29280
29281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29282   int jresult ;
29283   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29284   int result;
29285
29286   arg1 = (Dali::Rect< int > *)jarg1;
29287   result = (int) ((arg1)->left);
29288   jresult = result;
29289   return jresult;
29290 }
29291
29292
29293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29294   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29295   int arg2 ;
29296
29297   arg1 = (Dali::Rect< int > *)jarg1;
29298   arg2 = (int)jarg2;
29299   if (arg1) (arg1)->y = arg2;
29300 }
29301
29302
29303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29304   int jresult ;
29305   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29306   int result;
29307
29308   arg1 = (Dali::Rect< int > *)jarg1;
29309   result = (int) ((arg1)->y);
29310   jresult = result;
29311   return jresult;
29312 }
29313
29314
29315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29316   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29317   int arg2 ;
29318
29319   arg1 = (Dali::Rect< int > *)jarg1;
29320   arg2 = (int)jarg2;
29321   if (arg1) (arg1)->right = arg2;
29322 }
29323
29324
29325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29326   int jresult ;
29327   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29328   int result;
29329
29330   arg1 = (Dali::Rect< int > *)jarg1;
29331   result = (int) ((arg1)->right);
29332   jresult = result;
29333   return jresult;
29334 }
29335
29336
29337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29338   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29339   int arg2 ;
29340
29341   arg1 = (Dali::Rect< int > *)jarg1;
29342   arg2 = (int)jarg2;
29343   if (arg1) (arg1)->width = arg2;
29344 }
29345
29346
29347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29348   int jresult ;
29349   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29350   int result;
29351
29352   arg1 = (Dali::Rect< int > *)jarg1;
29353   result = (int) ((arg1)->width);
29354   jresult = result;
29355   return jresult;
29356 }
29357
29358
29359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29360   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29361   int arg2 ;
29362
29363   arg1 = (Dali::Rect< int > *)jarg1;
29364   arg2 = (int)jarg2;
29365   if (arg1) (arg1)->bottom = arg2;
29366 }
29367
29368
29369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29370   int jresult ;
29371   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29372   int result;
29373
29374   arg1 = (Dali::Rect< int > *)jarg1;
29375   result = (int) ((arg1)->bottom);
29376   jresult = result;
29377   return jresult;
29378 }
29379
29380
29381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29382   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29383   int arg2 ;
29384
29385   arg1 = (Dali::Rect< int > *)jarg1;
29386   arg2 = (int)jarg2;
29387   if (arg1) (arg1)->height = arg2;
29388 }
29389
29390
29391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29392   int jresult ;
29393   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29394   int result;
29395
29396   arg1 = (Dali::Rect< int > *)jarg1;
29397   result = (int) ((arg1)->height);
29398   jresult = result;
29399   return jresult;
29400 }
29401
29402
29403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29404   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29405   int arg2 ;
29406
29407   arg1 = (Dali::Rect< int > *)jarg1;
29408   arg2 = (int)jarg2;
29409   if (arg1) (arg1)->top = arg2;
29410 }
29411
29412
29413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29414   int jresult ;
29415   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29416   int result;
29417
29418   arg1 = (Dali::Rect< int > *)jarg1;
29419   result = (int) ((arg1)->top);
29420   jresult = result;
29421   return jresult;
29422 }
29423
29424
29425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29426   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29427
29428   arg1 = (Dali::Rect< int > *)jarg1;
29429   {
29430     try {
29431       delete arg1;
29432     } CALL_CATCH_EXCEPTION();
29433   }
29434
29435 }
29436
29437
29438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29439   void * jresult ;
29440   Dali::Rect< float > *result = 0 ;
29441
29442   {
29443     try {
29444       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29445     } CALL_CATCH_EXCEPTION(0);
29446   }
29447
29448   jresult = (void *)result;
29449   return jresult;
29450 }
29451
29452
29453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29454   void * jresult ;
29455   float arg1 ;
29456   float arg2 ;
29457   float arg3 ;
29458   float arg4 ;
29459   Dali::Rect< float > *result = 0 ;
29460
29461   arg1 = (float)jarg1;
29462   arg2 = (float)jarg2;
29463   arg3 = (float)jarg4;
29464   arg4 = (float)jarg3;
29465   {
29466     try {
29467       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29468     } CALL_CATCH_EXCEPTION(0);
29469   }
29470
29471   jresult = (void *)result;
29472   return jresult;
29473 }
29474
29475
29476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29477   void * jresult ;
29478   Dali::Rect< float > *arg1 = 0 ;
29479   Dali::Rect< float > *result = 0 ;
29480
29481   arg1 = (Dali::Rect< float > *)jarg1;
29482   if (!arg1) {
29483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29484     return 0;
29485   }
29486   {
29487     try {
29488       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29489     } CALL_CATCH_EXCEPTION(0);
29490   }
29491
29492   jresult = (void *)result;
29493   return jresult;
29494 }
29495
29496
29497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29498   void * jresult ;
29499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29500   Dali::Rect< float > *arg2 = 0 ;
29501   Dali::Rect< float > *result = 0 ;
29502
29503   arg1 = (Dali::Rect< float > *)jarg1;
29504   arg2 = (Dali::Rect< float > *)jarg2;
29505   if (!arg2) {
29506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29507     return 0;
29508   }
29509   {
29510     try {
29511       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29512     } CALL_CATCH_EXCEPTION(0);
29513   }
29514
29515   jresult = (void *)result;
29516   return jresult;
29517 }
29518
29519
29520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29522   float arg2 ;
29523   float arg3 ;
29524   float arg4 ;
29525   float arg5 ;
29526
29527   arg1 = (Dali::Rect< float > *)jarg1;
29528   arg2 = (float)jarg2;
29529   arg3 = (float)jarg3;
29530   arg4 = (float)jarg5;
29531   arg5 = (float)jarg4;
29532   {
29533     try {
29534       (arg1)->Set(arg2,arg3,arg4,arg5);
29535     } CALL_CATCH_EXCEPTION();
29536   }
29537
29538 }
29539
29540
29541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29542   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29543   float arg2 ;
29544
29545   arg1 = (Dali::Rect< float > *)jarg1;
29546   arg2 = (float)jarg2;
29547   if (arg1) (arg1)->left = arg2;
29548 }
29549
29550
29551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29552   float jresult ;
29553   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29554   float result;
29555
29556   arg1 = (Dali::Rect< float > *)jarg1;
29557   result = (float) ((arg1)->left);
29558   jresult = result;
29559   return jresult;
29560 }
29561
29562
29563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29564   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29565   float arg2 ;
29566
29567   arg1 = (Dali::Rect< float > *)jarg1;
29568   arg2 = (float)jarg2;
29569   if (arg1) (arg1)->left = arg2;
29570 }
29571
29572
29573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29574   float jresult ;
29575   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29576   float result;
29577
29578   arg1 = (Dali::Rect< float > *)jarg1;
29579   result = (float) ((arg1)->left);
29580   jresult = result;
29581   return jresult;
29582 }
29583
29584
29585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29586   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29587   float arg2 ;
29588
29589   arg1 = (Dali::Rect< float > *)jarg1;
29590   arg2 = (float)jarg2;
29591   if (arg1) (arg1)->right = arg2;
29592 }
29593
29594
29595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29596   float jresult ;
29597   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29598   float result;
29599
29600   arg1 = (Dali::Rect< float > *)jarg1;
29601   result = (float) ((arg1)->right);
29602   jresult = result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29608   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29609   float arg2 ;
29610
29611   arg1 = (Dali::Rect< float > *)jarg1;
29612   arg2 = (float)jarg2;
29613   if (arg1) (arg1)->right = arg2;
29614 }
29615
29616
29617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29618   float jresult ;
29619   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29620   float result;
29621
29622   arg1 = (Dali::Rect< float > *)jarg1;
29623   result = (float) ((arg1)->right);
29624   jresult = result;
29625   return jresult;
29626 }
29627
29628
29629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29630   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29631   float arg2 ;
29632
29633   arg1 = (Dali::Rect< float > *)jarg1;
29634   arg2 = (float)jarg2;
29635   if (arg1) (arg1)->bottom = arg2;
29636 }
29637
29638
29639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29640   float jresult ;
29641   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29642   float result;
29643
29644   arg1 = (Dali::Rect< float > *)jarg1;
29645   result = (float) ((arg1)->bottom);
29646   jresult = result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29652   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29653   float arg2 ;
29654
29655   arg1 = (Dali::Rect< float > *)jarg1;
29656   arg2 = (float)jarg2;
29657   if (arg1) (arg1)->top = arg2;
29658 }
29659
29660
29661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29662   float jresult ;
29663   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29664   float result;
29665
29666   arg1 = (Dali::Rect< float > *)jarg1;
29667   result = (float) ((arg1)->top);
29668   jresult = result;
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29674   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29675
29676   arg1 = (Dali::Rect< float > *)jarg1;
29677   {
29678     try {
29679       delete arg1;
29680     } CALL_CATCH_EXCEPTION();
29681   }
29682
29683 }
29684
29685
29686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29687   int jresult ;
29688   int result;
29689
29690   result = (int)Dali::Vector< int >::BaseType;
29691   jresult = (int)result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29697   void * jresult ;
29698   Dali::Vector< int > *result = 0 ;
29699
29700   {
29701     try {
29702       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29703     } CALL_CATCH_EXCEPTION(0);
29704   }
29705
29706   jresult = (void *)result;
29707   return jresult;
29708 }
29709
29710
29711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29712   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29713
29714   arg1 = (Dali::Vector< int > *)jarg1;
29715   {
29716     try {
29717       delete arg1;
29718     } CALL_CATCH_EXCEPTION();
29719   }
29720
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29725   void * jresult ;
29726   Dali::Vector< int > *arg1 = 0 ;
29727   Dali::Vector< int > *result = 0 ;
29728
29729   arg1 = (Dali::Vector< int > *)jarg1;
29730   if (!arg1) {
29731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29732     return 0;
29733   }
29734   {
29735     try {
29736       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29737     } CALL_CATCH_EXCEPTION(0);
29738   }
29739
29740   jresult = (void *)result;
29741   return jresult;
29742 }
29743
29744
29745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29746   void * jresult ;
29747   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29748   Dali::Vector< int > *arg2 = 0 ;
29749   Dali::Vector< int > *result = 0 ;
29750
29751   arg1 = (Dali::Vector< int > *)jarg1;
29752   arg2 = (Dali::Vector< int > *)jarg2;
29753   if (!arg2) {
29754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29755     return 0;
29756   }
29757   {
29758     try {
29759       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29760     } CALL_CATCH_EXCEPTION(0);
29761   }
29762
29763   jresult = (void *)result;
29764   return jresult;
29765 }
29766
29767
29768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29769   void * jresult ;
29770   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29771   Dali::Vector< int >::Iterator result;
29772
29773   arg1 = (Dali::Vector< int > *)jarg1;
29774   {
29775     try {
29776       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29777     } CALL_CATCH_EXCEPTION(0);
29778   }
29779
29780   jresult = (void *)result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
29786   void * jresult ;
29787   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29788   Dali::Vector< int >::Iterator result;
29789
29790   arg1 = (Dali::Vector< int > *)jarg1;
29791   {
29792     try {
29793       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
29794     } CALL_CATCH_EXCEPTION(0);
29795   }
29796
29797   jresult = (void *)result;
29798   return jresult;
29799 }
29800
29801
29802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29803   void * jresult ;
29804   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29805   Dali::Vector< int >::SizeType arg2 ;
29806   Dali::Vector< int >::ItemType *result = 0 ;
29807
29808   arg1 = (Dali::Vector< int > *)jarg1;
29809   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29810   {
29811     try {
29812       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29813     } CALL_CATCH_EXCEPTION(0);
29814   }
29815
29816   jresult = (void *)result;
29817   return jresult;
29818 }
29819
29820
29821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29822   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29823   Dali::Vector< int >::ItemType *arg2 = 0 ;
29824   Dali::Vector< int >::ItemType temp2 ;
29825
29826   arg1 = (Dali::Vector< int > *)jarg1;
29827   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29828   arg2 = &temp2;
29829   {
29830     try {
29831       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29832     } CALL_CATCH_EXCEPTION();
29833   }
29834
29835 }
29836
29837
29838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29839   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29840   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29841   Dali::Vector< int >::ItemType *arg3 = 0 ;
29842   Dali::Vector< int >::ItemType temp3 ;
29843
29844   arg1 = (Dali::Vector< int > *)jarg1;
29845   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29846   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29847   arg3 = &temp3;
29848   {
29849     try {
29850       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29851     } CALL_CATCH_EXCEPTION();
29852   }
29853
29854 }
29855
29856
29857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29858   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29859   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29860   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29861   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29862
29863   arg1 = (Dali::Vector< int > *)jarg1;
29864   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29865   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29866   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29867   {
29868     try {
29869       (arg1)->Insert(arg2,arg3,arg4);
29870     } CALL_CATCH_EXCEPTION();
29871   }
29872
29873 }
29874
29875
29876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29877   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29878   Dali::Vector< int >::SizeType arg2 ;
29879
29880   arg1 = (Dali::Vector< int > *)jarg1;
29881   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29882   {
29883     try {
29884       (arg1)->Reserve(arg2);
29885     } CALL_CATCH_EXCEPTION();
29886   }
29887
29888 }
29889
29890
29891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
29892   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29893   Dali::Vector< int >::SizeType arg2 ;
29894
29895   arg1 = (Dali::Vector< int > *)jarg1;
29896   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29897   {
29898     try {
29899       (arg1)->Resize(arg2);
29900     } CALL_CATCH_EXCEPTION();
29901   }
29902
29903 }
29904
29905
29906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
29907   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29908   Dali::Vector< int >::SizeType arg2 ;
29909   Dali::Vector< int >::ItemType *arg3 = 0 ;
29910   Dali::Vector< int >::ItemType temp3 ;
29911
29912   arg1 = (Dali::Vector< int > *)jarg1;
29913   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29914   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29915   arg3 = &temp3;
29916   {
29917     try {
29918       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29919     } CALL_CATCH_EXCEPTION();
29920   }
29921
29922 }
29923
29924
29925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
29926   void * jresult ;
29927   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29928   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29929   Dali::Vector< int >::Iterator result;
29930
29931   arg1 = (Dali::Vector< int > *)jarg1;
29932   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29933   {
29934     try {
29935       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
29936     } CALL_CATCH_EXCEPTION(0);
29937   }
29938
29939   jresult = (void *)result;
29940   return jresult;
29941 }
29942
29943
29944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
29945   void * jresult ;
29946   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29947   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29948   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29949   Dali::Vector< int >::Iterator result;
29950
29951   arg1 = (Dali::Vector< int > *)jarg1;
29952   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29953   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29954   {
29955     try {
29956       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
29957     } CALL_CATCH_EXCEPTION(0);
29958   }
29959
29960   jresult = (void *)result;
29961   return jresult;
29962 }
29963
29964
29965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
29966   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29967   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29968
29969   arg1 = (Dali::Vector< int > *)jarg1;
29970   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29971   {
29972     try {
29973       (arg1)->Remove(arg2);
29974     } CALL_CATCH_EXCEPTION();
29975   }
29976
29977 }
29978
29979
29980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
29981   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29982   Dali::Vector< int > *arg2 = 0 ;
29983
29984   arg1 = (Dali::Vector< int > *)jarg1;
29985   arg2 = (Dali::Vector< int > *)jarg2;
29986   if (!arg2) {
29987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
29988     return ;
29989   }
29990   {
29991     try {
29992       (arg1)->Swap(*arg2);
29993     } CALL_CATCH_EXCEPTION();
29994   }
29995
29996 }
29997
29998
29999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30000   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30001
30002   arg1 = (Dali::Vector< int > *)jarg1;
30003   {
30004     try {
30005       (arg1)->Clear();
30006     } CALL_CATCH_EXCEPTION();
30007   }
30008
30009 }
30010
30011
30012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30013   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30014
30015   arg1 = (Dali::Vector< int > *)jarg1;
30016   {
30017     try {
30018       (arg1)->Release();
30019     } CALL_CATCH_EXCEPTION();
30020   }
30021
30022 }
30023
30024
30025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30026   int jresult ;
30027   int result;
30028
30029   result = (int)Dali::Vector< float >::BaseType;
30030   jresult = (int)result;
30031   return jresult;
30032 }
30033
30034
30035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30036   void * jresult ;
30037   Dali::Vector< float > *result = 0 ;
30038
30039   {
30040     try {
30041       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30042     } CALL_CATCH_EXCEPTION(0);
30043   }
30044
30045   jresult = (void *)result;
30046   return jresult;
30047 }
30048
30049
30050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30051   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30052
30053   arg1 = (Dali::Vector< float > *)jarg1;
30054   {
30055     try {
30056       delete arg1;
30057     } CALL_CATCH_EXCEPTION();
30058   }
30059
30060 }
30061
30062
30063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30064   void * jresult ;
30065   Dali::Vector< float > *arg1 = 0 ;
30066   Dali::Vector< float > *result = 0 ;
30067
30068   arg1 = (Dali::Vector< float > *)jarg1;
30069   if (!arg1) {
30070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30071     return 0;
30072   }
30073   {
30074     try {
30075       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30076     } CALL_CATCH_EXCEPTION(0);
30077   }
30078
30079   jresult = (void *)result;
30080   return jresult;
30081 }
30082
30083
30084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30085   void * jresult ;
30086   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30087   Dali::Vector< float > *arg2 = 0 ;
30088   Dali::Vector< float > *result = 0 ;
30089
30090   arg1 = (Dali::Vector< float > *)jarg1;
30091   arg2 = (Dali::Vector< float > *)jarg2;
30092   if (!arg2) {
30093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30094     return 0;
30095   }
30096   {
30097     try {
30098       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30099     } CALL_CATCH_EXCEPTION(0);
30100   }
30101
30102   jresult = (void *)result;
30103   return jresult;
30104 }
30105
30106
30107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30108   void * jresult ;
30109   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30110   Dali::Vector< float >::Iterator result;
30111
30112   arg1 = (Dali::Vector< float > *)jarg1;
30113   {
30114     try {
30115       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30116     } CALL_CATCH_EXCEPTION(0);
30117   }
30118
30119   jresult = (void *)result;
30120   return jresult;
30121 }
30122
30123
30124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
30125   void * jresult ;
30126   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30127   Dali::Vector< float >::Iterator result;
30128
30129   arg1 = (Dali::Vector< float > *)jarg1;
30130   {
30131     try {
30132       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
30133     } CALL_CATCH_EXCEPTION(0);
30134   }
30135
30136   jresult = (void *)result;
30137   return jresult;
30138 }
30139
30140
30141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30142   void * jresult ;
30143   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30144   Dali::Vector< float >::SizeType arg2 ;
30145   Dali::Vector< float >::ItemType *result = 0 ;
30146
30147   arg1 = (Dali::Vector< float > *)jarg1;
30148   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30149   {
30150     try {
30151       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30152     } CALL_CATCH_EXCEPTION(0);
30153   }
30154
30155   jresult = (void *)result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30161   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30162   Dali::Vector< float >::ItemType *arg2 = 0 ;
30163   Dali::Vector< float >::ItemType temp2 ;
30164
30165   arg1 = (Dali::Vector< float > *)jarg1;
30166   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30167   arg2 = &temp2;
30168   {
30169     try {
30170       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30171     } CALL_CATCH_EXCEPTION();
30172   }
30173
30174 }
30175
30176
30177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30178   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30179   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30180   Dali::Vector< float >::ItemType *arg3 = 0 ;
30181   Dali::Vector< float >::ItemType temp3 ;
30182
30183   arg1 = (Dali::Vector< float > *)jarg1;
30184   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30185   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30186   arg3 = &temp3;
30187   {
30188     try {
30189       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30190     } CALL_CATCH_EXCEPTION();
30191   }
30192
30193 }
30194
30195
30196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30197   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30198   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30199   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30200   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30201
30202   arg1 = (Dali::Vector< float > *)jarg1;
30203   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30204   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30205   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30206   {
30207     try {
30208       (arg1)->Insert(arg2,arg3,arg4);
30209     } CALL_CATCH_EXCEPTION();
30210   }
30211
30212 }
30213
30214
30215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30216   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30217   Dali::Vector< float >::SizeType arg2 ;
30218
30219   arg1 = (Dali::Vector< float > *)jarg1;
30220   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30221   {
30222     try {
30223       (arg1)->Reserve(arg2);
30224     } CALL_CATCH_EXCEPTION();
30225   }
30226
30227 }
30228
30229 //// ========================= end of part 2 =============================
30230
30231 //// ========================== start part 3 ===============================
30232
30233
30234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30235   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30236   Dali::Vector< float >::SizeType arg2 ;
30237
30238   arg1 = (Dali::Vector< float > *)jarg1;
30239   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30240   {
30241     try {
30242       (arg1)->Resize(arg2);
30243     } CALL_CATCH_EXCEPTION();
30244   }
30245
30246 }
30247
30248
30249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30250   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30251   Dali::Vector< float >::SizeType arg2 ;
30252   Dali::Vector< float >::ItemType *arg3 = 0 ;
30253   Dali::Vector< float >::ItemType temp3 ;
30254
30255   arg1 = (Dali::Vector< float > *)jarg1;
30256   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30257   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30258   arg3 = &temp3;
30259   {
30260     try {
30261       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30262     } CALL_CATCH_EXCEPTION();
30263   }
30264
30265 }
30266
30267
30268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30269   void * jresult ;
30270   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30271   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30272   Dali::Vector< float >::Iterator result;
30273
30274   arg1 = (Dali::Vector< float > *)jarg1;
30275   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30276   {
30277     try {
30278       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30279     } CALL_CATCH_EXCEPTION(0);
30280   }
30281
30282   jresult = (void *)result;
30283   return jresult;
30284 }
30285
30286
30287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30288   void * jresult ;
30289   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30290   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30291   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30292   Dali::Vector< float >::Iterator result;
30293
30294   arg1 = (Dali::Vector< float > *)jarg1;
30295   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30296   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30297   {
30298     try {
30299       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30300     } CALL_CATCH_EXCEPTION(0);
30301   }
30302
30303   jresult = (void *)result;
30304   return jresult;
30305 }
30306
30307
30308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30309   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30310   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30311
30312   arg1 = (Dali::Vector< float > *)jarg1;
30313   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30314   {
30315     try {
30316       (arg1)->Remove(arg2);
30317     } CALL_CATCH_EXCEPTION();
30318   }
30319
30320 }
30321
30322
30323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30324   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30325   Dali::Vector< float > *arg2 = 0 ;
30326
30327   arg1 = (Dali::Vector< float > *)jarg1;
30328   arg2 = (Dali::Vector< float > *)jarg2;
30329   if (!arg2) {
30330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30331     return ;
30332   }
30333   {
30334     try {
30335       (arg1)->Swap(*arg2);
30336     } CALL_CATCH_EXCEPTION();
30337   }
30338
30339 }
30340
30341
30342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30343   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30344
30345   arg1 = (Dali::Vector< float > *)jarg1;
30346   {
30347     try {
30348       (arg1)->Clear();
30349     } CALL_CATCH_EXCEPTION();
30350   }
30351
30352 }
30353
30354
30355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30356   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30357
30358   arg1 = (Dali::Vector< float > *)jarg1;
30359   {
30360     try {
30361       (arg1)->Release();
30362     } CALL_CATCH_EXCEPTION();
30363   }
30364
30365 }
30366
30367
30368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30369   int jresult ;
30370   int result;
30371
30372   result = (int)Dali::Vector< unsigned char >::BaseType;
30373   jresult = (int)result;
30374   return jresult;
30375 }
30376
30377
30378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30379   void * jresult ;
30380   Dali::Vector< unsigned char > *result = 0 ;
30381
30382   {
30383     try {
30384       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30385     } CALL_CATCH_EXCEPTION(0);
30386   }
30387
30388   jresult = (void *)result;
30389   return jresult;
30390 }
30391
30392
30393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30394   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30395
30396   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30397   {
30398     try {
30399       delete arg1;
30400     } CALL_CATCH_EXCEPTION();
30401   }
30402
30403 }
30404
30405
30406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30407   void * jresult ;
30408   Dali::Vector< unsigned char > *arg1 = 0 ;
30409   Dali::Vector< unsigned char > *result = 0 ;
30410
30411   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30412   if (!arg1) {
30413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30414     return 0;
30415   }
30416   {
30417     try {
30418       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30419     } CALL_CATCH_EXCEPTION(0);
30420   }
30421
30422   jresult = (void *)result;
30423   return jresult;
30424 }
30425
30426
30427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30428   void * jresult ;
30429   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30430   Dali::Vector< unsigned char > *arg2 = 0 ;
30431   Dali::Vector< unsigned char > *result = 0 ;
30432
30433   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30434   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30435   if (!arg2) {
30436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30437     return 0;
30438   }
30439   {
30440     try {
30441       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30442     } CALL_CATCH_EXCEPTION(0);
30443   }
30444
30445   jresult = (void *)result;
30446   return jresult;
30447 }
30448
30449
30450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30451   void * jresult ;
30452   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30453   Dali::Vector< unsigned char >::Iterator result;
30454
30455   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30456   {
30457     try {
30458       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30459     } CALL_CATCH_EXCEPTION(0);
30460   }
30461
30462   jresult = (void *)result;
30463   return jresult;
30464 }
30465
30466
30467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
30468   void * jresult ;
30469   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30470   Dali::Vector< unsigned char >::Iterator result;
30471
30472   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30473   {
30474     try {
30475       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
30476     } CALL_CATCH_EXCEPTION(0);
30477   }
30478
30479   jresult = (void *)result;
30480   return jresult;
30481 }
30482
30483
30484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30485   void * jresult ;
30486   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30487   Dali::Vector< unsigned char >::SizeType arg2 ;
30488   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30489
30490   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30491   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30492   {
30493     try {
30494       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30495     } CALL_CATCH_EXCEPTION(0);
30496   }
30497
30498   jresult = (void *)result;
30499   return jresult;
30500 }
30501
30502
30503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30504   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30505   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30506   Dali::Vector< unsigned char >::ItemType temp2 ;
30507
30508   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30509   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30510   arg2 = &temp2;
30511   {
30512     try {
30513       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30514     } CALL_CATCH_EXCEPTION();
30515   }
30516
30517 }
30518
30519
30520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30521   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30522   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30523   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30524   Dali::Vector< unsigned char >::ItemType temp3 ;
30525
30526   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30527   arg2 = jarg2;
30528   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30529   arg3 = &temp3;
30530   {
30531     try {
30532       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30533     } CALL_CATCH_EXCEPTION();
30534   }
30535
30536
30537
30538 }
30539
30540
30541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30543   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30544   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30545   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30546
30547   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30548   arg2 = jarg2;
30549   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30550   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30551   {
30552     try {
30553       (arg1)->Insert(arg2,arg3,arg4);
30554     } CALL_CATCH_EXCEPTION();
30555   }
30556
30557
30558
30559 }
30560
30561
30562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30563   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30564   Dali::Vector< unsigned char >::SizeType arg2 ;
30565
30566   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30567   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30568   {
30569     try {
30570       (arg1)->Reserve(arg2);
30571     } CALL_CATCH_EXCEPTION();
30572   }
30573
30574 }
30575
30576
30577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30578   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30579   Dali::Vector< unsigned char >::SizeType arg2 ;
30580
30581   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30582   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30583   {
30584     try {
30585       (arg1)->Resize(arg2);
30586     } CALL_CATCH_EXCEPTION();
30587   }
30588
30589 }
30590
30591
30592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30593   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30594   Dali::Vector< unsigned char >::SizeType arg2 ;
30595   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30596   Dali::Vector< unsigned char >::ItemType temp3 ;
30597
30598   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30599   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30600   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30601   arg3 = &temp3;
30602   {
30603     try {
30604       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30605     } CALL_CATCH_EXCEPTION();
30606   }
30607
30608 }
30609
30610
30611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30612   void * jresult ;
30613   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30614   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30615   Dali::Vector< unsigned char >::Iterator result;
30616
30617   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30618   arg2 = jarg2;
30619   {
30620     try {
30621       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30622     } CALL_CATCH_EXCEPTION(0);
30623   }
30624
30625   jresult = (void *)result;
30626
30627
30628   return jresult;
30629 }
30630
30631
30632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30633   void * jresult ;
30634   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30635   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30636   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30637   Dali::Vector< unsigned char >::Iterator result;
30638
30639   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30640   arg2 = jarg2;
30641   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30642   {
30643     try {
30644       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30645     } CALL_CATCH_EXCEPTION(0);
30646   }
30647
30648   jresult = (void *)result;
30649
30650
30651   return jresult;
30652 }
30653
30654
30655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30656   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30657   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30658
30659   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30660   arg2 = jarg2;
30661   {
30662     try {
30663       (arg1)->Remove(arg2);
30664     } CALL_CATCH_EXCEPTION();
30665   }
30666
30667
30668
30669 }
30670
30671
30672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30673   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30674   Dali::Vector< unsigned char > *arg2 = 0 ;
30675
30676   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30677   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30678   if (!arg2) {
30679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30680     return ;
30681   }
30682   {
30683     try {
30684       (arg1)->Swap(*arg2);
30685     } CALL_CATCH_EXCEPTION();
30686   }
30687
30688 }
30689
30690
30691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30692   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30693
30694   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30695   {
30696     try {
30697       (arg1)->Clear();
30698     } CALL_CATCH_EXCEPTION();
30699   }
30700
30701 }
30702
30703
30704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30705   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30706
30707   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30708   {
30709     try {
30710       (arg1)->Release();
30711     } CALL_CATCH_EXCEPTION();
30712   }
30713
30714 }
30715
30716
30717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30718   int jresult ;
30719   int result;
30720
30721   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30722   jresult = (int)result;
30723   return jresult;
30724 }
30725
30726
30727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30728   void * jresult ;
30729   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30730
30731   {
30732     try {
30733       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30734     } CALL_CATCH_EXCEPTION(0);
30735   }
30736
30737   jresult = (void *)result;
30738   return jresult;
30739 }
30740
30741
30742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30743   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30744
30745   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30746   {
30747     try {
30748       delete arg1;
30749     } CALL_CATCH_EXCEPTION();
30750   }
30751
30752 }
30753
30754
30755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30756   void * jresult ;
30757   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30758   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30759
30760   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30761   if (!arg1) {
30762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30763     return 0;
30764   }
30765   {
30766     try {
30767       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30768     } CALL_CATCH_EXCEPTION(0);
30769   }
30770
30771   jresult = (void *)result;
30772   return jresult;
30773 }
30774
30775
30776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30777   void * jresult ;
30778   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30779   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30780   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30781
30782   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30783   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30784   if (!arg2) {
30785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30786     return 0;
30787   }
30788   {
30789     try {
30790       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30791     } CALL_CATCH_EXCEPTION(0);
30792   }
30793
30794   jresult = (void *)result;
30795   return jresult;
30796 }
30797
30798
30799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30800   void * jresult ;
30801   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30802   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30803
30804   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30805   {
30806     try {
30807       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30808     } CALL_CATCH_EXCEPTION(0);
30809   }
30810
30811   jresult = (void *)result;
30812   return jresult;
30813 }
30814
30815
30816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
30817   void * jresult ;
30818   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30819   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30820
30821   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30822   {
30823     try {
30824       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
30825     } CALL_CATCH_EXCEPTION(0);
30826   }
30827
30828   jresult = (void *)result;
30829   return jresult;
30830 }
30831
30832
30833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30834   void * jresult ;
30835   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30836   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30837   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30838
30839   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30840   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30841   {
30842     try {
30843       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30844     } CALL_CATCH_EXCEPTION(0);
30845   }
30846
30847   jresult = (void *)result;
30848   return jresult;
30849 }
30850
30851
30852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30853   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30854   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30855
30856   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30857   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30858   if (!arg2) {
30859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30860     return ;
30861   }
30862   {
30863     try {
30864       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30865     } CALL_CATCH_EXCEPTION();
30866   }
30867
30868 }
30869
30870
30871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30872   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30873   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30874   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30875
30876   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30877   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30878   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30879   if (!arg3) {
30880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30881     return ;
30882   }
30883   {
30884     try {
30885       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30886     } CALL_CATCH_EXCEPTION();
30887   }
30888
30889 }
30890
30891
30892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30893   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30894   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30895   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30896   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30897
30898   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30899   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30900   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30901   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
30902   {
30903     try {
30904       (arg1)->Insert(arg2,arg3,arg4);
30905     } CALL_CATCH_EXCEPTION();
30906   }
30907
30908 }
30909
30910
30911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
30912   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30913   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30914
30915   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30916   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30917   {
30918     try {
30919       (arg1)->Reserve(arg2);
30920     } CALL_CATCH_EXCEPTION();
30921   }
30922
30923 }
30924
30925
30926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30927   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30928   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30929
30930   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30931   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30932   {
30933     try {
30934       (arg1)->Resize(arg2);
30935     } CALL_CATCH_EXCEPTION();
30936   }
30937
30938 }
30939
30940
30941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
30942   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30943   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30944   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30945
30946   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30947   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30948   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30949   if (!arg3) {
30950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30951     return ;
30952   }
30953   {
30954     try {
30955       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30956     } CALL_CATCH_EXCEPTION();
30957   }
30958
30959 }
30960
30961
30962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
30963   void * jresult ;
30964   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30965   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30966   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30967
30968   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30969   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30970   {
30971     try {
30972       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
30973     } CALL_CATCH_EXCEPTION(0);
30974   }
30975
30976   jresult = (void *)result;
30977   return jresult;
30978 }
30979
30980
30981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30982   void * jresult ;
30983   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30984   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30985   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30986   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30987
30988   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30989   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30990   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30991   {
30992     try {
30993       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
30994     } CALL_CATCH_EXCEPTION(0);
30995   }
30996
30997   jresult = (void *)result;
30998   return jresult;
30999 }
31000
31001
31002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31003   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31004   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31005
31006   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31007   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31008   {
31009     try {
31010       (arg1)->Remove(arg2);
31011     } CALL_CATCH_EXCEPTION();
31012   }
31013
31014 }
31015
31016
31017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31018   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31019   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31020
31021   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31022   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31023   if (!arg2) {
31024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31025     return ;
31026   }
31027   {
31028     try {
31029       (arg1)->Swap(*arg2);
31030     } CALL_CATCH_EXCEPTION();
31031   }
31032
31033 }
31034
31035
31036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31037   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31038
31039   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31040   {
31041     try {
31042       (arg1)->Clear();
31043     } CALL_CATCH_EXCEPTION();
31044   }
31045
31046 }
31047
31048
31049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31050   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31051
31052   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31053   {
31054     try {
31055       (arg1)->Release();
31056     } CALL_CATCH_EXCEPTION();
31057   }
31058
31059 }
31060
31061
31062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31063   void * jresult ;
31064   Dali::Signal< void () > *result = 0 ;
31065
31066   {
31067     try {
31068       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31069     } CALL_CATCH_EXCEPTION(0);
31070   }
31071
31072   jresult = (void *)result;
31073   return jresult;
31074 }
31075
31076
31077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31078   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31079
31080   arg1 = (Dali::Signal< void () > *)jarg1;
31081   {
31082     try {
31083       delete arg1;
31084     } CALL_CATCH_EXCEPTION();
31085   }
31086
31087 }
31088
31089
31090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31091   unsigned int jresult ;
31092   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31093   bool result;
31094
31095   arg1 = (Dali::Signal< void () > *)jarg1;
31096   {
31097     try {
31098       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31099     } CALL_CATCH_EXCEPTION(0);
31100   }
31101
31102   jresult = result;
31103   return jresult;
31104 }
31105
31106
31107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31108   unsigned long jresult ;
31109   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31110   std::size_t result;
31111
31112   arg1 = (Dali::Signal< void () > *)jarg1;
31113   {
31114     try {
31115       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31116     } CALL_CATCH_EXCEPTION(0);
31117   }
31118
31119   jresult = (unsigned long)result;
31120   return jresult;
31121 }
31122
31123
31124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31125   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31126   void (*arg2)() = (void (*)()) 0 ;
31127
31128   arg1 = (Dali::Signal< void () > *)jarg1;
31129   arg2 = (void (*)())jarg2;
31130   {
31131     try {
31132       (arg1)->Connect(arg2);
31133     } CALL_CATCH_EXCEPTION();
31134   }
31135
31136 }
31137
31138
31139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31140   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31141   void (*arg2)() = (void (*)()) 0 ;
31142
31143   arg1 = (Dali::Signal< void () > *)jarg1;
31144   arg2 = (void (*)())jarg2;
31145   {
31146     try {
31147       (arg1)->Disconnect(arg2);
31148     } CALL_CATCH_EXCEPTION();
31149   }
31150
31151 }
31152
31153
31154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31155   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31156   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31157   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31158
31159   arg1 = (Dali::Signal< void () > *)jarg1;
31160   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31161   arg3 = (Dali::FunctorDelegate *)jarg3;
31162   {
31163     try {
31164       (arg1)->Connect(arg2,arg3);
31165     } CALL_CATCH_EXCEPTION();
31166   }
31167
31168 }
31169
31170
31171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31172   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31173
31174   arg1 = (Dali::Signal< void () > *)jarg1;
31175   {
31176     try {
31177       (arg1)->Emit();
31178     } CALL_CATCH_EXCEPTION();
31179   }
31180
31181 }
31182
31183
31184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31185   unsigned int jresult ;
31186   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31187   bool result;
31188
31189   arg1 = (Dali::Signal< void (float) > *)jarg1;
31190   {
31191     try {
31192       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31193     } CALL_CATCH_EXCEPTION(0);
31194   }
31195
31196   jresult = result;
31197   return jresult;
31198 }
31199
31200
31201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31202   unsigned long jresult ;
31203   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31204   std::size_t result;
31205
31206   arg1 = (Dali::Signal< void (float) > *)jarg1;
31207   {
31208     try {
31209       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31210     } CALL_CATCH_EXCEPTION(0);
31211   }
31212
31213   jresult = (unsigned long)result;
31214   return jresult;
31215 }
31216
31217
31218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31219   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31220   void (*arg2)(float) = (void (*)(float)) 0 ;
31221
31222   arg1 = (Dali::Signal< void (float) > *)jarg1;
31223   arg2 = (void (*)(float))jarg2;
31224   {
31225     try {
31226       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31227     } CALL_CATCH_EXCEPTION();
31228   }
31229
31230 }
31231
31232
31233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31234   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31235   void (*arg2)(float) = (void (*)(float)) 0 ;
31236
31237   arg1 = (Dali::Signal< void (float) > *)jarg1;
31238   arg2 = (void (*)(float))jarg2;
31239   {
31240     try {
31241       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31242     } CALL_CATCH_EXCEPTION();
31243   }
31244
31245 }
31246
31247
31248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31249   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31250   float arg2 ;
31251
31252   arg1 = (Dali::Signal< void (float) > *)jarg1;
31253   arg2 = (float)jarg2;
31254   {
31255     try {
31256       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31257     } CALL_CATCH_EXCEPTION();
31258   }
31259
31260 }
31261
31262
31263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31264   void * jresult ;
31265   Dali::Signal< void (float) > *result = 0 ;
31266
31267   {
31268     try {
31269       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31270     } CALL_CATCH_EXCEPTION(0);
31271   }
31272
31273   jresult = (void *)result;
31274   return jresult;
31275 }
31276
31277
31278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31279   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31280
31281   arg1 = (Dali::Signal< void (float) > *)jarg1;
31282   {
31283     try {
31284       delete arg1;
31285     } CALL_CATCH_EXCEPTION();
31286   }
31287
31288 }
31289
31290
31291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31292   unsigned int jresult ;
31293   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31294   bool result;
31295
31296   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31297   {
31298     try {
31299       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31300     } CALL_CATCH_EXCEPTION(0);
31301   }
31302
31303   jresult = result;
31304   return jresult;
31305 }
31306
31307
31308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31309   unsigned long jresult ;
31310   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31311   std::size_t result;
31312
31313   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31314   {
31315     try {
31316       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31317     } CALL_CATCH_EXCEPTION(0);
31318   }
31319
31320   jresult = (unsigned long)result;
31321   return jresult;
31322 }
31323
31324
31325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31326   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31327   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31328
31329   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31330   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31331   {
31332     try {
31333       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31334     } CALL_CATCH_EXCEPTION();
31335   }
31336
31337 }
31338
31339
31340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31341   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31342   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31343
31344   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31345   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31346   {
31347     try {
31348       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31349     } CALL_CATCH_EXCEPTION();
31350   }
31351
31352 }
31353
31354
31355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31356   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31357   Dali::BaseHandle arg2 ;
31358   Dali::BaseHandle *argp2 ;
31359
31360   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31361   argp2 = (Dali::BaseHandle *)jarg2;
31362   if (!argp2) {
31363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31364     return ;
31365   }
31366   arg2 = *argp2;
31367   {
31368     try {
31369       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31370     } CALL_CATCH_EXCEPTION();
31371   }
31372
31373 }
31374
31375
31376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31377   void * jresult ;
31378   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31379
31380   {
31381     try {
31382       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31383     } CALL_CATCH_EXCEPTION(0);
31384   }
31385
31386   jresult = (void *)result;
31387   return jresult;
31388 }
31389
31390
31391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31392   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31393
31394   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31395   {
31396     try {
31397       delete arg1;
31398     } CALL_CATCH_EXCEPTION();
31399   }
31400
31401 }
31402
31403
31404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31405   unsigned int jresult ;
31406   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31407   bool result;
31408
31409   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31410   {
31411     try {
31412       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31413     } CALL_CATCH_EXCEPTION(0);
31414   }
31415
31416   jresult = result;
31417   return jresult;
31418 }
31419
31420
31421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31422   unsigned long jresult ;
31423   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31424   std::size_t result;
31425
31426   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31427   {
31428     try {
31429       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31430     } CALL_CATCH_EXCEPTION(0);
31431   }
31432
31433   jresult = (unsigned long)result;
31434   return jresult;
31435 }
31436
31437
31438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31439   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31440   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31441
31442   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31443   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31444   {
31445     try {
31446       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31447     } CALL_CATCH_EXCEPTION();
31448   }
31449
31450 }
31451
31452
31453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31454   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31455   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31456
31457   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31458   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31459   {
31460     try {
31461       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31462     } CALL_CATCH_EXCEPTION();
31463   }
31464
31465 }
31466
31467
31468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31469   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31470   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31471
31472   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31473   arg2 = (Dali::RefObject *)jarg2;
31474   {
31475     try {
31476       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31477     } CALL_CATCH_EXCEPTION();
31478   }
31479
31480 }
31481
31482
31483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31484   void * jresult ;
31485   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31486
31487   {
31488     try {
31489       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31490     } CALL_CATCH_EXCEPTION(0);
31491   }
31492
31493   jresult = (void *)result;
31494   return jresult;
31495 }
31496
31497
31498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31499   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31500
31501   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31502   {
31503     try {
31504       delete arg1;
31505     } CALL_CATCH_EXCEPTION();
31506   }
31507
31508 }
31509
31510
31511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31512   unsigned int jresult ;
31513   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31514   bool result;
31515
31516   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31517   {
31518     try {
31519       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31520     } CALL_CATCH_EXCEPTION(0);
31521   }
31522
31523   jresult = result;
31524   return jresult;
31525 }
31526
31527
31528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31529   unsigned long jresult ;
31530   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31531   std::size_t result;
31532
31533   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31534   {
31535     try {
31536       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31537     } CALL_CATCH_EXCEPTION(0);
31538   }
31539
31540   jresult = (unsigned long)result;
31541   return jresult;
31542 }
31543
31544
31545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31546   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31547   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31548
31549   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31550   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31551   {
31552     try {
31553       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31554     } CALL_CATCH_EXCEPTION();
31555   }
31556
31557 }
31558
31559
31560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31561   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31562   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31563
31564   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31565   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31566   {
31567     try {
31568       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31569     } CALL_CATCH_EXCEPTION();
31570   }
31571
31572 }
31573
31574
31575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31576   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31577   Dali::PropertyNotification *arg2 = 0 ;
31578
31579   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31580   arg2 = (Dali::PropertyNotification *)jarg2;
31581   if (!arg2) {
31582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31583     return ;
31584   }
31585   {
31586     try {
31587       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31588     } CALL_CATCH_EXCEPTION();
31589   }
31590
31591 }
31592
31593
31594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31595   void * jresult ;
31596   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31597
31598   {
31599     try {
31600       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31601     } CALL_CATCH_EXCEPTION(0);
31602   }
31603
31604   jresult = (void *)result;
31605   return jresult;
31606 }
31607
31608
31609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31610   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31611
31612   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31613   {
31614     try {
31615       delete arg1;
31616     } CALL_CATCH_EXCEPTION();
31617   }
31618
31619 }
31620
31621
31622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31623   void * jresult ;
31624   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31625
31626   {
31627     try {
31628       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31629     } CALL_CATCH_EXCEPTION(0);
31630   }
31631
31632   jresult = (void *)result;
31633   return jresult;
31634 }
31635
31636
31637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31638   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31639
31640   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31641   {
31642     try {
31643       delete arg1;
31644     } CALL_CATCH_EXCEPTION();
31645   }
31646
31647 }
31648
31649
31650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31651   unsigned int jresult ;
31652   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31653   bool result;
31654
31655   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31656   {
31657     try {
31658       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);
31659     } CALL_CATCH_EXCEPTION(0);
31660   }
31661
31662   jresult = result;
31663   return jresult;
31664 }
31665
31666
31667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31668   unsigned long jresult ;
31669   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31670   std::size_t result;
31671
31672   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31673   {
31674     try {
31675       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);
31676     } CALL_CATCH_EXCEPTION(0);
31677   }
31678
31679   jresult = (unsigned long)result;
31680   return jresult;
31681 }
31682
31683
31684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31685   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31686   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31687
31688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31689   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31690   {
31691     try {
31692       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31693     } CALL_CATCH_EXCEPTION();
31694   }
31695
31696 }
31697
31698
31699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31700   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31701   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31702
31703   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31704   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31705   {
31706     try {
31707       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31708     } CALL_CATCH_EXCEPTION();
31709   }
31710
31711 }
31712
31713
31714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31715   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31716   Dali::Actor arg2 ;
31717   Dali::LongPressGesture *arg3 = 0 ;
31718   Dali::Actor *argp2 ;
31719
31720   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31721   argp2 = (Dali::Actor *)jarg2;
31722   if (!argp2) {
31723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31724     return ;
31725   }
31726   arg2 = *argp2;
31727   arg3 = (Dali::LongPressGesture *)jarg3;
31728   if (!arg3) {
31729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31730     return ;
31731   }
31732   {
31733     try {
31734       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31735     } CALL_CATCH_EXCEPTION();
31736   }
31737
31738 }
31739
31740
31741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31742   void * jresult ;
31743   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31744
31745   {
31746     try {
31747       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31748     } CALL_CATCH_EXCEPTION(0);
31749   }
31750
31751   jresult = (void *)result;
31752   return jresult;
31753 }
31754
31755
31756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31757   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31758
31759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31760   {
31761     try {
31762       delete arg1;
31763     } CALL_CATCH_EXCEPTION();
31764   }
31765
31766 }
31767
31768
31769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31770   unsigned int jresult ;
31771   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31772   bool result;
31773
31774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31775   {
31776     try {
31777       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);
31778     } CALL_CATCH_EXCEPTION(0);
31779   }
31780
31781   jresult = result;
31782   return jresult;
31783 }
31784
31785
31786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31787   unsigned long jresult ;
31788   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31789   std::size_t result;
31790
31791   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31792   {
31793     try {
31794       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);
31795     } CALL_CATCH_EXCEPTION(0);
31796   }
31797
31798   jresult = (unsigned long)result;
31799   return jresult;
31800 }
31801
31802
31803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31804   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31805   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31806
31807   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31808   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31809   {
31810     try {
31811       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31812     } CALL_CATCH_EXCEPTION();
31813   }
31814
31815 }
31816
31817
31818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31819   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31820   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31821
31822   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31823   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31824   {
31825     try {
31826       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31827     } CALL_CATCH_EXCEPTION();
31828   }
31829
31830 }
31831
31832
31833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31834   unsigned int jresult ;
31835   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31836   Dali::Actor arg2 ;
31837   Dali::TouchEvent *arg3 = 0 ;
31838   Dali::Actor *argp2 ;
31839   bool result;
31840
31841   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31842   argp2 = (Dali::Actor *)jarg2;
31843   if (!argp2) {
31844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31845     return 0;
31846   }
31847   arg2 = *argp2;
31848   arg3 = (Dali::TouchEvent *)jarg3;
31849   if (!arg3) {
31850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31851     return 0;
31852   }
31853   {
31854     try {
31855       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31856     } CALL_CATCH_EXCEPTION(0);
31857   }
31858
31859   jresult = result;
31860   return jresult;
31861 }
31862
31863
31864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31865   void * jresult ;
31866   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31867
31868   {
31869     try {
31870       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31871     } CALL_CATCH_EXCEPTION(0);
31872   }
31873
31874   jresult = (void *)result;
31875   return jresult;
31876 }
31877
31878
31879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
31880   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31881
31882   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31883   {
31884     try {
31885       delete arg1;
31886     } CALL_CATCH_EXCEPTION();
31887   }
31888
31889 }
31890
31891
31892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
31893   unsigned int jresult ;
31894   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31895   bool result;
31896
31897   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31898   {
31899     try {
31900       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);
31901     } CALL_CATCH_EXCEPTION(0);
31902   }
31903
31904   jresult = result;
31905   return jresult;
31906 }
31907
31908
31909 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
31910   unsigned long jresult ;
31911   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31912   std::size_t result;
31913
31914   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31915   {
31916     try {
31917       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);
31918     } CALL_CATCH_EXCEPTION(0);
31919   }
31920
31921   jresult = (unsigned long)result;
31922   return jresult;
31923 }
31924
31925
31926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
31927   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31928   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31929
31930   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31931   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31932   {
31933     try {
31934       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31935     } CALL_CATCH_EXCEPTION();
31936   }
31937
31938 }
31939
31940
31941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
31942   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31943   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31944
31945   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31946   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31947   {
31948     try {
31949       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31950     } CALL_CATCH_EXCEPTION();
31951   }
31952
31953 }
31954
31955
31956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31957   unsigned int jresult ;
31958   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31959   Dali::Actor arg2 ;
31960   Dali::HoverEvent *arg3 = 0 ;
31961   Dali::Actor *argp2 ;
31962   bool result;
31963
31964   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31965   argp2 = (Dali::Actor *)jarg2;
31966   if (!argp2) {
31967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31968     return 0;
31969   }
31970   arg2 = *argp2;
31971   arg3 = (Dali::HoverEvent *)jarg3;
31972   if (!arg3) {
31973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
31974     return 0;
31975   }
31976   {
31977     try {
31978       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
31979     } CALL_CATCH_EXCEPTION(0);
31980   }
31981
31982   jresult = result;
31983   return jresult;
31984 }
31985
31986
31987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
31988   void * jresult ;
31989   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
31990
31991   {
31992     try {
31993       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
31994     } CALL_CATCH_EXCEPTION(0);
31995   }
31996
31997   jresult = (void *)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32003   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32004
32005   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32006   {
32007     try {
32008       delete arg1;
32009     } CALL_CATCH_EXCEPTION();
32010   }
32011
32012 }
32013
32014
32015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32016   unsigned int jresult ;
32017   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32018   bool result;
32019
32020   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32021   {
32022     try {
32023       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);
32024     } CALL_CATCH_EXCEPTION(0);
32025   }
32026
32027   jresult = result;
32028   return jresult;
32029 }
32030
32031
32032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32033   unsigned long jresult ;
32034   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32035   std::size_t result;
32036
32037   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32038   {
32039     try {
32040       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);
32041     } CALL_CATCH_EXCEPTION(0);
32042   }
32043
32044   jresult = (unsigned long)result;
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32050   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32051   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32052
32053   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32054   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32055   {
32056     try {
32057       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32058     } CALL_CATCH_EXCEPTION();
32059   }
32060
32061 }
32062
32063
32064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32065   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32066   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32067
32068   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32069   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32070   {
32071     try {
32072       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32073     } CALL_CATCH_EXCEPTION();
32074   }
32075
32076 }
32077
32078
32079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32080   unsigned int jresult ;
32081   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32082   Dali::Actor arg2 ;
32083   Dali::WheelEvent *arg3 = 0 ;
32084   Dali::Actor *argp2 ;
32085   bool result;
32086
32087   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32088   argp2 = (Dali::Actor *)jarg2;
32089   if (!argp2) {
32090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32091     return 0;
32092   }
32093   arg2 = *argp2;
32094   arg3 = (Dali::WheelEvent *)jarg3;
32095   if (!arg3) {
32096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32097     return 0;
32098   }
32099   {
32100     try {
32101       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32102     } CALL_CATCH_EXCEPTION(0);
32103   }
32104
32105   jresult = result;
32106   return jresult;
32107 }
32108
32109
32110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32111   void * jresult ;
32112   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32113
32114   {
32115     try {
32116       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32117     } CALL_CATCH_EXCEPTION(0);
32118   }
32119
32120   jresult = (void *)result;
32121   return jresult;
32122 }
32123
32124
32125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32126   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32127
32128   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32129   {
32130     try {
32131       delete arg1;
32132     } CALL_CATCH_EXCEPTION();
32133   }
32134
32135 }
32136
32137
32138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32139   unsigned int jresult ;
32140   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32141   bool result;
32142
32143   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32144   {
32145     try {
32146       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32147     } CALL_CATCH_EXCEPTION(0);
32148   }
32149
32150   jresult = result;
32151   return jresult;
32152 }
32153
32154
32155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32156   unsigned long jresult ;
32157   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32158   std::size_t result;
32159
32160   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32161   {
32162     try {
32163       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32164     } CALL_CATCH_EXCEPTION(0);
32165   }
32166
32167   jresult = (unsigned long)result;
32168   return jresult;
32169 }
32170
32171
32172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32173   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32174   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32175
32176   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32177   arg2 = (void (*)(Dali::Actor))jarg2;
32178   {
32179     try {
32180       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32181     } CALL_CATCH_EXCEPTION();
32182   }
32183
32184 }
32185
32186
32187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32188   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32189   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32190
32191   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32192   arg2 = (void (*)(Dali::Actor))jarg2;
32193   {
32194     try {
32195       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32196     } CALL_CATCH_EXCEPTION();
32197   }
32198
32199 }
32200
32201
32202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32203   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32204   Dali::Actor arg2 ;
32205   Dali::Actor *argp2 ;
32206
32207   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32208   argp2 = (Dali::Actor *)jarg2;
32209   if (!argp2) {
32210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32211     return ;
32212   }
32213   arg2 = *argp2;
32214   {
32215     try {
32216       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32217     } CALL_CATCH_EXCEPTION();
32218   }
32219
32220 }
32221
32222
32223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32224   void * jresult ;
32225   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32226
32227   {
32228     try {
32229       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32230     } CALL_CATCH_EXCEPTION(0);
32231   }
32232
32233   jresult = (void *)result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32239   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32240
32241   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32242   {
32243     try {
32244       delete arg1;
32245     } CALL_CATCH_EXCEPTION();
32246   }
32247
32248 }
32249
32250
32251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32252   unsigned int jresult ;
32253   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32254   bool result;
32255
32256   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32257   {
32258     try {
32259       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32260     } CALL_CATCH_EXCEPTION(0);
32261   }
32262
32263   jresult = result;
32264   return jresult;
32265 }
32266
32267
32268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32269   unsigned long jresult ;
32270   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32271   std::size_t result;
32272
32273   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32274   {
32275     try {
32276       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32277     } CALL_CATCH_EXCEPTION(0);
32278   }
32279
32280   jresult = (unsigned long)result;
32281   return jresult;
32282 }
32283
32284
32285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32287   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32288
32289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32290   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32291   {
32292     try {
32293       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32294     } CALL_CATCH_EXCEPTION();
32295   }
32296
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32301   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32302   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32303
32304   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32305   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32306   {
32307     try {
32308       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32309     } CALL_CATCH_EXCEPTION();
32310   }
32311
32312 }
32313
32314
32315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32316   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32317   Dali::KeyEvent *arg2 = 0 ;
32318
32319   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32320   arg2 = (Dali::KeyEvent *)jarg2;
32321   if (!arg2) {
32322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32323     return ;
32324   }
32325   {
32326     try {
32327       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32328     } CALL_CATCH_EXCEPTION();
32329   }
32330
32331 }
32332
32333
32334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32335   void * jresult ;
32336   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32337
32338   {
32339     try {
32340       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32341     } CALL_CATCH_EXCEPTION(0);
32342   }
32343
32344   jresult = (void *)result;
32345   return jresult;
32346 }
32347
32348
32349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32350   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32351
32352   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32353   {
32354     try {
32355       delete arg1;
32356     } CALL_CATCH_EXCEPTION();
32357   }
32358
32359 }
32360
32361
32362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32363   unsigned int jresult ;
32364   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32365   bool result;
32366
32367   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32368   {
32369     try {
32370       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32371     } CALL_CATCH_EXCEPTION(0);
32372   }
32373
32374   jresult = result;
32375   return jresult;
32376 }
32377
32378
32379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32380   unsigned long jresult ;
32381   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32382   std::size_t result;
32383
32384   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32385   {
32386     try {
32387       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32388     } CALL_CATCH_EXCEPTION(0);
32389   }
32390
32391   jresult = (unsigned long)result;
32392   return jresult;
32393 }
32394
32395
32396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32397   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32398   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32399
32400   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32401   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32402   {
32403     try {
32404       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32405     } CALL_CATCH_EXCEPTION();
32406   }
32407
32408 }
32409
32410
32411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32412   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32413   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32414
32415   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32416   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32417   {
32418     try {
32419       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32420     } CALL_CATCH_EXCEPTION();
32421   }
32422
32423 }
32424
32425
32426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32427   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32428   Dali::TouchEvent *arg2 = 0 ;
32429
32430   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32431   arg2 = (Dali::TouchEvent *)jarg2;
32432   if (!arg2) {
32433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32434     return ;
32435   }
32436   {
32437     try {
32438       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32439     } CALL_CATCH_EXCEPTION();
32440   }
32441
32442 }
32443
32444
32445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32446   void * jresult ;
32447   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32448
32449   {
32450     try {
32451       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32452     } CALL_CATCH_EXCEPTION(0);
32453   }
32454
32455   jresult = (void *)result;
32456   return jresult;
32457 }
32458
32459
32460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32461   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32462
32463   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32464   {
32465     try {
32466       delete arg1;
32467     } CALL_CATCH_EXCEPTION();
32468   }
32469
32470 }
32471
32472
32473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32474   unsigned int jresult ;
32475   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32476   bool result;
32477
32478   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32479   {
32480     try {
32481       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32482     } CALL_CATCH_EXCEPTION(0);
32483   }
32484
32485   jresult = result;
32486   return jresult;
32487 }
32488
32489
32490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32491   unsigned long jresult ;
32492   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32493   std::size_t result;
32494
32495   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32496   {
32497     try {
32498       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32499     } CALL_CATCH_EXCEPTION(0);
32500   }
32501
32502   jresult = (unsigned long)result;
32503   return jresult;
32504 }
32505
32506
32507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32508   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32509   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32510
32511   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32512   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32513   {
32514     try {
32515       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32516     } CALL_CATCH_EXCEPTION();
32517   }
32518
32519 }
32520
32521
32522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32523   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32524   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32525
32526   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32527   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32528   {
32529     try {
32530       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32531     } CALL_CATCH_EXCEPTION();
32532   }
32533
32534 }
32535
32536
32537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32538   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32539   Dali::WheelEvent *arg2 = 0 ;
32540
32541   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32542   arg2 = (Dali::WheelEvent *)jarg2;
32543   if (!arg2) {
32544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32545     return ;
32546   }
32547   {
32548     try {
32549       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32550     } CALL_CATCH_EXCEPTION();
32551   }
32552
32553 }
32554
32555
32556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32557   void * jresult ;
32558   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32559
32560   {
32561     try {
32562       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32563     } CALL_CATCH_EXCEPTION(0);
32564   }
32565
32566   jresult = (void *)result;
32567   return jresult;
32568 }
32569
32570
32571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32572   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32573
32574   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32575   {
32576     try {
32577       delete arg1;
32578     } CALL_CATCH_EXCEPTION();
32579   }
32580
32581 }
32582
32583
32584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32585   void * jresult ;
32586   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32587
32588   {
32589     try {
32590       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32591     } CALL_CATCH_EXCEPTION(0);
32592   }
32593
32594   jresult = (void *)result;
32595   return jresult;
32596 }
32597
32598
32599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32600   void * jresult ;
32601   Dali::Radian arg1 ;
32602   Dali::Radian arg2 ;
32603   Dali::Radian *argp1 ;
32604   Dali::Radian *argp2 ;
32605   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32606
32607   argp1 = (Dali::Radian *)jarg1;
32608   if (!argp1) {
32609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32610     return 0;
32611   }
32612   arg1 = *argp1;
32613   argp2 = (Dali::Radian *)jarg2;
32614   if (!argp2) {
32615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32616     return 0;
32617   }
32618   arg2 = *argp2;
32619   {
32620     try {
32621       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32622     } CALL_CATCH_EXCEPTION(0);
32623   }
32624
32625   jresult = (void *)result;
32626   return jresult;
32627 }
32628
32629
32630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32631   void * jresult ;
32632   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32633   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32634
32635   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32636   if (!arg1) {
32637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32638     return 0;
32639   }
32640   {
32641     try {
32642       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32643     } CALL_CATCH_EXCEPTION(0);
32644   }
32645
32646   jresult = (void *)result;
32647   return jresult;
32648 }
32649
32650
32651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32652   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32653   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32654
32655   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32656   arg2 = (Dali::Radian *)jarg2;
32657   if (arg1) (arg1)->first = *arg2;
32658 }
32659
32660
32661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32662   void * jresult ;
32663   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32664   Dali::Radian *result = 0 ;
32665
32666   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32667   result = (Dali::Radian *)& ((arg1)->first);
32668   jresult = (void *)result;
32669   return jresult;
32670 }
32671
32672
32673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32674   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32675   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32676
32677   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32678   arg2 = (Dali::Radian *)jarg2;
32679   if (arg1) (arg1)->second = *arg2;
32680 }
32681
32682
32683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32684   void * jresult ;
32685   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32686   Dali::Radian *result = 0 ;
32687
32688   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32689   result = (Dali::Radian *)& ((arg1)->second);
32690   jresult = (void *)result;
32691   return jresult;
32692 }
32693
32694
32695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32696   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32697
32698   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32699   {
32700     try {
32701       delete arg1;
32702     } CALL_CATCH_EXCEPTION();
32703   }
32704
32705 }
32706
32707
32708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32709   unsigned int jresult ;
32710   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32711   bool result;
32712
32713   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32714   {
32715     try {
32716       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);
32717     } CALL_CATCH_EXCEPTION(0);
32718   }
32719
32720   jresult = result;
32721   return jresult;
32722 }
32723
32724
32725 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32726   unsigned long jresult ;
32727   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32728   std::size_t result;
32729
32730   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32731   {
32732     try {
32733       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);
32734     } CALL_CATCH_EXCEPTION(0);
32735   }
32736
32737   jresult = (unsigned long)result;
32738   return jresult;
32739 }
32740
32741
32742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32743   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32744   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32745
32746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32747   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32748   {
32749     try {
32750       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32751     } CALL_CATCH_EXCEPTION();
32752   }
32753
32754 }
32755
32756
32757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32758   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32759   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32760
32761   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32762   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32763   {
32764     try {
32765       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32766     } CALL_CATCH_EXCEPTION();
32767   }
32768
32769 }
32770
32771
32772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32773   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32774   Dali::Actor arg2 ;
32775   Dali::PanGesture *arg3 = 0 ;
32776   Dali::Actor *argp2 ;
32777
32778   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32779   argp2 = (Dali::Actor *)jarg2;
32780   if (!argp2) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32782     return ;
32783   }
32784   arg2 = *argp2;
32785   arg3 = (Dali::PanGesture *)jarg3;
32786   if (!arg3) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32788     return ;
32789   }
32790   {
32791     try {
32792       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32793     } CALL_CATCH_EXCEPTION();
32794   }
32795
32796 }
32797
32798
32799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32800   void * jresult ;
32801   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32802
32803   {
32804     try {
32805       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32806     } CALL_CATCH_EXCEPTION(0);
32807   }
32808
32809   jresult = (void *)result;
32810   return jresult;
32811 }
32812
32813
32814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32815   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32816
32817   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32818   {
32819     try {
32820       delete arg1;
32821     } CALL_CATCH_EXCEPTION();
32822   }
32823
32824 }
32825
32826
32827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32828   unsigned int jresult ;
32829   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32830   bool result;
32831
32832   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32833   {
32834     try {
32835       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);
32836     } CALL_CATCH_EXCEPTION(0);
32837   }
32838
32839   jresult = result;
32840   return jresult;
32841 }
32842
32843
32844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32845   unsigned long jresult ;
32846   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32847   std::size_t result;
32848
32849   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32850   {
32851     try {
32852       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);
32853     } CALL_CATCH_EXCEPTION(0);
32854   }
32855
32856   jresult = (unsigned long)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32862   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32863   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32864
32865   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32866   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32867   {
32868     try {
32869       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32870     } CALL_CATCH_EXCEPTION();
32871   }
32872
32873 }
32874
32875
32876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32877   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32878   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32879
32880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32881   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32882   {
32883     try {
32884       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32885     } CALL_CATCH_EXCEPTION();
32886   }
32887
32888 }
32889
32890
32891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32892   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32893   Dali::Actor arg2 ;
32894   Dali::PinchGesture *arg3 = 0 ;
32895   Dali::Actor *argp2 ;
32896
32897   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32898   argp2 = (Dali::Actor *)jarg2;
32899   if (!argp2) {
32900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32901     return ;
32902   }
32903   arg2 = *argp2;
32904   arg3 = (Dali::PinchGesture *)jarg3;
32905   if (!arg3) {
32906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
32907     return ;
32908   }
32909   {
32910     try {
32911       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
32912     } CALL_CATCH_EXCEPTION();
32913   }
32914
32915 }
32916
32917
32918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
32919   void * jresult ;
32920   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
32921
32922   {
32923     try {
32924       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
32925     } CALL_CATCH_EXCEPTION(0);
32926   }
32927
32928   jresult = (void *)result;
32929   return jresult;
32930 }
32931
32932
32933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
32934   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32935
32936   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32937   {
32938     try {
32939       delete arg1;
32940     } CALL_CATCH_EXCEPTION();
32941   }
32942
32943 }
32944
32945
32946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
32947   unsigned int jresult ;
32948   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32949   bool result;
32950
32951   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32952   {
32953     try {
32954       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);
32955     } CALL_CATCH_EXCEPTION(0);
32956   }
32957
32958   jresult = result;
32959   return jresult;
32960 }
32961
32962
32963 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32964   unsigned long jresult ;
32965   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32966   std::size_t result;
32967
32968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32969   {
32970     try {
32971       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);
32972     } CALL_CATCH_EXCEPTION(0);
32973   }
32974
32975   jresult = (unsigned long)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32981   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32982   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
32983
32984   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32985   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
32986   {
32987     try {
32988       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32989     } CALL_CATCH_EXCEPTION();
32990   }
32991
32992 }
32993
32994
32995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32996   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32997   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
32998
32999   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33000   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33001   {
33002     try {
33003       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33004     } CALL_CATCH_EXCEPTION();
33005   }
33006
33007 }
33008
33009
33010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33011   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33012   Dali::Actor arg2 ;
33013   Dali::TapGesture *arg3 = 0 ;
33014   Dali::Actor *argp2 ;
33015
33016   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33017   argp2 = (Dali::Actor *)jarg2;
33018   if (!argp2) {
33019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33020     return ;
33021   }
33022   arg2 = *argp2;
33023   arg3 = (Dali::TapGesture *)jarg3;
33024   if (!arg3) {
33025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33026     return ;
33027   }
33028   {
33029     try {
33030       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33031     } CALL_CATCH_EXCEPTION();
33032   }
33033
33034 }
33035
33036
33037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33038   void * jresult ;
33039   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33040
33041   {
33042     try {
33043       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33044     } CALL_CATCH_EXCEPTION(0);
33045   }
33046
33047   jresult = (void *)result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33053   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33054
33055   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33056   {
33057     try {
33058       delete arg1;
33059     } CALL_CATCH_EXCEPTION();
33060   }
33061
33062 }
33063
33064
33065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33066   unsigned int jresult ;
33067   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33068   bool result = false;
33069
33070   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33071   {
33072     try {
33073       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);
33074     } CALL_CATCH_EXCEPTION(0);
33075   }
33076   jresult = result;
33077   return jresult;
33078 }
33079
33080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33081   unsigned long jresult ;
33082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33083   std::size_t result = 0;
33084
33085   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33086   {
33087     try {
33088       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);
33089     }CALL_CATCH_EXCEPTION(0);
33090   }
33091   jresult = (unsigned long)result;
33092   return jresult;
33093 }
33094
33095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33096   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33097   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33098
33099   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33100   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33101   {
33102     try {
33103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33104     } CALL_CATCH_EXCEPTION();
33105   }
33106 }
33107
33108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33109   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33110   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33111
33112   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33113   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33114   {
33115     try {
33116       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33117     } CALL_CATCH_EXCEPTION();
33118   }
33119 }
33120
33121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33122   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33123   Dali::Actor arg2 ;
33124   //bool arg3 ;
33125   Dali::LayoutDirection::Type arg4 ;
33126   Dali::Actor *argp2 ;
33127
33128   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33129   argp2 = (Dali::Actor *)jarg2;
33130   if (!argp2) {
33131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33132     return ;
33133   }
33134   arg2 = *argp2;
33135   //arg3 = jarg3 ? true : false;
33136   arg4 = (Dali::LayoutDirection::Type)jarg4;
33137   {
33138     try {
33139       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33140     } CALL_CATCH_EXCEPTION();
33141   }
33142 }
33143
33144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33145   void * jresult ;
33146   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33147
33148   {
33149     try {
33150       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33151     } CALL_CATCH_EXCEPTION(0);
33152   }
33153   jresult = (void *)result;
33154   return jresult;
33155 }
33156
33157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33158   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33159
33160   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33161   {
33162     try {
33163       delete arg1;
33164     } CALL_CATCH_EXCEPTION();
33165   }
33166 }
33167
33168
33169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
33170   unsigned int jresult ;
33171   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33172   bool result = false;
33173
33174   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33175   {
33176     try {
33177       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);
33178     } CALL_CATCH_EXCEPTION(0);
33179   }
33180   jresult = result;
33181   return jresult;
33182 }
33183
33184
33185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33186   unsigned long jresult ;
33187   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33188   std::size_t result;
33189
33190   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33191   {
33192     try {
33193       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);
33194     } CALL_CATCH_EXCEPTION(0);
33195   }
33196
33197   jresult = (unsigned long)result;
33198   return jresult;
33199 }
33200
33201
33202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33203   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33204   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33205
33206   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33207   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33208   {
33209     try {
33210       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33211     } CALL_CATCH_EXCEPTION();
33212   }
33213
33214 }
33215
33216
33217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33219   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33220
33221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33222   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33223   {
33224     try {
33225       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33226     } CALL_CATCH_EXCEPTION();
33227   }
33228
33229 }
33230
33231
33232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33233   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33234   Dali::Actor arg2 ;
33235   bool arg3 ;
33236   Dali::DevelActor::VisibilityChange::Type arg4 ;
33237   Dali::Actor *argp2 ;
33238
33239   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33240   argp2 = (Dali::Actor *)jarg2;
33241   if (!argp2) {
33242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33243     return ;
33244   }
33245   arg2 = *argp2;
33246   arg3 = jarg3 ? true : false;
33247   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33248   {
33249     try {
33250       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33251     } CALL_CATCH_EXCEPTION();
33252   }
33253
33254 }
33255
33256
33257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33258   void * jresult ;
33259   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33260
33261   {
33262     try {
33263       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33264     } CALL_CATCH_EXCEPTION(0);
33265   }
33266
33267   jresult = (void *)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33273   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33274
33275   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33276   {
33277     try {
33278       delete arg1;
33279     } CALL_CATCH_EXCEPTION();
33280   }
33281
33282 }
33283
33284
33285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33286   void * jresult ;
33287   Dali::Timer *result = 0 ;
33288
33289   {
33290     try {
33291       result = (Dali::Timer *)new Dali::Timer();
33292     } CALL_CATCH_EXCEPTION(0);
33293   }
33294
33295   jresult = (void *)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33301   void * jresult ;
33302   unsigned int arg1 ;
33303   Dali::Timer result;
33304
33305   arg1 = (unsigned int)jarg1;
33306   {
33307     try {
33308       result = Dali::Timer::New(arg1);
33309     } CALL_CATCH_EXCEPTION(0);
33310   }
33311
33312   jresult = new Dali::Timer((const Dali::Timer &)result);
33313   return jresult;
33314 }
33315
33316
33317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33318   void * jresult ;
33319   Dali::Timer *arg1 = 0 ;
33320   Dali::Timer *result = 0 ;
33321
33322   arg1 = (Dali::Timer *)jarg1;
33323   if (!arg1) {
33324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33325     return 0;
33326   }
33327   {
33328     try {
33329       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33330     } CALL_CATCH_EXCEPTION(0);
33331   }
33332
33333   jresult = (void *)result;
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33339   void * jresult ;
33340   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33341   Dali::Timer *arg2 = 0 ;
33342   Dali::Timer *result = 0 ;
33343
33344   arg1 = (Dali::Timer *)jarg1;
33345   arg2 = (Dali::Timer *)jarg2;
33346   if (!arg2) {
33347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33348     return 0;
33349   }
33350   {
33351     try {
33352       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33353     } CALL_CATCH_EXCEPTION(0);
33354   }
33355
33356   jresult = (void *)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33362   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33363
33364   arg1 = (Dali::Timer *)jarg1;
33365   {
33366     try {
33367       delete arg1;
33368     } CALL_CATCH_EXCEPTION();
33369   }
33370
33371 }
33372
33373
33374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33375   void * jresult ;
33376   Dali::BaseHandle arg1 ;
33377   Dali::BaseHandle *argp1 ;
33378   Dali::Timer result;
33379
33380   argp1 = (Dali::BaseHandle *)jarg1;
33381   if (!argp1) {
33382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33383     return 0;
33384   }
33385   arg1 = *argp1;
33386   {
33387     try {
33388       result = Dali::Timer::DownCast(arg1);
33389     } CALL_CATCH_EXCEPTION(0);
33390   }
33391
33392   jresult = new Dali::Timer((const Dali::Timer &)result);
33393   return jresult;
33394 }
33395
33396
33397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33398   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33399
33400   arg1 = (Dali::Timer *)jarg1;
33401   {
33402     try {
33403       (arg1)->Start();
33404     } CALL_CATCH_EXCEPTION();
33405   }
33406
33407 }
33408
33409
33410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33411   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33412
33413   arg1 = (Dali::Timer *)jarg1;
33414   {
33415     try {
33416       (arg1)->Stop();
33417     } CALL_CATCH_EXCEPTION();
33418   }
33419
33420 }
33421
33422
33423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33424   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33425   unsigned int arg2 ;
33426
33427   arg1 = (Dali::Timer *)jarg1;
33428   arg2 = (unsigned int)jarg2;
33429   {
33430     try {
33431       (arg1)->SetInterval(arg2);
33432     } CALL_CATCH_EXCEPTION();
33433   }
33434
33435 }
33436
33437
33438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33439   unsigned int jresult ;
33440   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33441   unsigned int result;
33442
33443   arg1 = (Dali::Timer *)jarg1;
33444   {
33445     try {
33446       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33447     } CALL_CATCH_EXCEPTION(0);
33448   }
33449
33450   jresult = result;
33451   return jresult;
33452 }
33453
33454
33455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33456   unsigned int jresult ;
33457   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33458   bool result;
33459
33460   arg1 = (Dali::Timer *)jarg1;
33461   {
33462     try {
33463       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33464     } CALL_CATCH_EXCEPTION(0);
33465   }
33466
33467   jresult = result;
33468   return jresult;
33469 }
33470
33471
33472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33473   void * jresult ;
33474   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33475   Dali::Timer::TimerSignalType *result = 0 ;
33476
33477   arg1 = (Dali::Timer *)jarg1;
33478   {
33479     try {
33480       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33481     } CALL_CATCH_EXCEPTION(0);
33482   }
33483
33484   jresult = (void *)result;
33485   return jresult;
33486 }
33487
33488
33489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33490   unsigned int jresult ;
33491   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33492   bool result;
33493
33494   arg1 = (Dali::Signal< bool () > *)jarg1;
33495   {
33496     try {
33497       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33498     } CALL_CATCH_EXCEPTION(0);
33499   }
33500
33501   jresult = result;
33502   return jresult;
33503 }
33504
33505
33506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33507   unsigned long jresult ;
33508   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33509   std::size_t result;
33510
33511   arg1 = (Dali::Signal< bool () > *)jarg1;
33512   {
33513     try {
33514       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33515     } CALL_CATCH_EXCEPTION(0);
33516   }
33517
33518   jresult = (unsigned long)result;
33519   return jresult;
33520 }
33521
33522
33523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33524   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33525   bool (*arg2)() = (bool (*)()) 0 ;
33526
33527   arg1 = (Dali::Signal< bool () > *)jarg1;
33528   arg2 = (bool (*)())jarg2;
33529   {
33530     try {
33531       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33532     } CALL_CATCH_EXCEPTION();
33533   }
33534
33535 }
33536
33537
33538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33539   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33540   bool (*arg2)() = (bool (*)()) 0 ;
33541
33542   arg1 = (Dali::Signal< bool () > *)jarg1;
33543   arg2 = (bool (*)())jarg2;
33544   {
33545     try {
33546       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33547     } CALL_CATCH_EXCEPTION();
33548   }
33549
33550 }
33551
33552
33553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33554   unsigned int jresult ;
33555   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33556   bool result;
33557
33558   arg1 = (Dali::Signal< bool () > *)jarg1;
33559   {
33560     try {
33561       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33562     } CALL_CATCH_EXCEPTION(0);
33563   }
33564
33565   jresult = result;
33566   return jresult;
33567 }
33568
33569
33570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33571   void * jresult ;
33572   Dali::Signal< bool () > *result = 0 ;
33573
33574   {
33575     try {
33576       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33577     } CALL_CATCH_EXCEPTION(0);
33578   }
33579
33580   jresult = (void *)result;
33581   return jresult;
33582 }
33583
33584
33585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33586   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33587
33588   arg1 = (Dali::Signal< bool () > *)jarg1;
33589   {
33590     try {
33591       delete arg1;
33592     } CALL_CATCH_EXCEPTION();
33593   }
33594
33595 }
33596
33597
33598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33599   int jresult ;
33600   int result;
33601
33602   {
33603     try {
33604       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33605     } CALL_CATCH_EXCEPTION(0);
33606   }
33607
33608   jresult = (int)result;
33609   return jresult;
33610 }
33611
33612
33613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33614   int jresult ;
33615   int result;
33616
33617   {
33618     try {
33619       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33620     } CALL_CATCH_EXCEPTION(0);
33621   }
33622
33623   jresult = (int)result;
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33629   int jresult ;
33630   int result;
33631
33632   {
33633     try {
33634       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33635     } CALL_CATCH_EXCEPTION(0);
33636   }
33637
33638   jresult = (int)result;
33639   return jresult;
33640 }
33641
33642
33643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33644   int jresult ;
33645   int result;
33646
33647   {
33648     try {
33649       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33650     } CALL_CATCH_EXCEPTION(0);
33651   }
33652
33653   jresult = (int)result;
33654   return jresult;
33655 }
33656
33657
33658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33659   int jresult ;
33660   int result;
33661
33662   {
33663     try {
33664       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33665     } CALL_CATCH_EXCEPTION(0);
33666   }
33667
33668   jresult = (int)result;
33669   return jresult;
33670 }
33671
33672
33673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33674   int jresult ;
33675   int result;
33676
33677   {
33678     try {
33679       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33680     } CALL_CATCH_EXCEPTION(0);
33681   }
33682
33683   jresult = (int)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33689   int jresult ;
33690   int result;
33691
33692   {
33693     try {
33694       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33695     } CALL_CATCH_EXCEPTION(0);
33696   }
33697
33698   jresult = (int)result;
33699   return jresult;
33700 }
33701
33702
33703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33704   int jresult ;
33705   int result;
33706
33707   {
33708     try {
33709       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33710     } CALL_CATCH_EXCEPTION(0);
33711   }
33712
33713   jresult = (int)result;
33714   return jresult;
33715 }
33716
33717
33718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33719   int jresult ;
33720   int result;
33721
33722   {
33723     try {
33724       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33725     } CALL_CATCH_EXCEPTION(0);
33726   }
33727
33728   jresult = (int)result;
33729   return jresult;
33730 }
33731
33732
33733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33734   int jresult ;
33735   int result;
33736
33737   {
33738     try {
33739       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33740     } CALL_CATCH_EXCEPTION(0);
33741   }
33742
33743   jresult = (int)result;
33744   return jresult;
33745 }
33746
33747
33748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33749   int jresult ;
33750   int result;
33751
33752   {
33753     try {
33754       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33755     } CALL_CATCH_EXCEPTION(0);
33756   }
33757
33758   jresult = (int)result;
33759   return jresult;
33760 }
33761
33762
33763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33764   int jresult ;
33765   int result;
33766
33767   {
33768     try {
33769       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33770     } CALL_CATCH_EXCEPTION(0);
33771   }
33772
33773   jresult = (int)result;
33774   return jresult;
33775 }
33776
33777
33778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33779   int jresult ;
33780   int result;
33781
33782   {
33783     try {
33784       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33785     } CALL_CATCH_EXCEPTION(0);
33786   }
33787
33788   jresult = (int)result;
33789   return jresult;
33790 }
33791
33792
33793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33794   int jresult ;
33795   int result;
33796
33797   {
33798     try {
33799       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33800     } CALL_CATCH_EXCEPTION(0);
33801   }
33802
33803   jresult = (int)result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33809   int jresult ;
33810   int result;
33811
33812   {
33813     try {
33814       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33815     } CALL_CATCH_EXCEPTION(0);
33816   }
33817
33818   jresult = (int)result;
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33824   int jresult ;
33825   int result;
33826
33827   {
33828     try {
33829       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33830     } CALL_CATCH_EXCEPTION(0);
33831   }
33832
33833   jresult = (int)result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33839   int jresult ;
33840   int result;
33841
33842   {
33843     try {
33844       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33845     } CALL_CATCH_EXCEPTION(0);
33846   }
33847
33848   jresult = (int)result;
33849   return jresult;
33850 }
33851
33852
33853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33854   int jresult ;
33855   int result;
33856
33857   {
33858     try {
33859       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33860     } CALL_CATCH_EXCEPTION(0);
33861   }
33862
33863   jresult = (int)result;
33864   return jresult;
33865 }
33866
33867
33868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33869   int jresult ;
33870   int result;
33871
33872   {
33873     try {
33874       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33875     } CALL_CATCH_EXCEPTION(0);
33876   }
33877
33878   jresult = (int)result;
33879   return jresult;
33880 }
33881
33882
33883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
33884   int jresult ;
33885   int result;
33886
33887   {
33888     try {
33889       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
33890     } CALL_CATCH_EXCEPTION(0);
33891   }
33892
33893   jresult = (int)result;
33894   return jresult;
33895 }
33896
33897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
33898   int jresult ;
33899   int result;
33900
33901   {
33902     try {
33903       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
33904     } CALL_CATCH_EXCEPTION(0);
33905   }
33906
33907   jresult = (int)result;
33908   return jresult;
33909 }
33910
33911
33912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
33913   int jresult ;
33914   int result;
33915   {
33916     try
33917     {
33918       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
33919     } CALL_CATCH_EXCEPTION(0);
33920   }
33921
33922   jresult = (int)result;
33923   return jresult;
33924 }
33925
33926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
33927   int jresult ;
33928   int result;
33929   {
33930     try
33931     {
33932       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
33933     } CALL_CATCH_EXCEPTION(0);
33934   }
33935
33936   jresult = (int)result;
33937   return jresult;
33938 }
33939
33940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
33941   int jresult ;
33942   int result;
33943   {
33944     try
33945     {
33946       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
33947     } CALL_CATCH_EXCEPTION(0);
33948   }
33949
33950   jresult = (int)result;
33951   return jresult;
33952 }
33953
33954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
33955   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
33956 }
33957
33958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
33959   int jresult ;
33960   int result;
33961   {
33962     try
33963     {
33964       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
33965     } CALL_CATCH_EXCEPTION(0);
33966   }
33967
33968   jresult = (int)result;
33969   return jresult;
33970 }
33971
33972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
33973   int jresult ;
33974   int result;
33975   {
33976     try
33977     {
33978       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
33979     } CALL_CATCH_EXCEPTION(0);
33980   }
33981
33982   jresult = (int)result;
33983   return jresult;
33984 }
33985
33986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
33987   int jresult ;
33988   int result;
33989
33990   {
33991     try {
33992       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
33993     } CALL_CATCH_EXCEPTION(0);
33994   }
33995
33996   jresult = (int)result;
33997   return jresult;
33998 }
33999
34000
34001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34002   int jresult ;
34003   int result;
34004
34005   {
34006     try {
34007       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34008     } CALL_CATCH_EXCEPTION(0);
34009   }
34010
34011   jresult = (int)result;
34012   return jresult;
34013 }
34014
34015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34016   int jresult ;
34017   int result;
34018   {
34019     try
34020     {
34021       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34022     } CALL_CATCH_EXCEPTION(0);
34023   }
34024
34025   jresult = (int)result;
34026   return jresult;
34027 }
34028
34029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34030   int jresult ;
34031   int result;
34032   {
34033     try
34034     {
34035       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34036     } CALL_CATCH_EXCEPTION(0);
34037   }
34038
34039   jresult = (int)result;
34040   return jresult;
34041 }
34042
34043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34044   int jresult ;
34045   int result;
34046   {
34047     try
34048     {
34049       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34050     } CALL_CATCH_EXCEPTION(0);
34051   }
34052
34053   jresult = (int)result;
34054   return jresult;
34055 }
34056
34057
34058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34059   int jresult ;
34060   int result;
34061   {
34062     try
34063     {
34064       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34065     } CALL_CATCH_EXCEPTION(0);
34066   }
34067
34068   jresult = (int)result;
34069   return jresult;
34070 }
34071
34072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34073   int jresult ;
34074   int result;
34075   {
34076     try
34077     {
34078       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34079     } CALL_CATCH_EXCEPTION(0);
34080   }
34081
34082   jresult = (int)result;
34083   return jresult;
34084 }
34085
34086
34087
34088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34089   int jresult ;
34090   int result;
34091
34092   {
34093     try {
34094       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34095     } CALL_CATCH_EXCEPTION(0);
34096   }
34097
34098   jresult = (int)result;
34099   return jresult;
34100 }
34101
34102
34103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34104   int jresult ;
34105   int result;
34106
34107   {
34108     try {
34109       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34110     } CALL_CATCH_EXCEPTION(0);
34111   }
34112
34113   jresult = (int)result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34119   int jresult ;
34120   int result;
34121
34122   {
34123     try {
34124       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34125     } CALL_CATCH_EXCEPTION(0);
34126   }
34127
34128   jresult = (int)result;
34129   return jresult;
34130 }
34131
34132
34133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34134   int jresult ;
34135   int result;
34136
34137   {
34138     try {
34139       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34140     } CALL_CATCH_EXCEPTION(0);
34141   }
34142
34143   jresult = (int)result;
34144   return jresult;
34145 }
34146
34147
34148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34149   int jresult ;
34150   int result;
34151
34152   {
34153     try {
34154       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34155     } CALL_CATCH_EXCEPTION(0);
34156   }
34157
34158   jresult = (int)result;
34159   return jresult;
34160 }
34161
34162
34163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34164   int jresult ;
34165   int result;
34166
34167   {
34168     try {
34169       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34170     } CALL_CATCH_EXCEPTION(0);
34171   }
34172
34173   jresult = (int)result;
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34179   int jresult ;
34180   int result;
34181
34182   {
34183     try {
34184       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34185     } CALL_CATCH_EXCEPTION(0);
34186   }
34187
34188   jresult = (int)result;
34189   return jresult;
34190 }
34191
34192 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34193   int jresult ;
34194   int result;
34195
34196   {
34197     try {
34198       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34199     } CALL_CATCH_EXCEPTION(0);
34200   }
34201
34202   jresult = (int)result;
34203   return jresult;
34204 }
34205
34206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34207   int jresult ;
34208   int result;
34209
34210   {
34211     try {
34212       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34213     } CALL_CATCH_EXCEPTION(0);
34214   }
34215
34216   jresult = (int)result;
34217   return jresult;
34218 }
34219
34220
34221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34222   int jresult ;
34223   int result;
34224
34225   {
34226     try {
34227       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34228     } CALL_CATCH_EXCEPTION(0);
34229   }
34230
34231   jresult = (int)result;
34232   return jresult;
34233 }
34234
34235
34236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34237   int jresult ;
34238   int result;
34239
34240   {
34241     try {
34242       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34243     } CALL_CATCH_EXCEPTION(0);
34244   }
34245
34246   jresult = (int)result;
34247   return jresult;
34248 }
34249
34250
34251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34252   int jresult ;
34253   int result;
34254
34255   {
34256     try {
34257       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34258     } CALL_CATCH_EXCEPTION(0);
34259   }
34260
34261   jresult = (int)result;
34262   return jresult;
34263 }
34264
34265
34266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34267   int jresult ;
34268   int result;
34269
34270   {
34271     try {
34272       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34273     } CALL_CATCH_EXCEPTION(0);
34274   }
34275
34276   jresult = (int)result;
34277   return jresult;
34278 }
34279
34280
34281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34282   int jresult ;
34283   int result;
34284
34285   {
34286     try {
34287       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34288     } CALL_CATCH_EXCEPTION(0);
34289   }
34290
34291   jresult = (int)result;
34292   return jresult;
34293 }
34294
34295
34296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34297   int jresult ;
34298   int result;
34299
34300   {
34301     try {
34302       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34303     } CALL_CATCH_EXCEPTION(0);
34304   }
34305
34306   jresult = (int)result;
34307   return jresult;
34308 }
34309
34310
34311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34312   int jresult ;
34313   int result;
34314
34315   {
34316     try {
34317       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34318     } CALL_CATCH_EXCEPTION(0);
34319   }
34320
34321   jresult = (int)result;
34322   return jresult;
34323 }
34324
34325
34326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34327   int jresult ;
34328   int result;
34329
34330   {
34331     try {
34332       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34333     } CALL_CATCH_EXCEPTION(0);
34334   }
34335
34336   jresult = (int)result;
34337   return jresult;
34338 }
34339
34340
34341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34342   int jresult ;
34343   int result;
34344
34345   {
34346     try {
34347       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34348     } CALL_CATCH_EXCEPTION(0);
34349   }
34350
34351   jresult = (int)result;
34352   return jresult;
34353 }
34354
34355
34356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34357   int jresult ;
34358   int result;
34359
34360   {
34361     try {
34362       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34363     } CALL_CATCH_EXCEPTION(0);
34364   }
34365
34366   jresult = (int)result;
34367   return jresult;
34368 }
34369
34370
34371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34372   int jresult ;
34373   int result;
34374
34375   {
34376     try {
34377       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34378     } CALL_CATCH_EXCEPTION(0);
34379   }
34380
34381   jresult = (int)result;
34382   return jresult;
34383 }
34384
34385
34386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34387   int jresult ;
34388   int result;
34389
34390   {
34391     try {
34392       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34393     } CALL_CATCH_EXCEPTION(0);
34394   }
34395
34396   jresult = (int)result;
34397   return jresult;
34398 }
34399
34400
34401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34402   int jresult ;
34403   int result;
34404
34405   {
34406     try {
34407       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34408     } CALL_CATCH_EXCEPTION(0);
34409   }
34410
34411   jresult = (int)result;
34412   return jresult;
34413 }
34414
34415
34416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34417   int jresult ;
34418   int result;
34419
34420   {
34421     try {
34422       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34423     } CALL_CATCH_EXCEPTION(0);
34424   }
34425
34426   jresult = (int)result;
34427   return jresult;
34428 }
34429
34430
34431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34432   int jresult ;
34433   int result;
34434
34435   {
34436     try {
34437       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34438     } CALL_CATCH_EXCEPTION(0);
34439   }
34440
34441   jresult = (int)result;
34442   return jresult;
34443 }
34444
34445
34446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34447   int jresult ;
34448   int result;
34449
34450   {
34451     try {
34452       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34453     } CALL_CATCH_EXCEPTION(0);
34454   }
34455
34456   jresult = (int)result;
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34462   int jresult ;
34463   int result;
34464
34465   {
34466     try {
34467       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34468     } CALL_CATCH_EXCEPTION(0);
34469   }
34470
34471   jresult = (int)result;
34472   return jresult;
34473 }
34474
34475
34476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34477   int jresult ;
34478   int result;
34479
34480   {
34481     try {
34482       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34483     } CALL_CATCH_EXCEPTION(0);
34484   }
34485
34486   jresult = (int)result;
34487   return jresult;
34488 }
34489
34490
34491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34492   int jresult ;
34493   int result;
34494
34495   {
34496     try {
34497       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34498     } CALL_CATCH_EXCEPTION(0);
34499   }
34500
34501   jresult = (int)result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34507   int jresult ;
34508   int result;
34509
34510   {
34511     try {
34512       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34513     } CALL_CATCH_EXCEPTION(0);
34514   }
34515
34516   jresult = (int)result;
34517   return jresult;
34518 }
34519
34520
34521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34522   int jresult ;
34523   int result;
34524
34525   {
34526     try {
34527       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34528     } CALL_CATCH_EXCEPTION(0);
34529   }
34530
34531   jresult = (int)result;
34532   return jresult;
34533 }
34534
34535
34536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34537   int jresult ;
34538   int result;
34539
34540   {
34541     try {
34542       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34543     } CALL_CATCH_EXCEPTION(0);
34544   }
34545
34546   jresult = (int)result;
34547   return jresult;
34548 }
34549
34550
34551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34552   int jresult ;
34553   int result;
34554
34555   {
34556     try {
34557       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34558     } CALL_CATCH_EXCEPTION(0);
34559   }
34560
34561   jresult = (int)result;
34562   return jresult;
34563 }
34564
34565
34566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34567   int jresult ;
34568   int result;
34569
34570   {
34571     try {
34572       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34573     } CALL_CATCH_EXCEPTION(0);
34574   }
34575
34576   jresult = (int)result;
34577   return jresult;
34578 }
34579
34580
34581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34582   int jresult ;
34583   int result;
34584
34585   {
34586     try {
34587       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34588     } CALL_CATCH_EXCEPTION(0);
34589   }
34590
34591   jresult = (int)result;
34592   return jresult;
34593 }
34594
34595
34596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34597   int jresult ;
34598   int result;
34599
34600   {
34601     try {
34602       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34603     } CALL_CATCH_EXCEPTION(0);
34604   }
34605
34606   jresult = (int)result;
34607   return jresult;
34608 }
34609
34610
34611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34612   int jresult ;
34613   int result;
34614
34615   {
34616     try {
34617       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34618     } CALL_CATCH_EXCEPTION(0);
34619   }
34620
34621   jresult = (int)result;
34622   return jresult;
34623 }
34624
34625
34626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34627   void * jresult ;
34628   Dali::Toolkit::Builder *result = 0 ;
34629
34630   {
34631     try {
34632       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34633     } CALL_CATCH_EXCEPTION(0);
34634   }
34635
34636   jresult = (void *)result;
34637   return jresult;
34638 }
34639
34640
34641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34642   void * jresult ;
34643   Dali::Toolkit::Builder result;
34644
34645   {
34646     try {
34647       result = Dali::Toolkit::Builder::New();
34648     } CALL_CATCH_EXCEPTION(0);
34649   }
34650
34651   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34652   return jresult;
34653 }
34654
34655
34656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34657   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34658
34659   arg1 = (Dali::Toolkit::Builder *)jarg1;
34660   {
34661     try {
34662       delete arg1;
34663     } CALL_CATCH_EXCEPTION();
34664   }
34665
34666 }
34667
34668
34669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34670   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34671   std::string *arg2 = 0 ;
34672   Dali::Toolkit::Builder::UIFormat arg3 ;
34673
34674   arg1 = (Dali::Toolkit::Builder *)jarg1;
34675   if (!jarg2) {
34676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34677     return ;
34678   }
34679   std::string arg2_str(jarg2);
34680   arg2 = &arg2_str;
34681   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34682   {
34683     try {
34684       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34685     } CALL_CATCH_EXCEPTION();
34686   }
34687
34688
34689   //argout typemap for const std::string&
34690
34691 }
34692
34693
34694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34695   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34696   std::string *arg2 = 0 ;
34697
34698   arg1 = (Dali::Toolkit::Builder *)jarg1;
34699   if (!jarg2) {
34700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34701     return ;
34702   }
34703   std::string arg2_str(jarg2);
34704   arg2 = &arg2_str;
34705   {
34706     try {
34707       (arg1)->LoadFromString((std::string const &)*arg2);
34708     } CALL_CATCH_EXCEPTION();
34709   }
34710
34711
34712   //argout typemap for const std::string&
34713
34714 }
34715
34716
34717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34718   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34719   Dali::Property::Map *arg2 = 0 ;
34720
34721   arg1 = (Dali::Toolkit::Builder *)jarg1;
34722   arg2 = (Dali::Property::Map *)jarg2;
34723   if (!arg2) {
34724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34725     return ;
34726   }
34727   {
34728     try {
34729       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34730     } CALL_CATCH_EXCEPTION();
34731   }
34732
34733 }
34734
34735
34736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34737   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34738   std::string *arg2 = 0 ;
34739   Dali::Property::Value *arg3 = 0 ;
34740
34741   arg1 = (Dali::Toolkit::Builder *)jarg1;
34742   if (!jarg2) {
34743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34744     return ;
34745   }
34746   std::string arg2_str(jarg2);
34747   arg2 = &arg2_str;
34748   arg3 = (Dali::Property::Value *)jarg3;
34749   if (!arg3) {
34750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34751     return ;
34752   }
34753   {
34754     try {
34755       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34756     } CALL_CATCH_EXCEPTION();
34757   }
34758
34759
34760   //argout typemap for const std::string&
34761
34762 }
34763
34764
34765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34766   void * jresult ;
34767   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34768   Dali::Property::Map *result = 0 ;
34769
34770   arg1 = (Dali::Toolkit::Builder *)jarg1;
34771   {
34772     try {
34773       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34774     } CALL_CATCH_EXCEPTION(0);
34775   }
34776
34777   jresult = (void *)result;
34778   return jresult;
34779 }
34780
34781
34782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34783   void * jresult ;
34784   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34785   std::string *arg2 = 0 ;
34786   Dali::Property::Value *result = 0 ;
34787
34788   arg1 = (Dali::Toolkit::Builder *)jarg1;
34789   if (!jarg2) {
34790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34791     return 0;
34792   }
34793   std::string arg2_str(jarg2);
34794   arg2 = &arg2_str;
34795   {
34796     try {
34797       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34798     } CALL_CATCH_EXCEPTION(0);
34799   }
34800
34801   jresult = (void *)result;
34802
34803   //argout typemap for const std::string&
34804
34805   return jresult;
34806 }
34807
34808
34809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34810   void * jresult ;
34811   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34812   std::string *arg2 = 0 ;
34813   Dali::Animation result;
34814
34815   arg1 = (Dali::Toolkit::Builder *)jarg1;
34816   if (!jarg2) {
34817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34818     return 0;
34819   }
34820   std::string arg2_str(jarg2);
34821   arg2 = &arg2_str;
34822   {
34823     try {
34824       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34825     } CALL_CATCH_EXCEPTION(0);
34826   }
34827
34828   jresult = new Dali::Animation((const Dali::Animation &)result);
34829
34830   //argout typemap for const std::string&
34831
34832   return jresult;
34833 }
34834
34835
34836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34837   void * jresult ;
34838   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34839   std::string *arg2 = 0 ;
34840   Dali::Property::Map *arg3 = 0 ;
34841   Dali::Animation result;
34842
34843   arg1 = (Dali::Toolkit::Builder *)jarg1;
34844   if (!jarg2) {
34845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34846     return 0;
34847   }
34848   std::string arg2_str(jarg2);
34849   arg2 = &arg2_str;
34850   arg3 = (Dali::Property::Map *)jarg3;
34851   if (!arg3) {
34852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34853     return 0;
34854   }
34855   {
34856     try {
34857       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34858     } CALL_CATCH_EXCEPTION(0);
34859   }
34860
34861   jresult = new Dali::Animation((const Dali::Animation &)result);
34862
34863   //argout typemap for const std::string&
34864
34865   return jresult;
34866 }
34867
34868
34869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34870   void * jresult ;
34871   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34872   std::string *arg2 = 0 ;
34873   Dali::Actor arg3 ;
34874   Dali::Actor *argp3 ;
34875   Dali::Animation result;
34876
34877   arg1 = (Dali::Toolkit::Builder *)jarg1;
34878   if (!jarg2) {
34879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34880     return 0;
34881   }
34882   std::string arg2_str(jarg2);
34883   arg2 = &arg2_str;
34884   argp3 = (Dali::Actor *)jarg3;
34885   if (!argp3) {
34886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34887     return 0;
34888   }
34889   arg3 = *argp3;
34890   {
34891     try {
34892       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
34893     } CALL_CATCH_EXCEPTION(0);
34894   }
34895
34896   jresult = new Dali::Animation((const Dali::Animation &)result);
34897
34898   //argout typemap for const std::string&
34899
34900   return jresult;
34901 }
34902
34903
34904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
34905   void * jresult ;
34906   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34907   std::string *arg2 = 0 ;
34908   Dali::Property::Map *arg3 = 0 ;
34909   Dali::Actor arg4 ;
34910   Dali::Actor *argp4 ;
34911   Dali::Animation result;
34912
34913   arg1 = (Dali::Toolkit::Builder *)jarg1;
34914   if (!jarg2) {
34915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34916     return 0;
34917   }
34918   std::string arg2_str(jarg2);
34919   arg2 = &arg2_str;
34920   arg3 = (Dali::Property::Map *)jarg3;
34921   if (!arg3) {
34922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34923     return 0;
34924   }
34925   argp4 = (Dali::Actor *)jarg4;
34926   if (!argp4) {
34927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34928     return 0;
34929   }
34930   arg4 = *argp4;
34931   {
34932     try {
34933       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
34934     } CALL_CATCH_EXCEPTION(0);
34935   }
34936
34937   jresult = new Dali::Animation((const Dali::Animation &)result);
34938
34939   //argout typemap for const std::string&
34940
34941   return jresult;
34942 }
34943
34944
34945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
34946   void * jresult ;
34947   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34948   std::string *arg2 = 0 ;
34949   Dali::BaseHandle result;
34950
34951   arg1 = (Dali::Toolkit::Builder *)jarg1;
34952   if (!jarg2) {
34953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34954     return 0;
34955   }
34956   std::string arg2_str(jarg2);
34957   arg2 = &arg2_str;
34958   {
34959     try {
34960       result = (arg1)->Create((std::string const &)*arg2);
34961     } CALL_CATCH_EXCEPTION(0);
34962   }
34963
34964   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
34965
34966   //argout typemap for const std::string&
34967
34968   return jresult;
34969 }
34970
34971
34972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(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::Property::Map *arg3 = 0 ;
34977   Dali::BaseHandle result;
34978
34979   arg1 = (Dali::Toolkit::Builder *)jarg1;
34980   if (!jarg2) {
34981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34982     return 0;
34983   }
34984   std::string arg2_str(jarg2);
34985   arg2 = &arg2_str;
34986   arg3 = (Dali::Property::Map *)jarg3;
34987   if (!arg3) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34989     return 0;
34990   }
34991   {
34992     try {
34993       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34994     } CALL_CATCH_EXCEPTION(0);
34995   }
34996
34997   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
34998
34999   //argout typemap for const std::string&
35000
35001   return jresult;
35002 }
35003
35004
35005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35006   void * jresult ;
35007   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35008   std::string *arg2 = 0 ;
35009   Dali::BaseHandle result;
35010
35011   arg1 = (Dali::Toolkit::Builder *)jarg1;
35012   if (!jarg2) {
35013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35014     return 0;
35015   }
35016   std::string arg2_str(jarg2);
35017   arg2 = &arg2_str;
35018   {
35019     try {
35020       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35021     } CALL_CATCH_EXCEPTION(0);
35022   }
35023
35024   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35025
35026   //argout typemap for const std::string&
35027
35028   return jresult;
35029 }
35030
35031
35032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35033   unsigned int jresult ;
35034   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35035   std::string *arg2 = 0 ;
35036   Dali::Handle *arg3 = 0 ;
35037   bool result;
35038
35039   arg1 = (Dali::Toolkit::Builder *)jarg1;
35040   if (!jarg2) {
35041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35042     return 0;
35043   }
35044   std::string arg2_str(jarg2);
35045   arg2 = &arg2_str;
35046   arg3 = (Dali::Handle *)jarg3;
35047   if (!arg3) {
35048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35049     return 0;
35050   }
35051   {
35052     try {
35053       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35054     } CALL_CATCH_EXCEPTION(0);
35055   }
35056
35057   jresult = result;
35058
35059   //argout typemap for const std::string&
35060
35061   return jresult;
35062 }
35063
35064
35065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35066   unsigned int jresult ;
35067   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35068   Dali::Handle *arg2 = 0 ;
35069   std::string *arg3 = 0 ;
35070   bool result;
35071
35072   arg1 = (Dali::Toolkit::Builder *)jarg1;
35073   arg2 = (Dali::Handle *)jarg2;
35074   if (!arg2) {
35075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35076     return 0;
35077   }
35078   if (!jarg3) {
35079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35080     return 0;
35081   }
35082   std::string arg3_str(jarg3);
35083   arg3 = &arg3_str;
35084   {
35085     try {
35086       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35087     } CALL_CATCH_EXCEPTION(0);
35088   }
35089
35090   jresult = result;
35091
35092   //argout typemap for const std::string&
35093
35094   return jresult;
35095 }
35096
35097
35098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35099   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35100   Dali::Actor arg2 ;
35101   Dali::Actor *argp2 ;
35102
35103   arg1 = (Dali::Toolkit::Builder *)jarg1;
35104   argp2 = (Dali::Actor *)jarg2;
35105   if (!argp2) {
35106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35107     return ;
35108   }
35109   arg2 = *argp2;
35110   {
35111     try {
35112       (arg1)->AddActors(arg2);
35113     } CALL_CATCH_EXCEPTION();
35114   }
35115
35116 }
35117
35118
35119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35120   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35121   std::string *arg2 = 0 ;
35122   Dali::Actor arg3 ;
35123   Dali::Actor *argp3 ;
35124
35125   arg1 = (Dali::Toolkit::Builder *)jarg1;
35126   if (!jarg2) {
35127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35128     return ;
35129   }
35130   std::string arg2_str(jarg2);
35131   arg2 = &arg2_str;
35132   argp3 = (Dali::Actor *)jarg3;
35133   if (!argp3) {
35134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35135     return ;
35136   }
35137   arg3 = *argp3;
35138   {
35139     try {
35140       (arg1)->AddActors((std::string const &)*arg2,arg3);
35141     } CALL_CATCH_EXCEPTION();
35142   }
35143
35144
35145   //argout typemap for const std::string&
35146
35147 }
35148
35149
35150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35151   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35152   std::string *arg2 = 0 ;
35153
35154   arg1 = (Dali::Toolkit::Builder *)jarg1;
35155   if (!jarg2) {
35156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35157     return ;
35158   }
35159   std::string arg2_str(jarg2);
35160   arg2 = &arg2_str;
35161   {
35162     try {
35163       (arg1)->CreateRenderTask((std::string const &)*arg2);
35164     } CALL_CATCH_EXCEPTION();
35165   }
35166
35167
35168   //argout typemap for const std::string&
35169
35170 }
35171
35172
35173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35174   void * jresult ;
35175   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35176   std::string *arg2 = 0 ;
35177   Dali::Path result;
35178
35179   arg1 = (Dali::Toolkit::Builder *)jarg1;
35180   if (!jarg2) {
35181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35182     return 0;
35183   }
35184   std::string arg2_str(jarg2);
35185   arg2 = &arg2_str;
35186   {
35187     try {
35188       result = (arg1)->GetPath((std::string const &)*arg2);
35189     } CALL_CATCH_EXCEPTION(0);
35190   }
35191
35192   jresult = new Dali::Path((const Dali::Path &)result);
35193
35194   //argout typemap for const std::string&
35195
35196   return jresult;
35197 }
35198
35199
35200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35201   void * jresult ;
35202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35203   std::string *arg2 = 0 ;
35204   Dali::PathConstrainer result;
35205
35206   arg1 = (Dali::Toolkit::Builder *)jarg1;
35207   if (!jarg2) {
35208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35209     return 0;
35210   }
35211   std::string arg2_str(jarg2);
35212   arg2 = &arg2_str;
35213   {
35214     try {
35215       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35216     } CALL_CATCH_EXCEPTION(0);
35217   }
35218
35219   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35220
35221   //argout typemap for const std::string&
35222
35223   return jresult;
35224 }
35225
35226
35227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35228   void * jresult ;
35229   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35230   std::string *arg2 = 0 ;
35231   Dali::LinearConstrainer result;
35232
35233   arg1 = (Dali::Toolkit::Builder *)jarg1;
35234   if (!jarg2) {
35235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35236     return 0;
35237   }
35238   std::string arg2_str(jarg2);
35239   arg2 = &arg2_str;
35240   {
35241     try {
35242       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35243     } CALL_CATCH_EXCEPTION(0);
35244   }
35245
35246   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35247
35248   //argout typemap for const std::string&
35249
35250   return jresult;
35251 }
35252
35253
35254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35255   void * jresult ;
35256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35257   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35258
35259   arg1 = (Dali::Toolkit::Builder *)jarg1;
35260   {
35261     try {
35262       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35263     } CALL_CATCH_EXCEPTION(0);
35264   }
35265
35266   jresult = (void *)result;
35267   return jresult;
35268 }
35269
35270
35271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35272   void * jresult ;
35273   Dali::Toolkit::TransitionData *result = 0 ;
35274
35275   {
35276     try {
35277       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35278     } CALL_CATCH_EXCEPTION(0);
35279   }
35280
35281   jresult = (void *)result;
35282   return jresult;
35283 }
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35286   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35287
35288   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35289   {
35290     try {
35291       delete arg1;
35292     } CALL_CATCH_EXCEPTION();
35293   }
35294
35295 }
35296
35297
35298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35299   void * jresult ;
35300   Dali::Property::Map *arg1 = 0 ;
35301   Dali::Toolkit::TransitionData result;
35302
35303   arg1 = (Dali::Property::Map *)jarg1;
35304   if (!arg1) {
35305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35306     return 0;
35307   }
35308   {
35309     try {
35310       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35311     } CALL_CATCH_EXCEPTION(0);
35312   }
35313
35314   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35315   return jresult;
35316 }
35317
35318
35319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35320   void * jresult ;
35321   Dali::Property::Array *arg1 = 0 ;
35322   Dali::Toolkit::TransitionData result;
35323
35324   arg1 = (Dali::Property::Array *)jarg1;
35325   if (!arg1) {
35326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35327     return 0;
35328   }
35329   {
35330     try {
35331       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35332     } CALL_CATCH_EXCEPTION(0);
35333   }
35334
35335   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35336   return jresult;
35337 }
35338
35339
35340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35341   void * jresult ;
35342   Dali::BaseHandle arg1 ;
35343   Dali::BaseHandle *argp1 ;
35344   Dali::Toolkit::TransitionData result;
35345
35346   argp1 = (Dali::BaseHandle *)jarg1;
35347   if (!argp1) {
35348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35349     return 0;
35350   }
35351   arg1 = *argp1;
35352   {
35353     try {
35354       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35355     } CALL_CATCH_EXCEPTION(0);
35356   }
35357
35358   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35359   return jresult;
35360 }
35361
35362
35363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35364   void * jresult ;
35365   Dali::Toolkit::TransitionData *arg1 = 0 ;
35366   Dali::Toolkit::TransitionData *result = 0 ;
35367
35368   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35369   if (!arg1) {
35370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35371     return 0;
35372   }
35373   {
35374     try {
35375       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35376     } CALL_CATCH_EXCEPTION(0);
35377   }
35378
35379   jresult = (void *)result;
35380   return jresult;
35381 }
35382
35383
35384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35385   void * jresult ;
35386   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35387   Dali::Toolkit::TransitionData *arg2 = 0 ;
35388   Dali::Toolkit::TransitionData *result = 0 ;
35389
35390   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35391   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35392   if (!arg2) {
35393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35394     return 0;
35395   }
35396   {
35397     try {
35398       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35399     } CALL_CATCH_EXCEPTION(0);
35400   }
35401
35402   jresult = (void *)result;
35403   return jresult;
35404 }
35405
35406
35407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35408   unsigned long jresult ;
35409   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35410   size_t result;
35411
35412   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35413   {
35414     try {
35415       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35416     } CALL_CATCH_EXCEPTION(0);
35417   }
35418
35419   jresult = (unsigned long)result;
35420   return jresult;
35421 }
35422
35423
35424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35425   void * jresult ;
35426   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35427   size_t arg2 ;
35428   Dali::Property::Map result;
35429
35430   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35431   arg2 = (size_t)jarg2;
35432   {
35433     try {
35434       result = (arg1)->GetAnimatorAt(arg2);
35435     } CALL_CATCH_EXCEPTION(0);
35436   }
35437
35438   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35439   return jresult;
35440 }
35441
35442
35443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35444   int jresult ;
35445   int result;
35446
35447   {
35448     try {
35449       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35450     } CALL_CATCH_EXCEPTION(0);
35451   }
35452
35453   jresult = (int)result;
35454   return jresult;
35455 }
35456
35457
35458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35459   int jresult ;
35460   int result;
35461
35462   {
35463     try {
35464       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35465     } CALL_CATCH_EXCEPTION(0);
35466   }
35467
35468   jresult = (int)result;
35469   return jresult;
35470 }
35471
35472
35473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35474   int jresult ;
35475   int result;
35476
35477   {
35478     try {
35479       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35480     } CALL_CATCH_EXCEPTION(0);
35481   }
35482
35483   jresult = (int)result;
35484   return jresult;
35485 }
35486
35487
35488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35489   int jresult ;
35490   int result;
35491
35492   {
35493     try {
35494       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35495     } CALL_CATCH_EXCEPTION(0);
35496   }
35497
35498   jresult = (int)result;
35499   return jresult;
35500 }
35501
35502
35503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35504   int jresult ;
35505   int result;
35506
35507   {
35508     try {
35509       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35510     } CALL_CATCH_EXCEPTION(0);
35511   }
35512
35513   jresult = (int)result;
35514   return jresult;
35515 }
35516
35517
35518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35519   int jresult ;
35520   int result;
35521
35522   {
35523     try {
35524       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35525     } CALL_CATCH_EXCEPTION(0);
35526   }
35527
35528   jresult = (int)result;
35529   return jresult;
35530 }
35531
35532
35533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35534   int jresult ;
35535   int result;
35536
35537   {
35538     try {
35539       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35540     } CALL_CATCH_EXCEPTION(0);
35541   }
35542
35543   jresult = (int)result;
35544   return jresult;
35545 }
35546
35547
35548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35549   int jresult ;
35550   int result;
35551
35552   {
35553     try {
35554       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35555     } CALL_CATCH_EXCEPTION(0);
35556   }
35557
35558   jresult = (int)result;
35559   return jresult;
35560 }
35561
35562
35563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35564   int jresult ;
35565   int result;
35566
35567   {
35568     try {
35569       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35570     } CALL_CATCH_EXCEPTION(0);
35571   }
35572
35573   jresult = (int)result;
35574   return jresult;
35575 }
35576
35577
35578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35579   int jresult ;
35580   int result;
35581
35582   {
35583     try {
35584       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35585     } CALL_CATCH_EXCEPTION(0);
35586   }
35587
35588   jresult = (int)result;
35589   return jresult;
35590 }
35591
35592
35593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35594   int jresult ;
35595   int result;
35596
35597   {
35598     try {
35599       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35600     } CALL_CATCH_EXCEPTION(0);
35601   }
35602
35603   jresult = (int)result;
35604   return jresult;
35605 }
35606
35607
35608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35609   int jresult ;
35610   int result;
35611
35612   {
35613     try {
35614       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35615     } CALL_CATCH_EXCEPTION(0);
35616   }
35617
35618   jresult = (int)result;
35619   return jresult;
35620 }
35621
35622
35623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35624   int jresult ;
35625   int result;
35626
35627   {
35628     try {
35629       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35630     } CALL_CATCH_EXCEPTION(0);
35631   }
35632
35633   jresult = (int)result;
35634   return jresult;
35635 }
35636
35637
35638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35639   int jresult ;
35640   int result;
35641
35642   {
35643     try {
35644       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35645     } CALL_CATCH_EXCEPTION(0);
35646   }
35647
35648   jresult = (int)result;
35649   return jresult;
35650 }
35651
35652
35653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35654   void * jresult ;
35655   Dali::Toolkit::Control result;
35656
35657   {
35658     try {
35659       result = Dali::Toolkit::Internal::Control::New();
35660     } CALL_CATCH_EXCEPTION(0);
35661   }
35662
35663   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35664   return jresult;
35665 }
35666
35667
35668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35670   std::string *arg2 = 0 ;
35671
35672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35673   if (!jarg2) {
35674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35675     return ;
35676   }
35677   std::string arg2_str(jarg2);
35678   arg2 = &arg2_str;
35679   {
35680     try {
35681       (arg1)->SetStyleName((std::string const &)*arg2);
35682     } CALL_CATCH_EXCEPTION();
35683   }
35684
35685
35686   //argout typemap for const std::string&
35687
35688 }
35689
35690
35691 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35692   char * jresult ;
35693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35694   std::string *result = 0 ;
35695
35696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35697   {
35698     try {
35699       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35700     } CALL_CATCH_EXCEPTION(0);
35701   }
35702
35703   jresult = SWIG_csharp_string_callback(result->c_str());
35704   return jresult;
35705 }
35706
35707
35708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35710   Dali::Vector4 *arg2 = 0 ;
35711
35712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35713   arg2 = (Dali::Vector4 *)jarg2;
35714   if (!arg2) {
35715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35716     return ;
35717   }
35718   {
35719     try {
35720       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35721     } CALL_CATCH_EXCEPTION();
35722   }
35723
35724 }
35725
35726
35727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35728   void * jresult ;
35729   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35730   Dali::Vector4 result;
35731
35732   arg1 = (Dali::Handle *)jarg1;
35733   {
35734     try {
35735       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35736       if (resultMap)
35737       {
35738         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35739         if(type && type->Get<int>() == Visual::COLOR )
35740         {
35741           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35742           if (value)
35743           {
35744             result = value->Get<Vector4>();
35745           }
35746         }
35747       }
35748     } CALL_CATCH_EXCEPTION(0);
35749   }
35750
35751   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35752   return jresult;
35753 }
35754
35755
35756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35758   Dali::Property::Map *arg2 = 0 ;
35759
35760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35761   arg2 = (Dali::Property::Map *)jarg2;
35762   if (!arg2) {
35763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35764     return ;
35765   }
35766   {
35767     try {
35768       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35769     } CALL_CATCH_EXCEPTION();
35770   }
35771
35772 }
35773
35774
35775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35777
35778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35779   {
35780     try {
35781       (arg1)->ClearBackground();
35782     } CALL_CATCH_EXCEPTION();
35783   }
35784
35785 }
35786
35787
35788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35790   Dali::GestureType::Value arg2 ;
35791
35792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35793   arg2 = (Dali::GestureType::Value)jarg2;
35794   {
35795     try {
35796       (arg1)->EnableGestureDetection(arg2);
35797     } CALL_CATCH_EXCEPTION();
35798   }
35799
35800 }
35801
35802
35803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35805   Dali::GestureType::Value arg2 ;
35806
35807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35808   arg2 = (Dali::GestureType::Value)jarg2;
35809   {
35810     try {
35811       (arg1)->DisableGestureDetection(arg2);
35812     } CALL_CATCH_EXCEPTION();
35813   }
35814
35815 }
35816
35817
35818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35819   void * jresult ;
35820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35821   Dali::PinchGestureDetector result;
35822
35823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35824   {
35825     try {
35826       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35827     } CALL_CATCH_EXCEPTION(0);
35828   }
35829
35830   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35831   return jresult;
35832 }
35833
35834
35835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35836   void * jresult ;
35837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35838   Dali::PanGestureDetector result;
35839
35840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35841   {
35842     try {
35843       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35844     } CALL_CATCH_EXCEPTION(0);
35845   }
35846
35847   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35848   return jresult;
35849 }
35850
35851
35852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35853   void * jresult ;
35854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35855   Dali::TapGestureDetector result;
35856
35857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35858   {
35859     try {
35860       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35861     } CALL_CATCH_EXCEPTION(0);
35862   }
35863
35864   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35865   return jresult;
35866 }
35867
35868
35869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35870   void * jresult ;
35871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35872   Dali::LongPressGestureDetector result;
35873
35874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35875   {
35876     try {
35877       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35878     } CALL_CATCH_EXCEPTION(0);
35879   }
35880
35881   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35882   return jresult;
35883 }
35884
35885
35886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
35887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35888   bool arg2 ;
35889
35890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35891   arg2 = jarg2 ? true : false;
35892   {
35893     try {
35894       (arg1)->SetKeyboardNavigationSupport(arg2);
35895     } CALL_CATCH_EXCEPTION();
35896   }
35897
35898 }
35899
35900
35901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
35902   unsigned int jresult ;
35903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35904   bool result;
35905
35906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35907   {
35908     try {
35909       result = (bool)(arg1)->IsKeyboardNavigationSupported();
35910     } CALL_CATCH_EXCEPTION(0);
35911   }
35912
35913   jresult = result;
35914   return jresult;
35915 }
35916
35917
35918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
35919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35920
35921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35922   {
35923     try {
35924       (arg1)->SetKeyInputFocus();
35925     } CALL_CATCH_EXCEPTION();
35926   }
35927
35928 }
35929
35930
35931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
35932   unsigned int jresult ;
35933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35934   bool result;
35935
35936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35937   {
35938     try {
35939       result = (bool)(arg1)->HasKeyInputFocus();
35940     } CALL_CATCH_EXCEPTION(0);
35941   }
35942
35943   jresult = result;
35944   return jresult;
35945 }
35946
35947
35948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
35949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35950
35951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35952   {
35953     try {
35954       (arg1)->ClearKeyInputFocus();
35955     } CALL_CATCH_EXCEPTION();
35956   }
35957
35958 }
35959
35960
35961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
35962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35963   bool arg2 ;
35964
35965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35966   arg2 = jarg2 ? true : false;
35967   {
35968     try {
35969       (arg1)->SetAsKeyboardFocusGroup(arg2);
35970     } CALL_CATCH_EXCEPTION();
35971   }
35972
35973 }
35974
35975
35976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
35977   unsigned int jresult ;
35978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35979   bool result;
35980
35981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35982   {
35983     try {
35984       result = (bool)(arg1)->IsKeyboardFocusGroup();
35985     } CALL_CATCH_EXCEPTION(0);
35986   }
35987
35988   jresult = result;
35989   return jresult;
35990 }
35991
35992
35993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
35994   void * jresult ;
35995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35996   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
35997
35998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35999   {
36000     try {
36001       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36002     } CALL_CATCH_EXCEPTION(0);
36003   }
36004
36005   jresult = (void *)result;
36006   return jresult;
36007 }
36008
36009
36010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36011   void * jresult ;
36012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36013   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36014
36015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36016   {
36017     try {
36018       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36019     } CALL_CATCH_EXCEPTION(0);
36020   }
36021
36022   jresult = (void *)result;
36023   return jresult;
36024 }
36025
36026
36027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
36028   void * jresult ;
36029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36030   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36031
36032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36033   {
36034     try {
36035       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36036     } CALL_CATCH_EXCEPTION(0);
36037   }
36038
36039   jresult = (void *)result;
36040   return jresult;
36041 }
36042
36043
36044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36046   int arg2 ;
36047   SwigDirector_ViewImpl *darg = 0;
36048
36049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36050   arg2 = (int)jarg2;
36051   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36052   if(!darg) {
36053     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36054     return;
36055   }
36056   {
36057     try {
36058       if(darg) {
36059         (darg)->OnSceneConnection(arg2);
36060       }
36061     } CALL_CATCH_EXCEPTION();
36062   }
36063
36064 }
36065
36066
36067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36069   int arg2 ;
36070   SwigDirector_ViewImpl *darg = 0;
36071
36072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36073   arg2 = (int)jarg2;
36074   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36075   if(!darg) {
36076     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36077     return;
36078   }
36079   {
36080     try {
36081       if(darg) {
36082         (darg)->OnSceneConnectionSwigPublic(arg2);
36083       }
36084     } CALL_CATCH_EXCEPTION();
36085   }
36086
36087 }
36088
36089
36090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36092   SwigDirector_ViewImpl *darg = 0;
36093
36094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36095   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36096   if(!darg) {
36097     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36098     return;
36099   }
36100   {
36101     try {
36102       if(darg) {
36103         (darg)->OnSceneDisconnection();
36104       }
36105     } CALL_CATCH_EXCEPTION();
36106   }
36107
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36113   SwigDirector_ViewImpl *darg = 0;
36114
36115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36117   if(!darg) {
36118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36119     return;
36120   }
36121   {
36122     try {
36123       if(darg) {
36124         (darg)->OnSceneDisconnectionSwigPublic();
36125       }
36126     } CALL_CATCH_EXCEPTION();
36127   }
36128
36129 }
36130
36131
36132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
36133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36134   Dali::Actor *arg2 = 0 ;
36135   SwigDirector_ViewImpl *darg = 0;
36136
36137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36138   arg2 = (Dali::Actor *)jarg2;
36139   if (!arg2) {
36140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36141     return ;
36142   }
36143   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36144   if(!darg) {
36145     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36146     return;
36147   }
36148   {
36149     try {
36150       if(darg) {
36151         (darg)->OnChildAdd(*arg2);
36152       }
36153     } CALL_CATCH_EXCEPTION();
36154   }
36155
36156 }
36157
36158
36159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36161   Dali::Actor *arg2 = 0 ;
36162   SwigDirector_ViewImpl *darg = 0;
36163
36164   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36165   arg2 = (Dali::Actor *)jarg2;
36166   if (!arg2) {
36167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36168     return ;
36169   }
36170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36171   if(!darg) {
36172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36173     return;
36174   }
36175   {
36176     try {
36177       if(darg) {
36178           (darg)->OnChildAddSwigPublic(*arg2);
36179       }
36180     } CALL_CATCH_EXCEPTION();
36181   }
36182
36183 }
36184
36185
36186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36187   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36188   Dali::Actor *arg2 = 0 ;
36189   SwigDirector_ViewImpl *darg = 0;
36190
36191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36192   arg2 = (Dali::Actor *)jarg2;
36193   if (!arg2) {
36194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36195     return ;
36196   }
36197   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36198   if(!darg) {
36199     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36200     return;
36201   }
36202   {
36203     try {
36204       if(darg) {
36205         (darg)->OnChildRemove(*arg2);
36206       }
36207     } CALL_CATCH_EXCEPTION();
36208   }
36209
36210 }
36211
36212
36213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36215   Dali::Actor *arg2 = 0 ;
36216   SwigDirector_ViewImpl *darg = 0;
36217
36218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36219   arg2 = (Dali::Actor *)jarg2;
36220   if (!arg2) {
36221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36222     return ;
36223   }
36224   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36225   if(!darg) {
36226     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36227     return;
36228   }
36229   {
36230     try {
36231       if(darg) {
36232         (darg)->OnChildRemoveSwigPublic(*arg2);
36233       }
36234     } CALL_CATCH_EXCEPTION();
36235   }
36236
36237 }
36238
36239
36240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36242   Dali::Property::Index arg2 ;
36243   Dali::Property::Value arg3 ;
36244   Dali::Property::Value *argp3 ;
36245   SwigDirector_ViewImpl *darg = 0;
36246
36247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36248   arg2 = (Dali::Property::Index)jarg2;
36249   argp3 = (Dali::Property::Value *)jarg3;
36250   if (!argp3) {
36251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36252     return ;
36253   }
36254   arg3 = *argp3;
36255   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36256   if (!darg) {
36257     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36258     return;
36259   }
36260   {
36261     try {
36262       (darg)->OnPropertySet(arg2,arg3);
36263     } CALL_CATCH_EXCEPTION();
36264   }
36265
36266 }
36267
36268
36269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36271   Dali::Vector3 *arg2 = 0 ;
36272   SwigDirector_ViewImpl *darg = 0;
36273
36274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36275   arg2 = (Dali::Vector3 *)jarg2;
36276   if (!arg2) {
36277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36278     return ;
36279   }
36280   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36281   if (!darg) {
36282     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36283     return;
36284   }
36285   {
36286     try {
36287       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36288     } CALL_CATCH_EXCEPTION();
36289   }
36290
36291 }
36292
36293
36294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36295   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36296   Dali::Vector3 *arg2 = 0 ;
36297   SwigDirector_ViewImpl *darg = 0;
36298
36299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36300   arg2 = (Dali::Vector3 *)jarg2;
36301   if (!arg2) {
36302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36303     return ;
36304   }
36305   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36306   if (!darg) {
36307     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36308     return;
36309   }
36310   {
36311     try {
36312       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36313     } CALL_CATCH_EXCEPTION();
36314   }
36315
36316 }
36317
36318
36319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36321   Dali::Animation *arg2 = 0 ;
36322   Dali::Vector3 *arg3 = 0 ;
36323   SwigDirector_ViewImpl *darg = 0;
36324
36325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36326   arg2 = (Dali::Animation *)jarg2;
36327   if (!arg2) {
36328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36329     return ;
36330   }
36331   arg3 = (Dali::Vector3 *)jarg3;
36332   if (!arg3) {
36333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36334     return ;
36335   }
36336   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36337   if (!darg) {
36338     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36339     return;
36340   }
36341   {
36342     try {
36343       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36344     } CALL_CATCH_EXCEPTION();
36345   }
36346
36347 }
36348
36349
36350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36352   Dali::Animation *arg2 = 0 ;
36353   Dali::Vector3 *arg3 = 0 ;
36354   SwigDirector_ViewImpl *darg = 0;
36355
36356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36357   arg2 = (Dali::Animation *)jarg2;
36358   if (!arg2) {
36359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36360     return ;
36361   }
36362   arg3 = (Dali::Vector3 *)jarg3;
36363   if (!arg3) {
36364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36365     return ;
36366   }
36367   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36368   if (!darg) {
36369     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36370     return;
36371   }
36372   {
36373     try {
36374       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36375     } CALL_CATCH_EXCEPTION();
36376   }
36377 }
36378
36379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36380   unsigned int jresult ;
36381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36382   Dali::KeyEvent *arg2 = 0 ;
36383   SwigDirector_ViewImpl *darg = 0;
36384   bool result;
36385
36386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36387   arg2 = (Dali::KeyEvent *)jarg2;
36388   if (!arg2) {
36389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36390     return 0;
36391   }
36392   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36393   if (!darg) {
36394     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36395     return 0;
36396   }
36397   {
36398     try {
36399       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36400     } CALL_CATCH_EXCEPTION(0);
36401   }
36402
36403   jresult = result;
36404   return jresult;
36405 }
36406
36407
36408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36409   unsigned int jresult ;
36410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36411   Dali::KeyEvent *arg2 = 0 ;
36412   SwigDirector_ViewImpl *darg = 0;
36413   bool result;
36414
36415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36416   arg2 = (Dali::KeyEvent *)jarg2;
36417   if (!arg2) {
36418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36419     return 0;
36420   }
36421   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36422   if (!darg) {
36423     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36424     return 0;
36425   }
36426   {
36427     try {
36428       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36429     } CALL_CATCH_EXCEPTION(0);
36430   }
36431
36432   jresult = result;
36433   return jresult;
36434 }
36435
36436
36437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36439   Dali::Vector2 *arg2 = 0 ;
36440   Dali::RelayoutContainer *arg3 = 0 ;
36441   SwigDirector_ViewImpl *darg = 0;
36442
36443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36444   arg2 = (Dali::Vector2 *)jarg2;
36445   if (!arg2) {
36446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36447     return ;
36448   }
36449   arg3 = (Dali::RelayoutContainer *)jarg3;
36450   if (!arg3) {
36451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36452     return ;
36453   }
36454   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36455   if (!darg) {
36456     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36457     return;
36458   }
36459   {
36460     try {
36461       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36462     } CALL_CATCH_EXCEPTION();
36463   }
36464
36465 }
36466
36467
36468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36470   Dali::Vector2 *arg2 = 0 ;
36471   Dali::RelayoutContainer *arg3 = 0 ;
36472   SwigDirector_ViewImpl *darg = 0;
36473
36474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36475   arg2 = (Dali::Vector2 *)jarg2;
36476   if (!arg2) {
36477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36478     return ;
36479   }
36480   arg3 = (Dali::RelayoutContainer *)jarg3;
36481   if (!arg3) {
36482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36483     return ;
36484   }
36485   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36486   if (!darg) {
36487     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36488     return;
36489   }
36490   {
36491     try {
36492       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36493     } CALL_CATCH_EXCEPTION();
36494   }
36495
36496 }
36497
36498
36499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36501   Dali::ResizePolicy::Type arg2 ;
36502   Dali::Dimension::Type arg3 ;
36503   SwigDirector_ViewImpl *darg = 0;
36504
36505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36506   arg2 = (Dali::ResizePolicy::Type)jarg2;
36507   arg3 = (Dali::Dimension::Type)jarg3;
36508   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36509   if (!darg) {
36510     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36511     return;
36512   }
36513   {
36514     try {
36515       (darg)->OnSetResizePolicy(arg2,arg3);
36516     } CALL_CATCH_EXCEPTION();
36517   }
36518
36519 }
36520
36521
36522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36523   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36524   Dali::ResizePolicy::Type arg2 ;
36525   Dali::Dimension::Type arg3 ;
36526   SwigDirector_ViewImpl *darg = 0;
36527
36528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36529   arg2 = (Dali::ResizePolicy::Type)jarg2;
36530   arg3 = (Dali::Dimension::Type)jarg3;
36531   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36532   if (!darg) {
36533     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36534     return;
36535   }
36536   {
36537     try {
36538       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36539     } CALL_CATCH_EXCEPTION();
36540   }
36541
36542 }
36543
36544
36545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36546   void * jresult ;
36547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36548   SwigDirector_ViewImpl *darg = 0;
36549   Dali::Vector3 result;
36550
36551   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36552   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36553   if (!darg) {
36554     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36555     return 0;
36556   }
36557   {
36558     try {
36559       result = (darg)->GetNaturalSize();
36560     } CALL_CATCH_EXCEPTION(0);
36561   }
36562
36563   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36564   return jresult;
36565 }
36566
36567
36568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36569   void * jresult ;
36570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36571   SwigDirector_ViewImpl *darg = 0;
36572   Dali::Vector3 result;
36573
36574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36575   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36576   if (!darg) {
36577     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36578     return 0;
36579   }
36580   {
36581     try {
36582       result = (darg)->GetNaturalSizeSwigPublic();
36583     } CALL_CATCH_EXCEPTION(0);
36584   }
36585
36586   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36587   return jresult;
36588 }
36589
36590
36591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36592   float jresult ;
36593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36594   Dali::Actor *arg2 = 0 ;
36595   Dali::Dimension::Type arg3 ;
36596   SwigDirector_ViewImpl *darg = 0;
36597   float result;
36598
36599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36600   arg2 = (Dali::Actor *)jarg2;
36601   if (!arg2) {
36602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36603     return 0;
36604   }
36605   arg3 = (Dali::Dimension::Type)jarg3;
36606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36607   if (!darg) {
36608     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36609     return 0;
36610   }
36611   {
36612     try {
36613       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36614     } CALL_CATCH_EXCEPTION(0);
36615   }
36616
36617   jresult = result;
36618   return jresult;
36619 }
36620
36621
36622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36623   float jresult ;
36624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36625   Dali::Actor *arg2 = 0 ;
36626   Dali::Dimension::Type arg3 ;
36627   SwigDirector_ViewImpl *darg = 0;
36628   float result;
36629
36630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36631   arg2 = (Dali::Actor *)jarg2;
36632   if (!arg2) {
36633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36634     return 0;
36635   }
36636   arg3 = (Dali::Dimension::Type)jarg3;
36637   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36638   if (!darg) {
36639     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36640     return 0;
36641   }
36642   {
36643     try {
36644       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36645     } CALL_CATCH_EXCEPTION(0);
36646   }
36647
36648   jresult = result;
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36654   float jresult ;
36655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36656   float arg2 ;
36657   SwigDirector_ViewImpl *darg = 0;
36658   float result;
36659
36660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36661   arg2 = (float)jarg2;
36662   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36663   if (!darg) {
36664     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36665     return 0;
36666   }
36667   {
36668     try {
36669       result = (float)(darg)->GetHeightForWidth(arg2);
36670     } CALL_CATCH_EXCEPTION(0);
36671   }
36672
36673   jresult = result;
36674   return jresult;
36675 }
36676
36677
36678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36679   float jresult ;
36680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36681   float arg2 ;
36682   SwigDirector_ViewImpl *darg = 0;
36683   float result;
36684
36685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36686   arg2 = (float)jarg2;
36687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36688   if (!darg) {
36689     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36690     return 0;
36691   }
36692   {
36693     try {
36694       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36695     } CALL_CATCH_EXCEPTION(0);
36696   }
36697
36698   jresult = result;
36699   return jresult;
36700 }
36701
36702
36703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36704   float jresult ;
36705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36706   float arg2 ;
36707   SwigDirector_ViewImpl *darg = 0;
36708   float result;
36709
36710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36711   arg2 = (float)jarg2;
36712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36713   if (!darg) {
36714     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36715     return 0;
36716   }
36717   {
36718     try {
36719       result = (float)(darg)->GetWidthForHeight(arg2);
36720     } CALL_CATCH_EXCEPTION(0);
36721   }
36722
36723   jresult = result;
36724   return jresult;
36725 }
36726
36727
36728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36729   float jresult ;
36730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36731   float arg2 ;
36732   SwigDirector_ViewImpl *darg = 0;
36733   float result;
36734
36735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36736   arg2 = (float)jarg2;
36737   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36738   if (!darg) {
36739     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36740     return 0;
36741   }
36742   {
36743     try {
36744       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36745     } CALL_CATCH_EXCEPTION(0);
36746   }
36747
36748   jresult = result;
36749   return jresult;
36750 }
36751
36752
36753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36754   unsigned int jresult ;
36755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36756   Dali::Dimension::Type arg2 ;
36757   SwigDirector_ViewImpl *darg = 0;
36758   bool result;
36759
36760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36761   arg2 = (Dali::Dimension::Type)jarg2;
36762   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36763   if (!darg) {
36764     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36765     return 0;
36766   }
36767   {
36768     try {
36769       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
36770     } CALL_CATCH_EXCEPTION(0);
36771   }
36772
36773   jresult = result;
36774   return jresult;
36775 }
36776
36777
36778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
36779   unsigned int jresult ;
36780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36781   Dali::Dimension::Type arg2 ;
36782   SwigDirector_ViewImpl *darg = 0;
36783   bool result;
36784
36785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36786   arg2 = (Dali::Dimension::Type)jarg2;
36787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36788   if (!darg) {
36789     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36790     return 0;
36791   }
36792   {
36793     try {
36794       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
36795     } CALL_CATCH_EXCEPTION(0);
36796   }
36797
36798   jresult = result;
36799   return jresult;
36800 }
36801
36802
36803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
36804   unsigned int jresult ;
36805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36806   SwigDirector_ViewImpl *darg = 0;
36807   bool result;
36808
36809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36811   if (!darg) {
36812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36813     return 0;
36814   }
36815   {
36816     try {
36817       result = (bool)(darg)->RelayoutDependentOnChildren();
36818     } CALL_CATCH_EXCEPTION(0);
36819   }
36820
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
36827   unsigned int jresult ;
36828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36829   SwigDirector_ViewImpl *darg = 0;
36830   bool result;
36831
36832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36834   if (!darg) {
36835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36836     return 0;
36837   }
36838   {
36839     try {
36840       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
36841     } CALL_CATCH_EXCEPTION(0);
36842   }
36843
36844   jresult = result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
36850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36851   Dali::Dimension::Type arg2 ;
36852   SwigDirector_ViewImpl *darg = 0;
36853
36854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36855   arg2 = (Dali::Dimension::Type)jarg2;
36856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36857   if (!darg) {
36858     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36859     return;
36860   }
36861   {
36862     try {
36863       (darg)->OnCalculateRelayoutSize(arg2);
36864     } CALL_CATCH_EXCEPTION();
36865   }
36866
36867 }
36868
36869
36870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
36871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36872   Dali::Dimension::Type arg2 ;
36873   SwigDirector_ViewImpl *darg = 0;
36874
36875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36876   arg2 = (Dali::Dimension::Type)jarg2;
36877   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36878   if (!darg) {
36879     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36880     return;
36881   }
36882   {
36883     try {
36884       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
36885     } CALL_CATCH_EXCEPTION();
36886   }
36887
36888 }
36889
36890
36891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
36892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36893   float arg2 ;
36894   Dali::Dimension::Type arg3 ;
36895   SwigDirector_ViewImpl *darg = 0;
36896
36897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36898   arg2 = (float)jarg2;
36899   arg3 = (Dali::Dimension::Type)jarg3;
36900   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36901   if (!darg) {
36902     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36903     return;
36904   }
36905   {
36906     try {
36907       (darg)->OnLayoutNegotiated(arg2,arg3);
36908     } CALL_CATCH_EXCEPTION();
36909   }
36910
36911 }
36912
36913
36914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
36915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36916   float arg2 ;
36917   Dali::Dimension::Type arg3 ;
36918   SwigDirector_ViewImpl *darg = 0;
36919
36920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36921   arg2 = (float)jarg2;
36922   arg3 = (Dali::Dimension::Type)jarg3;
36923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36924   if (!darg) {
36925     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36926     return;
36927   }
36928   {
36929     try {
36930       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
36931     } CALL_CATCH_EXCEPTION();
36932   }
36933
36934 }
36935
36936
36937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
36938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36939
36940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36941   {
36942     try {
36943       (arg1)->OnInitialize();
36944     } CALL_CATCH_EXCEPTION();
36945   }
36946
36947 }
36948
36949
36950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
36951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36952
36953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36954   {
36955     try {
36956       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
36957     } CALL_CATCH_EXCEPTION();
36958   }
36959
36960 }
36961
36962
36963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
36964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36965   Dali::Toolkit::StyleManager arg2 ;
36966   Dali::StyleChange::Type arg3 ;
36967   Dali::Toolkit::StyleManager *argp2 ;
36968
36969   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36970   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
36971   if (!argp2) {
36972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
36973     return ;
36974   }
36975   arg2 = *argp2;
36976   arg3 = (Dali::StyleChange::Type)jarg3;
36977   {
36978     try {
36979       (arg1)->OnStyleChange(arg2,arg3);
36980     } CALL_CATCH_EXCEPTION();
36981   }
36982
36983 }
36984
36985
36986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36988   Dali::Toolkit::StyleManager arg2 ;
36989   Dali::StyleChange::Type arg3 ;
36990   Dali::Toolkit::StyleManager *argp2 ;
36991
36992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36993   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
36994   if (!argp2) {
36995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
36996     return ;
36997   }
36998   arg2 = *argp2;
36999   arg3 = (Dali::StyleChange::Type)jarg3;
37000   {
37001     try {
37002       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37003     } CALL_CATCH_EXCEPTION();
37004   }
37005
37006 }
37007
37008
37009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37010   unsigned int jresult ;
37011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37012   bool result;
37013
37014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37015   {
37016     try {
37017       result = (bool)(arg1)->OnAccessibilityActivated();
37018     } CALL_CATCH_EXCEPTION(0);
37019   }
37020
37021   jresult = result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
37027   unsigned int jresult ;
37028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37029   bool result;
37030
37031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37032   {
37033     try {
37034       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
37035     } CALL_CATCH_EXCEPTION(0);
37036   }
37037
37038   jresult = result;
37039   return jresult;
37040 }
37041
37042
37043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37044   unsigned int jresult ;
37045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37046   Dali::PanGesture arg2 ;
37047   Dali::PanGesture *argp2 ;
37048   bool result;
37049
37050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37051   argp2 = (Dali::PanGesture *)jarg2;
37052   if (!argp2) {
37053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37054     return 0;
37055   }
37056   arg2 = *argp2;
37057   {
37058     try {
37059       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37060     } CALL_CATCH_EXCEPTION(0);
37061   }
37062
37063   jresult = result;
37064   return jresult;
37065 }
37066
37067
37068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37069   unsigned int jresult ;
37070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37071   Dali::PanGesture arg2 ;
37072   Dali::PanGesture *argp2 ;
37073   bool result;
37074
37075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37076   argp2 = (Dali::PanGesture *)jarg2;
37077   if (!argp2) {
37078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37079     return 0;
37080   }
37081   arg2 = *argp2;
37082   {
37083     try {
37084       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37085     } CALL_CATCH_EXCEPTION(0);
37086   }
37087
37088   jresult = result;
37089   return jresult;
37090 }
37091
37092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37093   unsigned int jresult ;
37094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37095   bool arg2 ;
37096   bool result;
37097
37098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37099   arg2 = jarg2 ? true : false;
37100   {
37101     try {
37102       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37103     } CALL_CATCH_EXCEPTION(0);
37104   }
37105
37106   jresult = result;
37107   return jresult;
37108 }
37109
37110
37111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37112   unsigned int jresult ;
37113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37114   bool arg2 ;
37115   bool result;
37116
37117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37118   arg2 = jarg2 ? true : false;
37119   {
37120     try {
37121       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37122     } CALL_CATCH_EXCEPTION(0);
37123   }
37124
37125   jresult = result;
37126   return jresult;
37127 }
37128
37129
37130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37131   unsigned int jresult ;
37132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37133   bool result;
37134
37135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37136   {
37137     try {
37138       result = (bool)(arg1)->OnAccessibilityZoom();
37139     } CALL_CATCH_EXCEPTION(0);
37140   }
37141
37142   jresult = result;
37143   return jresult;
37144 }
37145
37146
37147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
37148   unsigned int jresult ;
37149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37150   bool result;
37151
37152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37153   {
37154     try {
37155       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37156     } CALL_CATCH_EXCEPTION(0);
37157   }
37158
37159   jresult = result;
37160   return jresult;
37161 }
37162
37163
37164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37166
37167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37168   {
37169     try {
37170       (arg1)->OnKeyInputFocusGained();
37171     } CALL_CATCH_EXCEPTION();
37172   }
37173
37174 }
37175
37176
37177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37179
37180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37181   {
37182     try {
37183       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37184     } CALL_CATCH_EXCEPTION();
37185   }
37186
37187 }
37188
37189
37190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37192
37193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37194   {
37195     try {
37196       (arg1)->OnKeyInputFocusLost();
37197     } CALL_CATCH_EXCEPTION();
37198   }
37199
37200 }
37201
37202
37203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37205
37206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37207   {
37208     try {
37209       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37210     } CALL_CATCH_EXCEPTION();
37211   }
37212
37213 }
37214
37215
37216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37217   void * jresult ;
37218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37219   Dali::Actor arg2 ;
37220   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37221   bool arg4 ;
37222   Dali::Actor *argp2 ;
37223   Dali::Actor result;
37224
37225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37226   argp2 = (Dali::Actor *)jarg2;
37227   if (!argp2) {
37228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37229     return 0;
37230   }
37231   arg2 = *argp2;
37232   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37233   arg4 = jarg4 ? true : false;
37234   {
37235     try {
37236       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37237     } CALL_CATCH_EXCEPTION(0);
37238   }
37239
37240   jresult = new Dali::Actor((const Dali::Actor &)result);
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37246   void * jresult ;
37247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37248   Dali::Actor arg2 ;
37249   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37250   bool arg4 ;
37251   Dali::Actor *argp2 ;
37252   Dali::Actor result;
37253
37254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37255   argp2 = (Dali::Actor *)jarg2;
37256   if (!argp2) {
37257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37258     return 0;
37259   }
37260   arg2 = *argp2;
37261   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37262   arg4 = jarg4 ? true : false;
37263   {
37264     try {
37265       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37266     } CALL_CATCH_EXCEPTION(0);
37267   }
37268
37269   jresult = new Dali::Actor((const Dali::Actor &)result);
37270   return jresult;
37271 }
37272
37273
37274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37276   Dali::Actor arg2 ;
37277   Dali::Actor *argp2 ;
37278
37279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37280   argp2 = (Dali::Actor *)jarg2;
37281   if (!argp2) {
37282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37283     return ;
37284   }
37285   arg2 = *argp2;
37286   {
37287     try {
37288       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37289     } CALL_CATCH_EXCEPTION();
37290   }
37291
37292 }
37293
37294
37295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37297   Dali::Actor arg2 ;
37298   Dali::Actor *argp2 ;
37299
37300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37301   argp2 = (Dali::Actor *)jarg2;
37302   if (!argp2) {
37303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37304     return ;
37305   }
37306   arg2 = *argp2;
37307   {
37308     try {
37309       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37310     } CALL_CATCH_EXCEPTION();
37311   }
37312
37313 }
37314
37315
37316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37317   unsigned int jresult ;
37318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37319   bool result;
37320
37321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37322   {
37323     try {
37324       result = (bool)(arg1)->OnKeyboardEnter();
37325     } CALL_CATCH_EXCEPTION(0);
37326   }
37327
37328   jresult = result;
37329   return jresult;
37330 }
37331
37332
37333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
37334   unsigned int jresult ;
37335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37336   bool result;
37337
37338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37339   {
37340     try {
37341       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37342     } CALL_CATCH_EXCEPTION(0);
37343   }
37344
37345   jresult = result;
37346   return jresult;
37347 }
37348
37349
37350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37352   Dali::PinchGesture *arg2 = 0 ;
37353
37354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37355   arg2 = (Dali::PinchGesture *)jarg2;
37356   if (!arg2) {
37357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37358     return ;
37359   }
37360   {
37361     try {
37362       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37363     } CALL_CATCH_EXCEPTION();
37364   }
37365
37366 }
37367
37368
37369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37371   Dali::PinchGesture *arg2 = 0 ;
37372
37373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37374   arg2 = (Dali::PinchGesture *)jarg2;
37375   if (!arg2) {
37376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37377     return ;
37378   }
37379   {
37380     try {
37381       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37382     } CALL_CATCH_EXCEPTION();
37383   }
37384
37385 }
37386
37387
37388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37390   Dali::PanGesture *arg2 = 0 ;
37391
37392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37393   arg2 = (Dali::PanGesture *)jarg2;
37394   if (!arg2) {
37395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37396     return ;
37397   }
37398   {
37399     try {
37400       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37401     } CALL_CATCH_EXCEPTION();
37402   }
37403
37404 }
37405
37406
37407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37409   Dali::PanGesture *arg2 = 0 ;
37410
37411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37412   arg2 = (Dali::PanGesture *)jarg2;
37413   if (!arg2) {
37414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37415     return ;
37416   }
37417   {
37418     try {
37419       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37420     } CALL_CATCH_EXCEPTION();
37421   }
37422
37423 }
37424
37425
37426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37428   Dali::TapGesture *arg2 = 0 ;
37429
37430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37431   arg2 = (Dali::TapGesture *)jarg2;
37432   if (!arg2) {
37433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37434     return ;
37435   }
37436   {
37437     try {
37438       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37439     } CALL_CATCH_EXCEPTION();
37440   }
37441
37442 }
37443
37444
37445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37447   Dali::TapGesture *arg2 = 0 ;
37448
37449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37450   arg2 = (Dali::TapGesture *)jarg2;
37451   if (!arg2) {
37452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37453     return ;
37454   }
37455   {
37456     try {
37457       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37458     } CALL_CATCH_EXCEPTION();
37459   }
37460
37461 }
37462
37463
37464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37466   Dali::LongPressGesture *arg2 = 0 ;
37467
37468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37469   arg2 = (Dali::LongPressGesture *)jarg2;
37470   if (!arg2) {
37471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37472     return ;
37473   }
37474   {
37475     try {
37476       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37477     } CALL_CATCH_EXCEPTION();
37478   }
37479
37480 }
37481
37482
37483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37485   Dali::LongPressGesture *arg2 = 0 ;
37486
37487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37488   arg2 = (Dali::LongPressGesture *)jarg2;
37489   if (!arg2) {
37490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37491     return ;
37492   }
37493   {
37494     try {
37495       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37496     } CALL_CATCH_EXCEPTION();
37497   }
37498
37499 }
37500
37501
37502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37504   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37505   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37506
37507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37508   arg2 = (Dali::SlotObserver *)jarg2;
37509   arg3 = (Dali::CallbackBase *)jarg3;
37510   {
37511     try {
37512       (arg1)->SignalConnected(arg2,arg3);
37513     } CALL_CATCH_EXCEPTION();
37514   }
37515
37516 }
37517
37518
37519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37520   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37521   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37522   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37523
37524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37525   arg2 = (Dali::SlotObserver *)jarg2;
37526   arg3 = (Dali::CallbackBase *)jarg3;
37527   {
37528     try {
37529       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37530     } CALL_CATCH_EXCEPTION();
37531   }
37532
37533 }
37534
37535
37536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
37537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37538   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37539   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37540
37541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37542   arg2 = (Dali::SlotObserver *)jarg2;
37543   arg3 = (Dali::CallbackBase *)jarg3;
37544   {
37545     try {
37546       (arg1)->SignalDisconnected(arg2,arg3);
37547     } CALL_CATCH_EXCEPTION();
37548   }
37549
37550 }
37551
37552
37553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37555   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37556   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37557
37558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37559   arg2 = (Dali::SlotObserver *)jarg2;
37560   arg3 = (Dali::CallbackBase *)jarg3;
37561   {
37562     try {
37563       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37564     } CALL_CATCH_EXCEPTION();
37565   }
37566
37567 }
37568
37569 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_Callback9_t callback9, 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) {
37570   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37571   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37572   if (director) {
37573     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, 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);
37574   }
37575 }
37576
37577
37578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37579   void * jresult ;
37580   Dali::Toolkit::Control *arg1 = 0 ;
37581   Dali::Toolkit::Internal::Control *result = 0 ;
37582
37583   arg1 = (Dali::Toolkit::Control *)jarg1;
37584   if (!arg1) {
37585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37586     return 0;
37587   }
37588   {
37589     try {
37590       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37591     } CALL_CATCH_EXCEPTION(0);
37592   }
37593
37594   jresult = (void *)result;
37595   return jresult;
37596 }
37597
37598
37599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37600   int jresult ;
37601   int result;
37602
37603   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37604   jresult = (int)result;
37605   return jresult;
37606 }
37607
37608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37609   int jresult ;
37610   int result;
37611
37612   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37613   jresult = (int)result;
37614   return jresult;
37615 }
37616
37617
37618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37619   int jresult ;
37620   int result;
37621
37622   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37623   jresult = (int)result;
37624   return jresult;
37625 }
37626
37627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37628   int jresult ;
37629   int result;
37630
37631   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37632   jresult = (int)result;
37633   return jresult;
37634 }
37635
37636
37637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37638   int jresult ;
37639   int result;
37640
37641   result = (int)Dali::Toolkit::Control::Property::PADDING;
37642   jresult = (int)result;
37643   return jresult;
37644 }
37645
37646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37647   int jresult ;
37648   int result;
37649
37650   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37651   jresult = (int)result;
37652   return jresult;
37653 }
37654
37655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37656   void * jresult ;
37657   Dali::Toolkit::Control::Property *result = 0 ;
37658
37659   {
37660     try {
37661       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37662     } CALL_CATCH_EXCEPTION(0);
37663   }
37664
37665   jresult = (void *)result;
37666   return jresult;
37667 }
37668
37669
37670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37671   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37672
37673   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37674   {
37675     try {
37676       delete arg1;
37677     } CALL_CATCH_EXCEPTION();
37678   }
37679
37680 }
37681
37682
37683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37684   void * jresult ;
37685   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37686
37687   {
37688     try {
37689       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37690     } CALL_CATCH_EXCEPTION(0);
37691   }
37692
37693   jresult = (void *)result;
37694   return jresult;
37695 }
37696
37697
37698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37699   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37700
37701   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37702   {
37703     try {
37704       delete arg1;
37705     } CALL_CATCH_EXCEPTION();
37706   }
37707
37708 }
37709
37710
37711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37712   void * jresult ;
37713   Dali::Toolkit::Control result;
37714
37715   {
37716     try {
37717       result = Dali::Toolkit::Control::New();
37718     } CALL_CATCH_EXCEPTION(0);
37719   }
37720
37721   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37722   return jresult;
37723 }
37724
37725
37726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37727   void * jresult ;
37728   Dali::Toolkit::Control *result = 0 ;
37729
37730   {
37731     try {
37732       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37733     } CALL_CATCH_EXCEPTION(0);
37734   }
37735
37736   jresult = (void *)result;
37737   return jresult;
37738 }
37739
37740
37741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37742   void * jresult ;
37743   Dali::Toolkit::Control *arg1 = 0 ;
37744   Dali::Toolkit::Control *result = 0 ;
37745
37746   arg1 = (Dali::Toolkit::Control *)jarg1;
37747   if (!arg1) {
37748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37749     return 0;
37750   }
37751   {
37752     try {
37753       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37754     } CALL_CATCH_EXCEPTION(0);
37755   }
37756
37757   jresult = (void *)result;
37758   return jresult;
37759 }
37760
37761
37762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
37763   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37764
37765   arg1 = (Dali::Toolkit::Control *)jarg1;
37766   {
37767     try {
37768       delete arg1;
37769     } CALL_CATCH_EXCEPTION();
37770   }
37771
37772 }
37773
37774
37775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
37776   void * jresult ;
37777   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37778   Dali::Toolkit::Control *arg2 = 0 ;
37779   Dali::Toolkit::Control *result = 0 ;
37780
37781   arg1 = (Dali::Toolkit::Control *)jarg1;
37782   arg2 = (Dali::Toolkit::Control *)jarg2;
37783   if (!arg2) {
37784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37785     return 0;
37786   }
37787   {
37788     try {
37789       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
37790     } CALL_CATCH_EXCEPTION(0);
37791   }
37792
37793   jresult = (void *)result;
37794   return jresult;
37795 }
37796
37797
37798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
37799   void * jresult ;
37800   Dali::BaseHandle arg1 ;
37801   Dali::BaseHandle *argp1 ;
37802   Dali::Toolkit::Control result;
37803
37804   argp1 = (Dali::BaseHandle *)jarg1;
37805   if (!argp1) {
37806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37807     return 0;
37808   }
37809   arg1 = *argp1;
37810   {
37811     try {
37812       result = Dali::Toolkit::Control::DownCast(arg1);
37813     } CALL_CATCH_EXCEPTION(0);
37814   }
37815
37816   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37817   return jresult;
37818 }
37819
37820
37821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
37822   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37823
37824   arg1 = (Dali::Toolkit::Control *)jarg1;
37825   {
37826     try {
37827       (arg1)->SetKeyInputFocus();
37828     } CALL_CATCH_EXCEPTION();
37829   }
37830
37831 }
37832
37833
37834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
37835   unsigned int jresult ;
37836   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37837   bool result;
37838
37839   arg1 = (Dali::Toolkit::Control *)jarg1;
37840   {
37841     try {
37842       result = (bool)(arg1)->HasKeyInputFocus();
37843     } CALL_CATCH_EXCEPTION(0);
37844   }
37845
37846   jresult = result;
37847   return jresult;
37848 }
37849
37850
37851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
37852   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37853
37854   arg1 = (Dali::Toolkit::Control *)jarg1;
37855   {
37856     try {
37857       (arg1)->ClearKeyInputFocus();
37858     } CALL_CATCH_EXCEPTION();
37859   }
37860
37861 }
37862
37863
37864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
37865   void * jresult ;
37866   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37867   Dali::PinchGestureDetector result;
37868
37869   arg1 = (Dali::Toolkit::Control *)jarg1;
37870   {
37871     try {
37872       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
37873     } CALL_CATCH_EXCEPTION(0);
37874   }
37875
37876   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
37877   return jresult;
37878 }
37879
37880
37881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
37882   void * jresult ;
37883   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37884   Dali::PanGestureDetector result;
37885
37886   arg1 = (Dali::Toolkit::Control *)jarg1;
37887   {
37888     try {
37889       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
37890     } CALL_CATCH_EXCEPTION(0);
37891   }
37892
37893   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
37894   return jresult;
37895 }
37896
37897
37898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
37899   void * jresult ;
37900   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37901   Dali::TapGestureDetector result;
37902
37903   arg1 = (Dali::Toolkit::Control *)jarg1;
37904   {
37905     try {
37906       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
37907     } CALL_CATCH_EXCEPTION(0);
37908   }
37909
37910   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
37911   return jresult;
37912 }
37913
37914
37915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
37916   void * jresult ;
37917   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37918   Dali::LongPressGestureDetector result;
37919
37920   arg1 = (Dali::Toolkit::Control *)jarg1;
37921   {
37922     try {
37923       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
37924     } CALL_CATCH_EXCEPTION(0);
37925   }
37926
37927   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
37928   return jresult;
37929 }
37930
37931
37932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
37933   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37934   std::string *arg2 = 0 ;
37935
37936   arg1 = (Dali::Toolkit::Control *)jarg1;
37937   if (!jarg2) {
37938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37939     return ;
37940   }
37941   std::string arg2_str(jarg2);
37942   arg2 = &arg2_str;
37943   {
37944     try {
37945       (arg1)->SetStyleName((std::string const &)*arg2);
37946     } CALL_CATCH_EXCEPTION();
37947   }
37948
37949
37950   //argout typemap for const std::string&
37951
37952 }
37953
37954
37955 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
37956   char * jresult ;
37957   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37958   std::string *result = 0 ;
37959
37960   arg1 = (Dali::Toolkit::Control *)jarg1;
37961   {
37962     try {
37963       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
37964     } CALL_CATCH_EXCEPTION(0);
37965   }
37966
37967   jresult = SWIG_csharp_string_callback(result->c_str());
37968   return jresult;
37969 }
37970
37971
37972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
37973   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37974   Dali::Vector4 *arg2 = 0 ;
37975
37976   arg1 = (Dali::Toolkit::Control *)jarg1;
37977   arg2 = (Dali::Vector4 *)jarg2;
37978   if (!arg2) {
37979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
37980     return ;
37981   }
37982   {
37983     try {
37984       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
37985     } CALL_CATCH_EXCEPTION();
37986   }
37987
37988 }
37989
37990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
37991   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37992
37993   arg1 = (Dali::Toolkit::Control *)jarg1;
37994   {
37995     try {
37996       (arg1)->ClearBackground();
37997     } CALL_CATCH_EXCEPTION();
37998   }
37999
38000 }
38001
38002
38003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38004   void * jresult ;
38005   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38006   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38007
38008   arg1 = (Dali::Toolkit::Control *)jarg1;
38009   {
38010     try {
38011       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38012     } CALL_CATCH_EXCEPTION(0);
38013   }
38014
38015   jresult = (void *)result;
38016   return jresult;
38017 }
38018
38019
38020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38021   void * jresult ;
38022   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38023   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38024
38025   arg1 = (Dali::Toolkit::Control *)jarg1;
38026   {
38027     try {
38028       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38029     } CALL_CATCH_EXCEPTION(0);
38030   }
38031
38032   jresult = (void *)result;
38033   return jresult;
38034 }
38035
38036
38037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
38038   void * jresult ;
38039   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38040   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38041
38042   arg1 = (Dali::Toolkit::Control *)jarg1;
38043   {
38044     try {
38045       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38046     } CALL_CATCH_EXCEPTION(0);
38047   }
38048
38049   jresult = (void *)result;
38050   return jresult;
38051 }
38052
38053
38054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38055   void * jresult ;
38056   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38057   Dali::Toolkit::Control *result = 0 ;
38058
38059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38060   if (!arg1) {
38061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38062     return 0;
38063   }
38064   {
38065     try {
38066       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38067     } CALL_CATCH_EXCEPTION(0);
38068   }
38069
38070   jresult = (void *)result;
38071   return jresult;
38072 }
38073
38074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38075 {
38076   int jresult;
38077   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38078   arg1 = (Dali::Toolkit::Control *)jarg1;
38079
38080   if (!arg1) {
38081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38082     return 0;
38083   }
38084
38085   Dali::Property::Index arg2 = 0 ;
38086   arg2 = (Dali::Property::Index)jarg2;
38087
38088   Toolkit::Visual::ResourceStatus result;
38089   {
38090     try {
38091       result = arg1->GetVisualResourceStatus(arg2);
38092     } CALL_CATCH_EXCEPTION(0);
38093   }
38094
38095   jresult = (int)result;
38096   return jresult;
38097 }
38098
38099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38100 {
38101   void * jresult;
38102   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38103   arg1 = (Dali::Toolkit::Control *)jarg1;
38104
38105   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38106
38107   Dali::Toolkit::TransitionData *arg2 = 0 ;
38108   Dali::Animation result;
38109
38110   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38111   if (!arg2) {
38112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38113     return 0;
38114   }
38115   {
38116     try {
38117       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38118     } CALL_CATCH_EXCEPTION(0);
38119   }
38120
38121   jresult = new Dali::Animation((const Dali::Animation &)result);
38122   return jresult;
38123 }
38124
38125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38126 {
38127   Dali::Toolkit::Control arg1;
38128   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38129
38130   if (!argp1) {
38131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38132   }
38133   arg1 = *argp1;
38134
38135   Dali::Property::Index arg2 = 0 ;
38136   arg2 = (Dali::Property::Index)jarg2;
38137
38138   Dali::Property::Index arg3 = 0 ;
38139   arg3 = (Dali::Property::Index)jarg3;
38140
38141   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38142
38143   {
38144     try {
38145       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38146     } CALL_CATCH_EXCEPTION();
38147   }
38148 }
38149
38150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38151   void * jresult ;
38152   Dali::Toolkit::Control *arg1 = 0 ;
38153   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38154
38155   arg1 = (Dali::Toolkit::Control *)jarg1;
38156   if (!arg1) {
38157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38158     return 0;
38159   }
38160   {
38161     try {
38162       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38163     } CALL_CATCH_EXCEPTION(0);
38164   }
38165
38166   jresult = (void *)result;
38167   return jresult;
38168 }
38169
38170
38171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38172   unsigned int jresult ;
38173   Dali::Toolkit::Control *arg1 = 0 ;
38174   bool result;
38175
38176   arg1 = (Dali::Toolkit::Control *)jarg1;
38177   if (!arg1) {
38178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38179     return 0;
38180   }
38181   {
38182     try {
38183       result = (bool)arg1->IsResourceReady();
38184     } CALL_CATCH_EXCEPTION(0);
38185   }
38186
38187   jresult = result;
38188   return jresult;
38189 }
38190
38191
38192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38193   void * jresult ;
38194   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38195
38196   {
38197     try {
38198       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38199     } CALL_CATCH_EXCEPTION(0);
38200   }
38201
38202   jresult = (void *)result;
38203   return jresult;
38204 }
38205
38206
38207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38208   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38209
38210   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38211   {
38212     try {
38213       delete arg1;
38214     } CALL_CATCH_EXCEPTION();
38215   }
38216
38217 }
38218
38219
38220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38221   void * jresult ;
38222   Dali::Toolkit::KeyInputFocusManager result;
38223
38224   {
38225     try {
38226       result = Dali::Toolkit::KeyInputFocusManager::Get();
38227     } CALL_CATCH_EXCEPTION(0);
38228   }
38229
38230   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38231   return jresult;
38232 }
38233
38234
38235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38236   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38237   Dali::Toolkit::Control arg2 ;
38238   Dali::Toolkit::Control *argp2 ;
38239
38240   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38241   argp2 = (Dali::Toolkit::Control *)jarg2;
38242   if (!argp2) {
38243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38244     return ;
38245   }
38246   arg2 = *argp2;
38247   {
38248     try {
38249       (arg1)->SetFocus(arg2);
38250     } CALL_CATCH_EXCEPTION();
38251   }
38252
38253 }
38254
38255
38256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38257   void * jresult ;
38258   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38259   Dali::Toolkit::Control result;
38260
38261   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38262   {
38263     try {
38264       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38265     } CALL_CATCH_EXCEPTION(0);
38266   }
38267
38268   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38269   return jresult;
38270 }
38271
38272
38273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38274   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38275   Dali::Toolkit::Control arg2 ;
38276   Dali::Toolkit::Control *argp2 ;
38277
38278   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38279   argp2 = (Dali::Toolkit::Control *)jarg2;
38280   if (!argp2) {
38281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38282     return ;
38283   }
38284   arg2 = *argp2;
38285   {
38286     try {
38287       (arg1)->RemoveFocus(arg2);
38288     } CALL_CATCH_EXCEPTION();
38289   }
38290
38291 }
38292
38293
38294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38295   void * jresult ;
38296   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38297   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38298
38299   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38300   {
38301     try {
38302       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38303     } CALL_CATCH_EXCEPTION(0);
38304   }
38305
38306   jresult = (void *)result;
38307   return jresult;
38308 }
38309
38310
38311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38312   void * jresult ;
38313   Dali::Toolkit::Alignment::Padding *result = 0 ;
38314
38315   {
38316     try {
38317       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38318     } CALL_CATCH_EXCEPTION(0);
38319   }
38320
38321   jresult = (void *)result;
38322   return jresult;
38323 }
38324
38325
38326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38327   void * jresult ;
38328   float arg1 ;
38329   float arg2 ;
38330   float arg3 ;
38331   float arg4 ;
38332   Dali::Toolkit::Alignment::Padding *result = 0 ;
38333
38334   arg1 = (float)jarg1;
38335   arg2 = (float)jarg2;
38336   arg3 = (float)jarg3;
38337   arg4 = (float)jarg4;
38338   {
38339     try {
38340       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38341     } CALL_CATCH_EXCEPTION(0);
38342   }
38343
38344   jresult = (void *)result;
38345   return jresult;
38346 }
38347
38348
38349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38350   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38351   float arg2 ;
38352
38353   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38354   arg2 = (float)jarg2;
38355   if (arg1) (arg1)->left = arg2;
38356 }
38357
38358
38359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38360   float jresult ;
38361   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38362   float result;
38363
38364   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38365   result = (float) ((arg1)->left);
38366   jresult = result;
38367   return jresult;
38368 }
38369
38370
38371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38372   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38373   float arg2 ;
38374
38375   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38376   arg2 = (float)jarg2;
38377   if (arg1) (arg1)->right = arg2;
38378 }
38379
38380
38381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38382   float jresult ;
38383   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38384   float result;
38385
38386   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38387   result = (float) ((arg1)->right);
38388   jresult = result;
38389   return jresult;
38390 }
38391
38392
38393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38394   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38395   float arg2 ;
38396
38397   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38398   arg2 = (float)jarg2;
38399   if (arg1) (arg1)->top = arg2;
38400 }
38401
38402
38403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38404   float jresult ;
38405   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38406   float result;
38407
38408   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38409   result = (float) ((arg1)->top);
38410   jresult = result;
38411   return jresult;
38412 }
38413
38414
38415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38416   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38417   float arg2 ;
38418
38419   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38420   arg2 = (float)jarg2;
38421   if (arg1) (arg1)->bottom = arg2;
38422 }
38423
38424
38425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38426   float jresult ;
38427   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38428   float result;
38429
38430   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38431   result = (float) ((arg1)->bottom);
38432   jresult = result;
38433   return jresult;
38434 }
38435
38436
38437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38438   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38439
38440   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38441   {
38442     try {
38443       delete arg1;
38444     } CALL_CATCH_EXCEPTION();
38445   }
38446
38447 }
38448
38449
38450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38451   void * jresult ;
38452   Dali::Toolkit::Alignment *result = 0 ;
38453
38454   {
38455     try {
38456       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38457     } CALL_CATCH_EXCEPTION(0);
38458   }
38459
38460   jresult = (void *)result;
38461   return jresult;
38462 }
38463
38464
38465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38466   void * jresult ;
38467   Dali::Toolkit::Alignment::Type arg1 ;
38468   Dali::Toolkit::Alignment::Type arg2 ;
38469   Dali::Toolkit::Alignment result;
38470
38471   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38472   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38473   {
38474     try {
38475       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38476     } CALL_CATCH_EXCEPTION(0);
38477   }
38478
38479   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38480   return jresult;
38481 }
38482
38483
38484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38485   void * jresult ;
38486   Dali::Toolkit::Alignment::Type arg1 ;
38487   Dali::Toolkit::Alignment result;
38488
38489   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38490   {
38491     try {
38492       result = Dali::Toolkit::Alignment::New(arg1);
38493     } CALL_CATCH_EXCEPTION(0);
38494   }
38495
38496   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38497   return jresult;
38498 }
38499
38500
38501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
38502   void * jresult ;
38503   Dali::Toolkit::Alignment result;
38504
38505   {
38506     try {
38507       result = Dali::Toolkit::Alignment::New();
38508     } CALL_CATCH_EXCEPTION(0);
38509   }
38510
38511   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38512   return jresult;
38513 }
38514
38515
38516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38517   void * jresult ;
38518   Dali::Toolkit::Alignment *arg1 = 0 ;
38519   Dali::Toolkit::Alignment *result = 0 ;
38520
38521   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38522   if (!arg1) {
38523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38524     return 0;
38525   }
38526   {
38527     try {
38528       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38529     } CALL_CATCH_EXCEPTION(0);
38530   }
38531
38532   jresult = (void *)result;
38533   return jresult;
38534 }
38535
38536
38537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38538   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38539
38540   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38541   {
38542     try {
38543       delete arg1;
38544     } CALL_CATCH_EXCEPTION();
38545   }
38546
38547 }
38548
38549
38550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38551   void * jresult ;
38552   Dali::BaseHandle arg1 ;
38553   Dali::BaseHandle *argp1 ;
38554   Dali::Toolkit::Alignment result;
38555
38556   argp1 = (Dali::BaseHandle *)jarg1;
38557   if (!argp1) {
38558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38559     return 0;
38560   }
38561   arg1 = *argp1;
38562   {
38563     try {
38564       result = Dali::Toolkit::Alignment::DownCast(arg1);
38565     } CALL_CATCH_EXCEPTION(0);
38566   }
38567
38568   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38569   return jresult;
38570 }
38571
38572
38573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38574   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38575   Dali::Toolkit::Alignment::Type arg2 ;
38576
38577   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38578   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38579   {
38580     try {
38581       (arg1)->SetAlignmentType(arg2);
38582     } CALL_CATCH_EXCEPTION();
38583   }
38584
38585 }
38586
38587
38588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38589   int jresult ;
38590   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38591   Dali::Toolkit::Alignment::Type result;
38592
38593   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38594   {
38595     try {
38596       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38597     } CALL_CATCH_EXCEPTION(0);
38598   }
38599
38600   jresult = (int)result;
38601   return jresult;
38602 }
38603
38604
38605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38606   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38607   Dali::Toolkit::Alignment::Scaling arg2 ;
38608
38609   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38610   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38611   {
38612     try {
38613       (arg1)->SetScaling(arg2);
38614     } CALL_CATCH_EXCEPTION();
38615   }
38616
38617 }
38618
38619
38620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38621   int jresult ;
38622   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38623   Dali::Toolkit::Alignment::Scaling result;
38624
38625   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38626   {
38627     try {
38628       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38629     } CALL_CATCH_EXCEPTION(0);
38630   }
38631
38632   jresult = (int)result;
38633   return jresult;
38634 }
38635
38636
38637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38638   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38639   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38640
38641   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38642   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38643   if (!arg2) {
38644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38645     return ;
38646   }
38647   {
38648     try {
38649       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38650     } CALL_CATCH_EXCEPTION();
38651   }
38652
38653 }
38654
38655
38656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38657   void * jresult ;
38658   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38659   Dali::Toolkit::Alignment::Padding *result = 0 ;
38660
38661   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38662   {
38663     try {
38664       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38665     } CALL_CATCH_EXCEPTION(0);
38666   }
38667
38668   jresult = (void *)result;
38669   return jresult;
38670 }
38671
38672
38673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38674   void * jresult ;
38675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38676   Dali::Toolkit::Alignment *arg2 = 0 ;
38677   Dali::Toolkit::Alignment *result = 0 ;
38678
38679   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38680   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38681   if (!arg2) {
38682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38683     return 0;
38684   }
38685   {
38686     try {
38687       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38688     } CALL_CATCH_EXCEPTION(0);
38689   }
38690
38691   jresult = (void *)result;
38692   return jresult;
38693 }
38694
38695
38696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38697   int jresult ;
38698   int result;
38699
38700   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38701   jresult = (int)result;
38702   return jresult;
38703 }
38704
38705
38706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38707   int jresult ;
38708   int result;
38709
38710   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38711   jresult = (int)result;
38712   return jresult;
38713 }
38714
38715
38716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38717   int jresult ;
38718   int result;
38719
38720   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38721   jresult = (int)result;
38722   return jresult;
38723 }
38724
38725
38726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38727   int jresult ;
38728   int result;
38729
38730   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38731   jresult = (int)result;
38732   return jresult;
38733 }
38734
38735
38736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38737   int jresult ;
38738   int result;
38739
38740   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38741   jresult = (int)result;
38742   return jresult;
38743 }
38744
38745
38746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38747   int jresult ;
38748   int result;
38749
38750   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38751   jresult = (int)result;
38752   return jresult;
38753 }
38754
38755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38756   int jresult ;
38757   int result;
38758
38759   result = (int)Dali::Toolkit::Button::Property::LABEL;
38760   jresult = (int)result;
38761   return jresult;
38762 }
38763
38764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
38765   void * jresult ;
38766   Dali::Toolkit::Button::Property *result = 0 ;
38767
38768   {
38769     try {
38770       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
38771     } CALL_CATCH_EXCEPTION(0);
38772   }
38773
38774   jresult = (void *)result;
38775   return jresult;
38776 }
38777
38778
38779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
38780   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
38781
38782   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
38783   {
38784     try {
38785       delete arg1;
38786     } CALL_CATCH_EXCEPTION();
38787   }
38788
38789 }
38790
38791
38792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
38793   void * jresult ;
38794   Dali::Toolkit::Button *result = 0 ;
38795
38796   {
38797     try {
38798       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
38799     } CALL_CATCH_EXCEPTION(0);
38800   }
38801
38802   jresult = (void *)result;
38803   return jresult;
38804 }
38805
38806
38807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
38808   void * jresult ;
38809   Dali::Toolkit::Button *arg1 = 0 ;
38810   Dali::Toolkit::Button *result = 0 ;
38811
38812   arg1 = (Dali::Toolkit::Button *)jarg1;
38813   if (!arg1) {
38814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38815     return 0;
38816   }
38817   {
38818     try {
38819       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
38820     } CALL_CATCH_EXCEPTION(0);
38821   }
38822
38823   jresult = (void *)result;
38824   return jresult;
38825 }
38826
38827
38828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
38829   void * jresult ;
38830   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38831   Dali::Toolkit::Button *arg2 = 0 ;
38832   Dali::Toolkit::Button *result = 0 ;
38833
38834   arg1 = (Dali::Toolkit::Button *)jarg1;
38835   arg2 = (Dali::Toolkit::Button *)jarg2;
38836   if (!arg2) {
38837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38838     return 0;
38839   }
38840   {
38841     try {
38842       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
38843     } CALL_CATCH_EXCEPTION(0);
38844   }
38845
38846   jresult = (void *)result;
38847   return jresult;
38848 }
38849
38850
38851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
38852   void * jresult ;
38853   Dali::BaseHandle arg1 ;
38854   Dali::BaseHandle *argp1 ;
38855   Dali::Toolkit::Button result;
38856
38857   argp1 = (Dali::BaseHandle *)jarg1;
38858   if (!argp1) {
38859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38860     return 0;
38861   }
38862   arg1 = *argp1;
38863   {
38864     try {
38865       result = Dali::Toolkit::Button::DownCast(arg1);
38866     } CALL_CATCH_EXCEPTION(0);
38867   }
38868
38869   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
38870   return jresult;
38871 }
38872
38873
38874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
38875   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38876
38877   arg1 = (Dali::Toolkit::Button *)jarg1;
38878   {
38879     try {
38880       delete arg1;
38881     } CALL_CATCH_EXCEPTION();
38882   }
38883
38884 }
38885
38886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
38887   void * jresult ;
38888   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38889   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38890
38891   arg1 = (Dali::Toolkit::Button *)jarg1;
38892   {
38893     try {
38894       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
38895     } CALL_CATCH_EXCEPTION(0);
38896   }
38897
38898   jresult = (void *)result;
38899   return jresult;
38900 }
38901
38902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
38903   void * jresult ;
38904   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38905   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38906
38907   arg1 = (Dali::Toolkit::Button *)jarg1;
38908   {
38909     try {
38910       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
38911     } CALL_CATCH_EXCEPTION(0);
38912   }
38913
38914   jresult = (void *)result;
38915   return jresult;
38916 }
38917
38918
38919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
38920   void * jresult ;
38921   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38922   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38923
38924   arg1 = (Dali::Toolkit::Button *)jarg1;
38925   {
38926     try {
38927       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
38928     } CALL_CATCH_EXCEPTION(0);
38929   }
38930
38931   jresult = (void *)result;
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
38937   void * jresult ;
38938   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38939   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38940
38941   arg1 = (Dali::Toolkit::Button *)jarg1;
38942   {
38943     try {
38944       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
38945     } CALL_CATCH_EXCEPTION(0);
38946   }
38947
38948   jresult = (void *)result;
38949   return jresult;
38950 }
38951
38952
38953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
38954   void * jresult ;
38955   Dali::Toolkit::CheckBoxButton *result = 0 ;
38956
38957   {
38958     try {
38959       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
38960     } CALL_CATCH_EXCEPTION(0);
38961   }
38962
38963   jresult = (void *)result;
38964   return jresult;
38965 }
38966
38967
38968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
38969   void * jresult ;
38970   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
38971   Dali::Toolkit::CheckBoxButton *result = 0 ;
38972
38973   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
38974   if (!arg1) {
38975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
38976     return 0;
38977   }
38978   {
38979     try {
38980       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
38981     } CALL_CATCH_EXCEPTION(0);
38982   }
38983
38984   jresult = (void *)result;
38985   return jresult;
38986 }
38987
38988
38989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
38990   void * jresult ;
38991   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
38992   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
38993   Dali::Toolkit::CheckBoxButton *result = 0 ;
38994
38995   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
38996   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
38997   if (!arg2) {
38998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
38999     return 0;
39000   }
39001   {
39002     try {
39003       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39004     } CALL_CATCH_EXCEPTION(0);
39005   }
39006
39007   jresult = (void *)result;
39008   return jresult;
39009 }
39010
39011
39012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
39013   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39014
39015   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39016   {
39017     try {
39018       delete arg1;
39019     } CALL_CATCH_EXCEPTION();
39020   }
39021
39022 }
39023
39024
39025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
39026   void * jresult ;
39027   Dali::Toolkit::CheckBoxButton result;
39028
39029   {
39030     try {
39031       result = Dali::Toolkit::CheckBoxButton::New();
39032     } CALL_CATCH_EXCEPTION(0);
39033   }
39034
39035   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39036   return jresult;
39037 }
39038
39039
39040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39041   void * jresult ;
39042   Dali::BaseHandle arg1 ;
39043   Dali::BaseHandle *argp1 ;
39044   Dali::Toolkit::CheckBoxButton result;
39045
39046   argp1 = (Dali::BaseHandle *)jarg1;
39047   if (!argp1) {
39048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39049     return 0;
39050   }
39051   arg1 = *argp1;
39052   {
39053     try {
39054       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39055     } CALL_CATCH_EXCEPTION(0);
39056   }
39057
39058   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39059   return jresult;
39060 }
39061
39062
39063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39064   int jresult ;
39065   int result;
39066
39067   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39068   jresult = (int)result;
39069   return jresult;
39070 }
39071
39072
39073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39074   int jresult ;
39075   int result;
39076
39077   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39078   jresult = (int)result;
39079   return jresult;
39080 }
39081
39082
39083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39084   void * jresult ;
39085   Dali::Toolkit::PushButton::Property *result = 0 ;
39086
39087   {
39088     try {
39089       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39090     } CALL_CATCH_EXCEPTION(0);
39091   }
39092
39093   jresult = (void *)result;
39094   return jresult;
39095 }
39096
39097
39098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39099   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39100
39101   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39102   {
39103     try {
39104       delete arg1;
39105     } CALL_CATCH_EXCEPTION();
39106   }
39107
39108 }
39109
39110
39111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39112   void * jresult ;
39113   Dali::Toolkit::PushButton *result = 0 ;
39114
39115   {
39116     try {
39117       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39118     } CALL_CATCH_EXCEPTION(0);
39119   }
39120
39121   jresult = (void *)result;
39122   return jresult;
39123 }
39124
39125
39126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39127   void * jresult ;
39128   Dali::Toolkit::PushButton *arg1 = 0 ;
39129   Dali::Toolkit::PushButton *result = 0 ;
39130
39131   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39132   if (!arg1) {
39133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39134     return 0;
39135   }
39136   {
39137     try {
39138       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39139     } CALL_CATCH_EXCEPTION(0);
39140   }
39141
39142   jresult = (void *)result;
39143   return jresult;
39144 }
39145
39146
39147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39148   void * jresult ;
39149   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39150   Dali::Toolkit::PushButton *arg2 = 0 ;
39151   Dali::Toolkit::PushButton *result = 0 ;
39152
39153   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39154   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39155   if (!arg2) {
39156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39157     return 0;
39158   }
39159   {
39160     try {
39161       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39162     } CALL_CATCH_EXCEPTION(0);
39163   }
39164
39165   jresult = (void *)result;
39166   return jresult;
39167 }
39168
39169
39170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39171   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39172
39173   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39174   {
39175     try {
39176       delete arg1;
39177     } CALL_CATCH_EXCEPTION();
39178   }
39179
39180 }
39181
39182
39183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39184   void * jresult ;
39185   Dali::Toolkit::PushButton result;
39186
39187   {
39188     try {
39189       result = Dali::Toolkit::PushButton::New();
39190     } CALL_CATCH_EXCEPTION(0);
39191   }
39192
39193   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39199   void * jresult ;
39200   Dali::BaseHandle arg1 ;
39201   Dali::BaseHandle *argp1 ;
39202   Dali::Toolkit::PushButton result;
39203
39204   argp1 = (Dali::BaseHandle *)jarg1;
39205   if (!argp1) {
39206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39207     return 0;
39208   }
39209   arg1 = *argp1;
39210   {
39211     try {
39212       result = Dali::Toolkit::PushButton::DownCast(arg1);
39213     } CALL_CATCH_EXCEPTION(0);
39214   }
39215
39216   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39217   return jresult;
39218 }
39219
39220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39221   void * jresult ;
39222   Dali::Toolkit::RadioButton *result = 0 ;
39223
39224   {
39225     try {
39226       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39227     } CALL_CATCH_EXCEPTION(0);
39228   }
39229
39230   jresult = (void *)result;
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39236   void * jresult ;
39237   Dali::Toolkit::RadioButton *arg1 = 0 ;
39238   Dali::Toolkit::RadioButton *result = 0 ;
39239
39240   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39241   if (!arg1) {
39242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39243     return 0;
39244   }
39245   {
39246     try {
39247       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39248     } CALL_CATCH_EXCEPTION(0);
39249   }
39250
39251   jresult = (void *)result;
39252   return jresult;
39253 }
39254
39255
39256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39257   void * jresult ;
39258   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39259   Dali::Toolkit::RadioButton *arg2 = 0 ;
39260   Dali::Toolkit::RadioButton *result = 0 ;
39261
39262   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39263   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39264   if (!arg2) {
39265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39266     return 0;
39267   }
39268   {
39269     try {
39270       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39271     } CALL_CATCH_EXCEPTION(0);
39272   }
39273
39274   jresult = (void *)result;
39275   return jresult;
39276 }
39277
39278
39279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39280   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39281
39282   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39283   {
39284     try {
39285       delete arg1;
39286     } CALL_CATCH_EXCEPTION();
39287   }
39288
39289 }
39290
39291
39292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39293   void * jresult ;
39294   Dali::Toolkit::RadioButton result;
39295
39296   {
39297     try {
39298       result = Dali::Toolkit::RadioButton::New();
39299     } CALL_CATCH_EXCEPTION(0);
39300   }
39301
39302   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39303   return jresult;
39304 }
39305
39306
39307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39308   void * jresult ;
39309   std::string *arg1 = 0 ;
39310   Dali::Toolkit::RadioButton result;
39311
39312   if (!jarg1) {
39313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39314     return 0;
39315   }
39316   std::string arg1_str(jarg1);
39317   arg1 = &arg1_str;
39318   {
39319     try {
39320       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39321     } CALL_CATCH_EXCEPTION(0);
39322   }
39323
39324   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39325
39326   //argout typemap for const std::string&
39327
39328   return jresult;
39329 }
39330
39331
39332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39333   void * jresult ;
39334   Dali::BaseHandle arg1 ;
39335   Dali::BaseHandle *argp1 ;
39336   Dali::Toolkit::RadioButton result;
39337
39338   argp1 = (Dali::BaseHandle *)jarg1;
39339   if (!argp1) {
39340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39341     return 0;
39342   }
39343   arg1 = *argp1;
39344   {
39345     try {
39346       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39347     } CALL_CATCH_EXCEPTION(0);
39348   }
39349
39350   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39351   return jresult;
39352 }
39353
39354
39355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39356   int jresult ;
39357   int result;
39358
39359   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39360   jresult = (int)result;
39361   return jresult;
39362 }
39363
39364
39365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39366   int jresult ;
39367   int result;
39368
39369   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39370   jresult = (int)result;
39371   return jresult;
39372 }
39373
39374
39375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39376   int jresult ;
39377   int result;
39378
39379   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39380   jresult = (int)result;
39381   return jresult;
39382 }
39383
39384
39385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39386   int jresult ;
39387   int result;
39388
39389   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39390   jresult = (int)result;
39391   return jresult;
39392 }
39393
39394
39395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39396   int jresult ;
39397   int result;
39398
39399   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39400   jresult = (int)result;
39401   return jresult;
39402 }
39403
39404
39405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39406   int jresult ;
39407   int result;
39408
39409   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39410   jresult = (int)result;
39411   return jresult;
39412 }
39413
39414
39415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39416   void * jresult ;
39417   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39418
39419   {
39420     try {
39421       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39422     } CALL_CATCH_EXCEPTION(0);
39423   }
39424
39425   jresult = (void *)result;
39426   return jresult;
39427 }
39428
39429
39430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39431   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39432
39433   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39434   {
39435     try {
39436       delete arg1;
39437     } CALL_CATCH_EXCEPTION();
39438   }
39439
39440 }
39441
39442
39443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39444   int jresult ;
39445   int result;
39446
39447   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39448   jresult = (int)result;
39449   return jresult;
39450 }
39451
39452
39453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39454   int jresult ;
39455   int result;
39456
39457   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39458   jresult = (int)result;
39459   return jresult;
39460 }
39461
39462
39463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39464   int jresult ;
39465   int result;
39466
39467   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39468   jresult = (int)result;
39469   return jresult;
39470 }
39471
39472
39473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39474   void * jresult ;
39475   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39476
39477   {
39478     try {
39479       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39480     } CALL_CATCH_EXCEPTION(0);
39481   }
39482
39483   jresult = (void *)result;
39484   return jresult;
39485 }
39486
39487
39488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39489   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39490
39491   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39492   {
39493     try {
39494       delete arg1;
39495     } CALL_CATCH_EXCEPTION();
39496   }
39497
39498 }
39499
39500
39501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39502   void * jresult ;
39503   Dali::Toolkit::FlexContainer *result = 0 ;
39504
39505   {
39506     try {
39507       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39508     } CALL_CATCH_EXCEPTION(0);
39509   }
39510
39511   jresult = (void *)result;
39512   return jresult;
39513 }
39514
39515
39516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39517   void * jresult ;
39518   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39519   Dali::Toolkit::FlexContainer *result = 0 ;
39520
39521   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39522   if (!arg1) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39524     return 0;
39525   }
39526   {
39527     try {
39528       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39529     } CALL_CATCH_EXCEPTION(0);
39530   }
39531
39532   jresult = (void *)result;
39533   return jresult;
39534 }
39535
39536
39537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39538   void * jresult ;
39539   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39540   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39541   Dali::Toolkit::FlexContainer *result = 0 ;
39542
39543   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39544   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39545   if (!arg2) {
39546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39547     return 0;
39548   }
39549   {
39550     try {
39551       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39552     } CALL_CATCH_EXCEPTION(0);
39553   }
39554
39555   jresult = (void *)result;
39556   return jresult;
39557 }
39558
39559
39560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39561   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39562
39563   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39564   {
39565     try {
39566       delete arg1;
39567     } CALL_CATCH_EXCEPTION();
39568   }
39569
39570 }
39571
39572
39573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39574   void * jresult ;
39575   Dali::Toolkit::FlexContainer result;
39576
39577   {
39578     try {
39579       result = Dali::Toolkit::FlexContainer::New();
39580     } CALL_CATCH_EXCEPTION(0);
39581   }
39582
39583   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39584   return jresult;
39585 }
39586
39587
39588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39589   void * jresult ;
39590   Dali::BaseHandle arg1 ;
39591   Dali::BaseHandle *argp1 ;
39592   Dali::Toolkit::FlexContainer result;
39593
39594   argp1 = (Dali::BaseHandle *)jarg1;
39595   if (!argp1) {
39596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39597     return 0;
39598   }
39599   arg1 = *argp1;
39600   {
39601     try {
39602       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39603     } CALL_CATCH_EXCEPTION(0);
39604   }
39605
39606   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39607   return jresult;
39608 }
39609
39610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39611   int jresult ;
39612   int result;
39613
39614   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39615   jresult = (int)result;
39616   return jresult;
39617 }
39618
39619
39620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39621   int jresult ;
39622   int result;
39623
39624   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39625   jresult = (int)result;
39626   return jresult;
39627 }
39628
39629
39630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39631   int jresult ;
39632   int result;
39633
39634   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39635   jresult = (int)result;
39636   return jresult;
39637 }
39638
39639
39640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39641   void * jresult ;
39642   Dali::Toolkit::ImageView::Property *result = 0 ;
39643
39644   {
39645     try {
39646       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39647     } CALL_CATCH_EXCEPTION(0);
39648   }
39649
39650   jresult = (void *)result;
39651   return jresult;
39652 }
39653
39654
39655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39656   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39657
39658   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39659   {
39660     try {
39661       delete arg1;
39662     } CALL_CATCH_EXCEPTION();
39663   }
39664
39665 }
39666
39667
39668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39669   void * jresult ;
39670   Dali::Toolkit::ImageView *result = 0 ;
39671
39672   {
39673     try {
39674       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39675     } CALL_CATCH_EXCEPTION(0);
39676   }
39677
39678   jresult = (void *)result;
39679   return jresult;
39680 }
39681
39682
39683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39684   void * jresult ;
39685   Dali::Toolkit::ImageView result;
39686
39687   {
39688     try {
39689       result = Dali::Toolkit::ImageView::New();
39690     } CALL_CATCH_EXCEPTION(0);
39691   }
39692
39693   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39694   return jresult;
39695 }
39696
39697
39698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39699   void * jresult ;
39700   std::string *arg1 = 0 ;
39701   Dali::Toolkit::ImageView result;
39702
39703   if (!jarg1) {
39704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39705     return 0;
39706   }
39707   std::string arg1_str(jarg1);
39708   arg1 = &arg1_str;
39709   {
39710     try {
39711       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39712     } CALL_CATCH_EXCEPTION(0);
39713   }
39714
39715   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39716
39717   //argout typemap for const std::string&
39718
39719   return jresult;
39720 }
39721
39722
39723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39724   void * jresult ;
39725   std::string *arg1 = 0 ;
39726   Dali::ImageDimensions arg2 ;
39727   Dali::ImageDimensions *argp2 ;
39728   Dali::Toolkit::ImageView result;
39729
39730   if (!jarg1) {
39731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39732     return 0;
39733   }
39734   std::string arg1_str(jarg1);
39735   arg1 = &arg1_str;
39736   argp2 = (Dali::ImageDimensions *)jarg2;
39737   if (!argp2) {
39738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39739     return 0;
39740   }
39741   arg2 = *argp2;
39742   {
39743     try {
39744       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39745     } CALL_CATCH_EXCEPTION(0);
39746   }
39747
39748   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39749
39750   //argout typemap for const std::string&
39751
39752   return jresult;
39753 }
39754
39755
39756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39757   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39758
39759   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39760   {
39761     try {
39762       delete arg1;
39763     } CALL_CATCH_EXCEPTION();
39764   }
39765
39766 }
39767
39768
39769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
39770   void * jresult ;
39771   Dali::Toolkit::ImageView *arg1 = 0 ;
39772   Dali::Toolkit::ImageView *result = 0 ;
39773
39774   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39775   if (!arg1) {
39776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39777     return 0;
39778   }
39779   {
39780     try {
39781       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
39782     } CALL_CATCH_EXCEPTION(0);
39783   }
39784
39785   jresult = (void *)result;
39786   return jresult;
39787 }
39788
39789
39790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
39791   void * jresult ;
39792   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39793   Dali::Toolkit::ImageView *arg2 = 0 ;
39794   Dali::Toolkit::ImageView *result = 0 ;
39795
39796   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39797   arg2 = (Dali::Toolkit::ImageView *)jarg2;
39798   if (!arg2) {
39799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39800     return 0;
39801   }
39802   {
39803     try {
39804       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
39805     } CALL_CATCH_EXCEPTION(0);
39806   }
39807
39808   jresult = (void *)result;
39809   return jresult;
39810 }
39811
39812
39813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
39814   void * jresult ;
39815   Dali::BaseHandle arg1 ;
39816   Dali::BaseHandle *argp1 ;
39817   Dali::Toolkit::ImageView result;
39818
39819   argp1 = (Dali::BaseHandle *)jarg1;
39820   if (!argp1) {
39821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39822     return 0;
39823   }
39824   arg1 = *argp1;
39825   {
39826     try {
39827       result = Dali::Toolkit::ImageView::DownCast(arg1);
39828     } CALL_CATCH_EXCEPTION(0);
39829   }
39830
39831   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39832   return jresult;
39833 }
39834
39835
39836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
39837   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39838   std::string *arg2 = 0 ;
39839
39840   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39841   if (!jarg2) {
39842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39843     return ;
39844   }
39845   std::string arg2_str(jarg2);
39846   arg2 = &arg2_str;
39847   {
39848     try {
39849       (arg1)->SetImage((std::string const &)*arg2);
39850     } CALL_CATCH_EXCEPTION();
39851   }
39852
39853
39854   //argout typemap for const std::string&
39855
39856 }
39857
39858
39859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
39860   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39861   std::string *arg2 = 0 ;
39862   Dali::ImageDimensions arg3 ;
39863   Dali::ImageDimensions *argp3 ;
39864
39865   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39866   if (!jarg2) {
39867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39868     return ;
39869   }
39870   std::string arg2_str(jarg2);
39871   arg2 = &arg2_str;
39872   argp3 = (Dali::ImageDimensions *)jarg3;
39873   if (!argp3) {
39874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39875     return ;
39876   }
39877   arg3 = *argp3;
39878   {
39879     try {
39880       (arg1)->SetImage((std::string const &)*arg2,arg3);
39881     } CALL_CATCH_EXCEPTION();
39882   }
39883
39884
39885   //argout typemap for const std::string&
39886
39887 }
39888
39889
39890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
39891   int jresult ;
39892   int result;
39893
39894   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
39895   jresult = (int)result;
39896   return jresult;
39897 }
39898
39899
39900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
39901   int jresult ;
39902   int result;
39903
39904   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
39905   jresult = (int)result;
39906   return jresult;
39907 }
39908
39909
39910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
39911   int jresult ;
39912   int result;
39913
39914   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
39915   jresult = (int)result;
39916   return jresult;
39917 }
39918
39919
39920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
39921   int jresult ;
39922   int result;
39923
39924   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
39925   jresult = (int)result;
39926   return jresult;
39927 }
39928
39929
39930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
39931   int jresult ;
39932   int result;
39933
39934   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
39935   jresult = (int)result;
39936   return jresult;
39937 }
39938
39939
39940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
39941   int jresult ;
39942   int result;
39943
39944   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
39945   jresult = (int)result;
39946   return jresult;
39947 }
39948
39949
39950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
39951   int jresult ;
39952   int result;
39953
39954   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
39955   jresult = (int)result;
39956   return jresult;
39957 }
39958
39959
39960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
39961   int jresult ;
39962   int result;
39963
39964   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
39965   jresult = (int)result;
39966   return jresult;
39967 }
39968
39969
39970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
39971   void * jresult ;
39972   Dali::Toolkit::Model3dView::Property *result = 0 ;
39973
39974   {
39975     try {
39976       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
39977     } CALL_CATCH_EXCEPTION(0);
39978   }
39979
39980   jresult = (void *)result;
39981   return jresult;
39982 }
39983
39984
39985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
39986   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
39987
39988   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
39989   {
39990     try {
39991       delete arg1;
39992     } CALL_CATCH_EXCEPTION();
39993   }
39994
39995 }
39996
39997
39998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
39999   void * jresult ;
40000   Dali::Toolkit::Model3dView result;
40001
40002   {
40003     try {
40004       result = Dali::Toolkit::Model3dView::New();
40005     } CALL_CATCH_EXCEPTION(0);
40006   }
40007
40008   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40009   return jresult;
40010 }
40011
40012
40013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
40014   void * jresult ;
40015   std::string *arg1 = 0 ;
40016   std::string *arg2 = 0 ;
40017   std::string *arg3 = 0 ;
40018   Dali::Toolkit::Model3dView result;
40019
40020   if (!jarg1) {
40021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40022     return 0;
40023   }
40024   std::string arg1_str(jarg1);
40025   arg1 = &arg1_str;
40026   if (!jarg2) {
40027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40028     return 0;
40029   }
40030   std::string arg2_str(jarg2);
40031   arg2 = &arg2_str;
40032   if (!jarg3) {
40033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40034     return 0;
40035   }
40036   std::string arg3_str(jarg3);
40037   arg3 = &arg3_str;
40038   {
40039     try {
40040       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40041     } CALL_CATCH_EXCEPTION(0);
40042   }
40043
40044   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40045
40046   //argout typemap for const std::string&
40047
40048
40049   //argout typemap for const std::string&
40050
40051
40052   //argout typemap for const std::string&
40053
40054   return jresult;
40055 }
40056
40057
40058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40059   void * jresult ;
40060   Dali::Toolkit::Model3dView *result = 0 ;
40061
40062   {
40063     try {
40064       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40065     } CALL_CATCH_EXCEPTION(0);
40066   }
40067
40068   jresult = (void *)result;
40069   return jresult;
40070 }
40071
40072
40073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40074   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40075
40076   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40077   {
40078     try {
40079       delete arg1;
40080     } CALL_CATCH_EXCEPTION();
40081   }
40082
40083 }
40084
40085
40086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40087   void * jresult ;
40088   Dali::Toolkit::Model3dView *arg1 = 0 ;
40089   Dali::Toolkit::Model3dView *result = 0 ;
40090
40091   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40092   if (!arg1) {
40093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40094     return 0;
40095   }
40096   {
40097     try {
40098       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40099     } CALL_CATCH_EXCEPTION(0);
40100   }
40101
40102   jresult = (void *)result;
40103   return jresult;
40104 }
40105
40106
40107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40108   void * jresult ;
40109   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40110   Dali::Toolkit::Model3dView *arg2 = 0 ;
40111   Dali::Toolkit::Model3dView *result = 0 ;
40112
40113   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40114   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40115   if (!arg2) {
40116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40117     return 0;
40118   }
40119   {
40120     try {
40121       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40122     } CALL_CATCH_EXCEPTION(0);
40123   }
40124
40125   jresult = (void *)result;
40126   return jresult;
40127 }
40128
40129
40130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40131   void * jresult ;
40132   Dali::BaseHandle arg1 ;
40133   Dali::BaseHandle *argp1 ;
40134   Dali::Toolkit::Model3dView result;
40135
40136   argp1 = (Dali::BaseHandle *)jarg1;
40137   if (!argp1) {
40138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40139     return 0;
40140   }
40141   arg1 = *argp1;
40142   {
40143     try {
40144       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40145     } CALL_CATCH_EXCEPTION(0);
40146   }
40147
40148   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40149   return jresult;
40150 }
40151
40152
40153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40154   int jresult ;
40155   int result;
40156
40157   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40158   jresult = (int)result;
40159   return jresult;
40160 }
40161
40162
40163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40164   int jresult ;
40165   int result;
40166
40167   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40168   jresult = (int)result;
40169   return jresult;
40170 }
40171
40172
40173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40174   int jresult ;
40175   int result;
40176
40177   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40178   jresult = (int)result;
40179   return jresult;
40180 }
40181
40182
40183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40184   int jresult ;
40185   int result;
40186
40187   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40188   jresult = (int)result;
40189   return jresult;
40190 }
40191
40192
40193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40194   int jresult ;
40195   int result;
40196
40197   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40198   jresult = (int)result;
40199   return jresult;
40200 }
40201
40202
40203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40204   int jresult ;
40205   int result;
40206
40207   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40208   jresult = (int)result;
40209   return jresult;
40210 }
40211
40212
40213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40214   int jresult ;
40215   int result;
40216
40217   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40218   jresult = (int)result;
40219   return jresult;
40220 }
40221
40222
40223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40224   int jresult ;
40225   int result;
40226
40227   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40228   jresult = (int)result;
40229   return jresult;
40230 }
40231
40232
40233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40234   int jresult ;
40235   int result;
40236
40237   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40238   jresult = (int)result;
40239   return jresult;
40240 }
40241
40242
40243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40244   void * jresult ;
40245   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40246
40247   {
40248     try {
40249       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40250     } CALL_CATCH_EXCEPTION(0);
40251   }
40252
40253   jresult = (void *)result;
40254   return jresult;
40255 }
40256
40257
40258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40259   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40260
40261   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40262   {
40263     try {
40264       delete arg1;
40265     } CALL_CATCH_EXCEPTION();
40266   }
40267
40268 }
40269
40270
40271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40272   void * jresult ;
40273   Dali::Toolkit::ScrollBar *result = 0 ;
40274
40275   {
40276     try {
40277       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40278     } CALL_CATCH_EXCEPTION(0);
40279   }
40280
40281   jresult = (void *)result;
40282   return jresult;
40283 }
40284
40285
40286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40287   void * jresult ;
40288   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40289   Dali::Toolkit::ScrollBar *result = 0 ;
40290
40291   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40292   if (!arg1) {
40293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40294     return 0;
40295   }
40296   {
40297     try {
40298       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40299     } CALL_CATCH_EXCEPTION(0);
40300   }
40301
40302   jresult = (void *)result;
40303   return jresult;
40304 }
40305
40306
40307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40308   void * jresult ;
40309   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40310   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40311   Dali::Toolkit::ScrollBar *result = 0 ;
40312
40313   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40314   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40315   if (!arg2) {
40316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40317     return 0;
40318   }
40319   {
40320     try {
40321       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40322     } CALL_CATCH_EXCEPTION(0);
40323   }
40324
40325   jresult = (void *)result;
40326   return jresult;
40327 }
40328
40329
40330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40331   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40332
40333   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40334   {
40335     try {
40336       delete arg1;
40337     } CALL_CATCH_EXCEPTION();
40338   }
40339
40340 }
40341
40342
40343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40344   void * jresult ;
40345   Dali::Toolkit::ScrollBar::Direction arg1 ;
40346   Dali::Toolkit::ScrollBar result;
40347
40348   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40349   {
40350     try {
40351       result = Dali::Toolkit::ScrollBar::New(arg1);
40352     } CALL_CATCH_EXCEPTION(0);
40353   }
40354
40355   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40356   return jresult;
40357 }
40358
40359
40360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40361   void * jresult ;
40362   Dali::Toolkit::ScrollBar result;
40363
40364   {
40365     try {
40366       result = Dali::Toolkit::ScrollBar::New();
40367     } CALL_CATCH_EXCEPTION(0);
40368   }
40369
40370   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40371   return jresult;
40372 }
40373
40374
40375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40376   void * jresult ;
40377   Dali::BaseHandle arg1 ;
40378   Dali::BaseHandle *argp1 ;
40379   Dali::Toolkit::ScrollBar result;
40380
40381   argp1 = (Dali::BaseHandle *)jarg1;
40382   if (!argp1) {
40383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40384     return 0;
40385   }
40386   arg1 = *argp1;
40387   {
40388     try {
40389       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40390     } CALL_CATCH_EXCEPTION(0);
40391   }
40392
40393   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40394   return jresult;
40395 }
40396
40397
40398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40399   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40400   Dali::Handle arg2 ;
40401   Dali::Property::Index arg3 ;
40402   Dali::Property::Index arg4 ;
40403   Dali::Property::Index arg5 ;
40404   Dali::Property::Index arg6 ;
40405   Dali::Handle *argp2 ;
40406
40407   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40408   argp2 = (Dali::Handle *)jarg2;
40409   if (!argp2) {
40410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40411     return ;
40412   }
40413   arg2 = *argp2;
40414   arg3 = (Dali::Property::Index)jarg3;
40415   arg4 = (Dali::Property::Index)jarg4;
40416   arg5 = (Dali::Property::Index)jarg5;
40417   arg6 = (Dali::Property::Index)jarg6;
40418   {
40419     try {
40420       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40421     } CALL_CATCH_EXCEPTION();
40422   }
40423
40424 }
40425
40426
40427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40428   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40429   Dali::Actor arg2 ;
40430   Dali::Actor *argp2 ;
40431
40432   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40433   argp2 = (Dali::Actor *)jarg2;
40434   if (!argp2) {
40435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40436     return ;
40437   }
40438   arg2 = *argp2;
40439   {
40440     try {
40441       (arg1)->SetScrollIndicator(arg2);
40442     } CALL_CATCH_EXCEPTION();
40443   }
40444
40445 }
40446
40447
40448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40449   void * jresult ;
40450   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40451   Dali::Actor result;
40452
40453   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40454   {
40455     try {
40456       result = (arg1)->GetScrollIndicator();
40457     } CALL_CATCH_EXCEPTION(0);
40458   }
40459
40460   jresult = new Dali::Actor((const Dali::Actor &)result);
40461   return jresult;
40462 }
40463
40464
40465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40466   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40467   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40468
40469   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40470   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40471   if (!arg2) {
40472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40473     return ;
40474   }
40475   {
40476     try {
40477       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40478     } CALL_CATCH_EXCEPTION();
40479   }
40480
40481 }
40482
40483
40484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40485   void * jresult ;
40486   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40487
40488   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40489   {
40490     try {
40491       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()));
40492     } CALL_CATCH_EXCEPTION(0);
40493   }
40494   return jresult;
40495 }
40496
40497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40498   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40499   Dali::Toolkit::ScrollBar::Direction arg2 ;
40500
40501   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40502   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40503   {
40504     try {
40505       (arg1)->SetScrollDirection(arg2);
40506     } CALL_CATCH_EXCEPTION();
40507   }
40508
40509 }
40510
40511
40512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40513   int jresult ;
40514   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40515   Dali::Toolkit::ScrollBar::Direction result;
40516
40517   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40518   {
40519     try {
40520       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40521     } CALL_CATCH_EXCEPTION(0);
40522   }
40523
40524   jresult = (int)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40530   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40531   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40532
40533   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40534   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40535   {
40536     try {
40537       (arg1)->SetIndicatorHeightPolicy(arg2);
40538     } CALL_CATCH_EXCEPTION();
40539   }
40540
40541 }
40542
40543
40544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40545   int jresult ;
40546   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40547   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40548
40549   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40550   {
40551     try {
40552       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40553     } CALL_CATCH_EXCEPTION(0);
40554   }
40555
40556   jresult = (int)result;
40557   return jresult;
40558 }
40559
40560
40561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40562   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40563   float arg2 ;
40564
40565   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40566   arg2 = (float)jarg2;
40567   {
40568     try {
40569       (arg1)->SetIndicatorFixedHeight(arg2);
40570     } CALL_CATCH_EXCEPTION();
40571   }
40572
40573 }
40574
40575
40576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40577   float jresult ;
40578   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40579   float result;
40580
40581   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40582   {
40583     try {
40584       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40585     } CALL_CATCH_EXCEPTION(0);
40586   }
40587
40588   jresult = result;
40589   return jresult;
40590 }
40591
40592
40593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40594   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40595   float arg2 ;
40596
40597   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40598   arg2 = (float)jarg2;
40599   {
40600     try {
40601       (arg1)->SetIndicatorShowDuration(arg2);
40602     } CALL_CATCH_EXCEPTION();
40603   }
40604
40605 }
40606
40607
40608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40609   float jresult ;
40610   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40611   float result;
40612
40613   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40614   {
40615     try {
40616       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40617     } CALL_CATCH_EXCEPTION(0);
40618   }
40619
40620   jresult = result;
40621   return jresult;
40622 }
40623
40624
40625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40626   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40627   float arg2 ;
40628
40629   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40630   arg2 = (float)jarg2;
40631   {
40632     try {
40633       (arg1)->SetIndicatorHideDuration(arg2);
40634     } CALL_CATCH_EXCEPTION();
40635   }
40636
40637 }
40638
40639
40640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40641   float jresult ;
40642   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40643   float result;
40644
40645   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40646   {
40647     try {
40648       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40649     } CALL_CATCH_EXCEPTION(0);
40650   }
40651
40652   jresult = result;
40653   return jresult;
40654 }
40655
40656
40657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40658   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40659
40660   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40661   {
40662     try {
40663       (arg1)->ShowIndicator();
40664     } CALL_CATCH_EXCEPTION();
40665   }
40666
40667 }
40668
40669
40670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40672
40673   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40674   {
40675     try {
40676       (arg1)->HideIndicator();
40677     } CALL_CATCH_EXCEPTION();
40678   }
40679
40680 }
40681
40682
40683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40684   void * jresult ;
40685   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40686   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40687
40688   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40689   {
40690     try {
40691       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40692     } CALL_CATCH_EXCEPTION(0);
40693   }
40694
40695   jresult = (void *)result;
40696   return jresult;
40697 }
40698
40699
40700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40701   void * jresult ;
40702   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40703   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40704
40705   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40706   {
40707     try {
40708       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40709     } CALL_CATCH_EXCEPTION(0);
40710   }
40711
40712   jresult = (void *)result;
40713   return jresult;
40714 }
40715
40716
40717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40718   int jresult ;
40719   int result;
40720
40721   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40722   jresult = (int)result;
40723   return jresult;
40724 }
40725
40726
40727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40728   int jresult ;
40729   int result;
40730
40731   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40732   jresult = (int)result;
40733   return jresult;
40734 }
40735
40736
40737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40738   int jresult ;
40739   int result;
40740
40741   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40742   jresult = (int)result;
40743   return jresult;
40744 }
40745
40746
40747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40748   int jresult ;
40749   int result;
40750
40751   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40752   jresult = (int)result;
40753   return jresult;
40754 }
40755
40756
40757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40758   int jresult ;
40759   int result;
40760
40761   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40762   jresult = (int)result;
40763   return jresult;
40764 }
40765
40766
40767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
40768   int jresult ;
40769   int result;
40770
40771   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
40772   jresult = (int)result;
40773   return jresult;
40774 }
40775
40776
40777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
40778   int jresult ;
40779   int result;
40780
40781   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
40782   jresult = (int)result;
40783   return jresult;
40784 }
40785
40786
40787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
40788   int jresult ;
40789   int result;
40790
40791   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
40792   jresult = (int)result;
40793   return jresult;
40794 }
40795
40796
40797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
40798   int jresult ;
40799   int result;
40800
40801   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
40802   jresult = (int)result;
40803   return jresult;
40804 }
40805
40806
40807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
40808   int jresult ;
40809   int result;
40810
40811   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
40812   jresult = (int)result;
40813   return jresult;
40814 }
40815
40816
40817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
40818   int jresult ;
40819   int result;
40820
40821   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
40822   jresult = (int)result;
40823   return jresult;
40824 }
40825
40826
40827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
40828   int jresult ;
40829   int result;
40830
40831   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
40832   jresult = (int)result;
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
40838   int jresult ;
40839   int result;
40840
40841   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
40842   jresult = (int)result;
40843   return jresult;
40844 }
40845
40846
40847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
40848   int jresult ;
40849   int result;
40850
40851   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
40852   jresult = (int)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
40858   void * jresult ;
40859   Dali::Toolkit::Scrollable::Property *result = 0 ;
40860
40861   {
40862     try {
40863       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
40864     } CALL_CATCH_EXCEPTION(0);
40865   }
40866
40867   jresult = (void *)result;
40868   return jresult;
40869 }
40870
40871
40872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
40873   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
40874
40875   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
40876   {
40877     try {
40878       delete arg1;
40879     } CALL_CATCH_EXCEPTION();
40880   }
40881
40882 }
40883
40884
40885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
40886   void * jresult ;
40887   Dali::Toolkit::Scrollable *result = 0 ;
40888
40889   {
40890     try {
40891       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
40892     } CALL_CATCH_EXCEPTION(0);
40893   }
40894
40895   jresult = (void *)result;
40896   return jresult;
40897 }
40898
40899
40900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
40901   void * jresult ;
40902   Dali::Toolkit::Scrollable *arg1 = 0 ;
40903   Dali::Toolkit::Scrollable *result = 0 ;
40904
40905   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40906   if (!arg1) {
40907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
40908     return 0;
40909   }
40910   {
40911     try {
40912       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
40913     } CALL_CATCH_EXCEPTION(0);
40914   }
40915
40916   jresult = (void *)result;
40917   return jresult;
40918 }
40919
40920
40921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
40922   void * jresult ;
40923   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40924   Dali::Toolkit::Scrollable *arg2 = 0 ;
40925   Dali::Toolkit::Scrollable *result = 0 ;
40926
40927   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40928   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
40929   if (!arg2) {
40930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
40931     return 0;
40932   }
40933   {
40934     try {
40935       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
40936     } CALL_CATCH_EXCEPTION(0);
40937   }
40938
40939   jresult = (void *)result;
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
40945   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40946
40947   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40948   {
40949     try {
40950       delete arg1;
40951     } CALL_CATCH_EXCEPTION();
40952   }
40953
40954 }
40955
40956
40957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
40958   void * jresult ;
40959   Dali::BaseHandle arg1 ;
40960   Dali::BaseHandle *argp1 ;
40961   Dali::Toolkit::Scrollable result;
40962
40963   argp1 = (Dali::BaseHandle *)jarg1;
40964   if (!argp1) {
40965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40966     return 0;
40967   }
40968   arg1 = *argp1;
40969   {
40970     try {
40971       result = Dali::Toolkit::Scrollable::DownCast(arg1);
40972     } CALL_CATCH_EXCEPTION(0);
40973   }
40974
40975   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
40976   return jresult;
40977 }
40978
40979
40980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
40981   unsigned int jresult ;
40982   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40983   bool result;
40984
40985   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40986   {
40987     try {
40988       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
40989     } CALL_CATCH_EXCEPTION(0);
40990   }
40991
40992   jresult = result;
40993   return jresult;
40994 }
40995
40996
40997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
40998   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40999   bool arg2 ;
41000
41001   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41002   arg2 = jarg2 ? true : false;
41003   {
41004     try {
41005       (arg1)->SetOvershootEnabled(arg2);
41006     } CALL_CATCH_EXCEPTION();
41007   }
41008
41009 }
41010
41011
41012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41013   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41014   Dali::Vector4 *arg2 = 0 ;
41015
41016   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41017   arg2 = (Dali::Vector4 *)jarg2;
41018   if (!arg2) {
41019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41020     return ;
41021   }
41022   {
41023     try {
41024       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41025     } CALL_CATCH_EXCEPTION();
41026   }
41027
41028 }
41029
41030
41031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41032   void * jresult ;
41033   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41034   Dali::Vector4 result;
41035
41036   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41037   {
41038     try {
41039       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41040     } CALL_CATCH_EXCEPTION(0);
41041   }
41042
41043   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41049   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41050   float arg2 ;
41051
41052   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41053   arg2 = (float)jarg2;
41054   {
41055     try {
41056       (arg1)->SetOvershootAnimationSpeed(arg2);
41057     } CALL_CATCH_EXCEPTION();
41058   }
41059
41060 }
41061
41062
41063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41064   float jresult ;
41065   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41066   float result;
41067
41068   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41069   {
41070     try {
41071       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41072     } CALL_CATCH_EXCEPTION(0);
41073   }
41074
41075   jresult = result;
41076   return jresult;
41077 }
41078
41079
41080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41081   void * jresult ;
41082   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41083   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41084
41085   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41086   {
41087     try {
41088       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41089     } CALL_CATCH_EXCEPTION(0);
41090   }
41091
41092   jresult = (void *)result;
41093   return jresult;
41094 }
41095
41096
41097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41098   void * jresult ;
41099   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41100   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41101
41102   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41103   {
41104     try {
41105       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41106     } CALL_CATCH_EXCEPTION(0);
41107   }
41108
41109   jresult = (void *)result;
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41115   void * jresult ;
41116   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41117   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41118
41119   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41120   {
41121     try {
41122       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41123     } CALL_CATCH_EXCEPTION(0);
41124   }
41125
41126   jresult = (void *)result;
41127   return jresult;
41128 }
41129
41130
41131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41132   unsigned int jresult ;
41133   Dali::Toolkit::ControlOrientation::Type arg1 ;
41134   bool result;
41135
41136   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41137   {
41138     try {
41139       result = (bool)Dali::Toolkit::IsVertical(arg1);
41140     } CALL_CATCH_EXCEPTION(0);
41141   }
41142
41143   jresult = result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41149   unsigned int jresult ;
41150   Dali::Toolkit::ControlOrientation::Type arg1 ;
41151   bool result;
41152
41153   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41154   {
41155     try {
41156       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41157     } CALL_CATCH_EXCEPTION(0);
41158   }
41159
41160   jresult = result;
41161   return jresult;
41162 }
41163
41164
41165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41166   void * jresult ;
41167   unsigned int arg1 ;
41168   unsigned int arg2 ;
41169   Dali::Toolkit::ItemRange *result = 0 ;
41170
41171   arg1 = (unsigned int)jarg1;
41172   arg2 = (unsigned int)jarg2;
41173   {
41174     try {
41175       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41176     } CALL_CATCH_EXCEPTION(0);
41177   }
41178
41179   jresult = (void *)result;
41180   return jresult;
41181 }
41182
41183
41184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41185   void * jresult ;
41186   Dali::Toolkit::ItemRange *arg1 = 0 ;
41187   Dali::Toolkit::ItemRange *result = 0 ;
41188
41189   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41190   if (!arg1) {
41191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41192     return 0;
41193   }
41194   {
41195     try {
41196       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41197     } CALL_CATCH_EXCEPTION(0);
41198   }
41199
41200   jresult = (void *)result;
41201   return jresult;
41202 }
41203
41204
41205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41206   void * jresult ;
41207   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41208   Dali::Toolkit::ItemRange *arg2 = 0 ;
41209   Dali::Toolkit::ItemRange *result = 0 ;
41210
41211   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41212   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41213   if (!arg2) {
41214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41215     return 0;
41216   }
41217   {
41218     try {
41219       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41220     } CALL_CATCH_EXCEPTION(0);
41221   }
41222
41223   jresult = (void *)result;
41224   return jresult;
41225 }
41226
41227
41228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41229   unsigned int jresult ;
41230   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41231   unsigned int arg2 ;
41232   bool result;
41233
41234   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41235   arg2 = (unsigned int)jarg2;
41236   {
41237     try {
41238       result = (bool)(arg1)->Within(arg2);
41239     } CALL_CATCH_EXCEPTION(0);
41240   }
41241
41242   jresult = result;
41243   return jresult;
41244 }
41245
41246
41247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41248   void * jresult ;
41249   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41250   Dali::Toolkit::ItemRange *arg2 = 0 ;
41251   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41252
41253   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41254   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41255   if (!arg2) {
41256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41257     return 0;
41258   }
41259   {
41260     try {
41261       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41262     } CALL_CATCH_EXCEPTION(0);
41263   }
41264
41265   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41266   return jresult;
41267 }
41268
41269
41270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41271   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41272   unsigned int arg2 ;
41273
41274   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41275   arg2 = (unsigned int)jarg2;
41276   if (arg1) (arg1)->begin = arg2;
41277 }
41278
41279
41280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41281   unsigned int jresult ;
41282   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41283   unsigned int result;
41284
41285   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41286   result = (unsigned int) ((arg1)->begin);
41287   jresult = result;
41288   return jresult;
41289 }
41290
41291
41292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41293   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41294   unsigned int arg2 ;
41295
41296   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41297   arg2 = (unsigned int)jarg2;
41298   if (arg1) (arg1)->end = arg2;
41299 }
41300
41301
41302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41303   unsigned int jresult ;
41304   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41305   unsigned int result;
41306
41307   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41308   result = (unsigned int) ((arg1)->end);
41309   jresult = result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41315   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41316
41317   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41318   {
41319     try {
41320       delete arg1;
41321     } CALL_CATCH_EXCEPTION();
41322   }
41323
41324 }
41325
41326
41327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41328   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41329
41330   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41331   {
41332     try {
41333       delete arg1;
41334     } CALL_CATCH_EXCEPTION();
41335   }
41336
41337 }
41338
41339
41340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41341   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41342   Dali::Toolkit::ControlOrientation::Type arg2 ;
41343
41344   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41345   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41346   {
41347     try {
41348       (arg1)->SetOrientation(arg2);
41349     } CALL_CATCH_EXCEPTION();
41350   }
41351
41352 }
41353
41354
41355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41356   int jresult ;
41357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41358   Dali::Toolkit::ControlOrientation::Type result;
41359
41360   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41361   {
41362     try {
41363       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41364     } CALL_CATCH_EXCEPTION(0);
41365   }
41366
41367   jresult = (int)result;
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41373   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41374   Dali::Property::Map *arg2 = 0 ;
41375
41376   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41377   arg2 = (Dali::Property::Map *)jarg2;
41378   if (!arg2) {
41379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41380     return ;
41381   }
41382   {
41383     try {
41384       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41385     } CALL_CATCH_EXCEPTION();
41386   }
41387
41388 }
41389
41390
41391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41392   void * jresult ;
41393   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41394   Dali::Property::Map result;
41395
41396   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41397   {
41398     try {
41399       result = (arg1)->GetLayoutProperties();
41400     } CALL_CATCH_EXCEPTION(0);
41401   }
41402
41403   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41404   return jresult;
41405 }
41406
41407
41408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41409   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41410   unsigned int arg2 ;
41411   Dali::Vector3 *arg3 = 0 ;
41412   Dali::Vector3 *arg4 = 0 ;
41413
41414   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41415   arg2 = (unsigned int)jarg2;
41416   arg3 = (Dali::Vector3 *)jarg3;
41417   if (!arg3) {
41418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41419     return ;
41420   }
41421   arg4 = (Dali::Vector3 *)jarg4;
41422   if (!arg4) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41424     return ;
41425   }
41426   {
41427     try {
41428       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41429     } CALL_CATCH_EXCEPTION();
41430   }
41431
41432 }
41433
41434
41435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41436   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41437   Dali::Vector3 *arg2 = 0 ;
41438
41439   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41440   arg2 = (Dali::Vector3 *)jarg2;
41441   if (!arg2) {
41442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41443     return ;
41444   }
41445   {
41446     try {
41447       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41448     } CALL_CATCH_EXCEPTION();
41449   }
41450
41451 }
41452
41453
41454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41455   float jresult ;
41456   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41457   unsigned int arg2 ;
41458   Dali::Vector3 arg3 ;
41459   Dali::Vector3 *argp3 ;
41460   float result;
41461
41462   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41463   arg2 = (unsigned int)jarg2;
41464   argp3 = (Dali::Vector3 *)jarg3;
41465   if (!argp3) {
41466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41467     return 0;
41468   }
41469   arg3 = *argp3;
41470   {
41471     try {
41472       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41473     } CALL_CATCH_EXCEPTION(0);
41474   }
41475
41476   jresult = result;
41477   return jresult;
41478 }
41479
41480
41481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41482   float jresult ;
41483   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41484   float arg2 ;
41485   float result;
41486
41487   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41488   arg2 = (float)jarg2;
41489   {
41490     try {
41491       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41492     } CALL_CATCH_EXCEPTION(0);
41493   }
41494
41495   jresult = result;
41496   return jresult;
41497 }
41498
41499
41500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41501   float jresult ;
41502   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41503   unsigned int arg2 ;
41504   float result;
41505
41506   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41507   arg2 = (unsigned int)jarg2;
41508   {
41509     try {
41510       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41511     } CALL_CATCH_EXCEPTION(0);
41512   }
41513
41514   jresult = result;
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41520   void * jresult ;
41521   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41522   float arg2 ;
41523   Dali::Vector3 arg3 ;
41524   Dali::Vector3 *argp3 ;
41525   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41526
41527   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41528   arg2 = (float)jarg2;
41529   argp3 = (Dali::Vector3 *)jarg3;
41530   if (!argp3) {
41531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41532     return 0;
41533   }
41534   arg3 = *argp3;
41535   {
41536     try {
41537       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41538     } CALL_CATCH_EXCEPTION(0);
41539   }
41540
41541   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41542   return jresult;
41543 }
41544
41545
41546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41547   float jresult ;
41548   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41549   int arg2 ;
41550   float arg3 ;
41551   Dali::Vector3 *arg4 = 0 ;
41552   float result;
41553
41554   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41555   arg2 = (int)jarg2;
41556   arg3 = (float)jarg3;
41557   arg4 = (Dali::Vector3 *)jarg4;
41558   if (!arg4) {
41559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41560     return 0;
41561   }
41562   {
41563     try {
41564       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41565     } CALL_CATCH_EXCEPTION(0);
41566   }
41567
41568   jresult = result;
41569   return jresult;
41570 }
41571
41572
41573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41574   unsigned int jresult ;
41575   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41576   Dali::Vector3 arg2 ;
41577   Dali::Vector3 *argp2 ;
41578   unsigned int result;
41579
41580   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41581   argp2 = (Dali::Vector3 *)jarg2;
41582   if (!argp2) {
41583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41584     return 0;
41585   }
41586   arg2 = *argp2;
41587   {
41588     try {
41589       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41590     } CALL_CATCH_EXCEPTION(0);
41591   }
41592
41593   jresult = result;
41594   return jresult;
41595 }
41596
41597
41598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41599   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41600   unsigned int arg2 ;
41601   Dali::Vector3 *arg3 = 0 ;
41602   Dali::Vector3 *arg4 = 0 ;
41603
41604   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41605   arg2 = (unsigned int)jarg2;
41606   arg3 = (Dali::Vector3 *)jarg3;
41607   if (!arg3) {
41608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41609     return ;
41610   }
41611   arg4 = (Dali::Vector3 *)jarg4;
41612   if (!arg4) {
41613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41614     return ;
41615   }
41616   {
41617     try {
41618       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41619     } CALL_CATCH_EXCEPTION();
41620   }
41621
41622 }
41623
41624
41625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41626   void * jresult ;
41627   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41628   Dali::Degree result;
41629
41630   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41631   {
41632     try {
41633       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41634     } CALL_CATCH_EXCEPTION(0);
41635   }
41636
41637   jresult = new Dali::Degree((const Dali::Degree &)result);
41638   return jresult;
41639 }
41640
41641
41642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41643   float jresult ;
41644   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41645   float result;
41646
41647   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41648   {
41649     try {
41650       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41651     } CALL_CATCH_EXCEPTION(0);
41652   }
41653
41654   jresult = result;
41655   return jresult;
41656 }
41657
41658
41659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
41660   float jresult ;
41661   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41662   float result;
41663
41664   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41665   {
41666     try {
41667       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
41668     } CALL_CATCH_EXCEPTION(0);
41669   }
41670
41671   jresult = result;
41672   return jresult;
41673 }
41674
41675
41676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
41677   float jresult ;
41678   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41679   float result;
41680
41681   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41682   {
41683     try {
41684       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
41685     } CALL_CATCH_EXCEPTION(0);
41686   }
41687
41688   jresult = result;
41689   return jresult;
41690 }
41691
41692
41693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41694   int jresult ;
41695   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41696   int arg2 ;
41697   int arg3 ;
41698   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41699   bool arg5 ;
41700   int result;
41701
41702   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41703   arg2 = (int)jarg2;
41704   arg3 = (int)jarg3;
41705   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41706   arg5 = jarg5 ? true : false;
41707   {
41708     try {
41709       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41710     } CALL_CATCH_EXCEPTION(0);
41711   }
41712
41713   jresult = result;
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41719   float jresult ;
41720   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41721   float result;
41722
41723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41724   {
41725     try {
41726       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41727     } CALL_CATCH_EXCEPTION(0);
41728   }
41729
41730   jresult = result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41736   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41737   Dali::Actor *arg2 = 0 ;
41738   int arg3 ;
41739   Dali::Vector3 *arg4 = 0 ;
41740   Dali::Actor *arg5 = 0 ;
41741
41742   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41743   arg2 = (Dali::Actor *)jarg2;
41744   if (!arg2) {
41745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41746     return ;
41747   }
41748   arg3 = (int)jarg3;
41749   arg4 = (Dali::Vector3 *)jarg4;
41750   if (!arg4) {
41751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41752     return ;
41753   }
41754   arg5 = (Dali::Actor *)jarg5;
41755   if (!arg5) {
41756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41757     return ;
41758   }
41759   {
41760     try {
41761       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41762     } CALL_CATCH_EXCEPTION();
41763   }
41764
41765 }
41766
41767
41768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41769   void * jresult ;
41770   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41771   int arg2 ;
41772   float arg3 ;
41773   Dali::Vector3 *arg4 = 0 ;
41774   Dali::Vector3 result;
41775
41776   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41777   arg2 = (int)jarg2;
41778   arg3 = (float)jarg3;
41779   arg4 = (Dali::Vector3 *)jarg4;
41780   if (!arg4) {
41781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41782     return 0;
41783   }
41784   {
41785     try {
41786       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41787     } CALL_CATCH_EXCEPTION(0);
41788   }
41789
41790   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
41791   return jresult;
41792 }
41793
41794
41795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
41796   void * jresult ;
41797   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
41798   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
41799
41800   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
41801   {
41802     try {
41803       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
41804     } CALL_CATCH_EXCEPTION(0);
41805   }
41806
41807   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
41813   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41814
41815   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41816   {
41817     try {
41818       delete arg1;
41819     } CALL_CATCH_EXCEPTION();
41820   }
41821
41822 }
41823
41824
41825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
41826   unsigned int jresult ;
41827   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41828   unsigned int result;
41829
41830   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41831   {
41832     try {
41833       result = (unsigned int)(arg1)->GetNumberOfItems();
41834     } CALL_CATCH_EXCEPTION(0);
41835   }
41836
41837   jresult = result;
41838   return jresult;
41839 }
41840
41841
41842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
41843   void * jresult ;
41844   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41845   unsigned int arg2 ;
41846   Dali::Actor result;
41847
41848   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41849   arg2 = (unsigned int)jarg2;
41850   {
41851     try {
41852       result = (arg1)->NewItem(arg2);
41853     } CALL_CATCH_EXCEPTION(0);
41854   }
41855
41856   jresult = new Dali::Actor((const Dali::Actor &)result);
41857   return jresult;
41858 }
41859
41860
41861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
41862   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41863   unsigned int arg2 ;
41864   Dali::Actor arg3 ;
41865   Dali::Actor *argp3 ;
41866
41867   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41868   arg2 = (unsigned int)jarg2;
41869   argp3 = (Dali::Actor *)jarg3;
41870   if (!argp3) {
41871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41872     return ;
41873   }
41874   arg3 = *argp3;
41875   {
41876     try {
41877       (arg1)->ItemReleased(arg2,arg3);
41878     } CALL_CATCH_EXCEPTION();
41879   }
41880
41881 }
41882
41883
41884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
41885   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41886   unsigned int arg2 ;
41887   Dali::Actor arg3 ;
41888   Dali::Actor *argp3 ;
41889
41890   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41891   arg2 = (unsigned int)jarg2;
41892   argp3 = (Dali::Actor *)jarg3;
41893   if (!argp3) {
41894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41895     return ;
41896   }
41897   arg3 = *argp3;
41898   {
41899     try {
41900       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
41901     } CALL_CATCH_EXCEPTION();
41902   }
41903
41904 }
41905
41906
41907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
41908   void * jresult ;
41909   Dali::Toolkit::ItemFactory *result = 0 ;
41910
41911   {
41912     try {
41913       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
41914     } CALL_CATCH_EXCEPTION(0);
41915   }
41916
41917   jresult = (void *)result;
41918   return jresult;
41919 }
41920
41921
41922 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) {
41923   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
41924   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
41925   if (director) {
41926     director->swig_connect_director(callback0, callback1, callback2);
41927   }
41928 }
41929
41930
41931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
41932   int jresult ;
41933   int result;
41934
41935   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
41936   jresult = (int)result;
41937   return jresult;
41938 }
41939
41940
41941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
41942   int jresult ;
41943   int result;
41944
41945   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
41946   jresult = (int)result;
41947   return jresult;
41948 }
41949
41950
41951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
41952   int jresult ;
41953   int result;
41954
41955   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
41956   jresult = (int)result;
41957   return jresult;
41958 }
41959
41960
41961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
41962   int jresult ;
41963   int result;
41964
41965   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
41966   jresult = (int)result;
41967   return jresult;
41968 }
41969
41970
41971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
41972   int jresult ;
41973   int result;
41974
41975   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
41976   jresult = (int)result;
41977   return jresult;
41978 }
41979
41980
41981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
41982   int jresult ;
41983   int result;
41984
41985   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
41986   jresult = (int)result;
41987   return jresult;
41988 }
41989
41990
41991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
41992   int jresult ;
41993   int result;
41994
41995   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
41996   jresult = (int)result;
41997   return jresult;
41998 }
41999
42000
42001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42002   int jresult ;
42003   int result;
42004
42005   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42006   jresult = (int)result;
42007   return jresult;
42008 }
42009
42010
42011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42012   int jresult ;
42013   int result;
42014
42015   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42016   jresult = (int)result;
42017   return jresult;
42018 }
42019
42020
42021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42022   int jresult ;
42023   int result;
42024
42025   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42026   jresult = (int)result;
42027   return jresult;
42028 }
42029
42030
42031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42032   int jresult ;
42033   int result;
42034
42035   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42036   jresult = (int)result;
42037   return jresult;
42038 }
42039
42040
42041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42042   void * jresult ;
42043   Dali::Toolkit::ItemView::Property *result = 0 ;
42044
42045   {
42046     try {
42047       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42048     } CALL_CATCH_EXCEPTION(0);
42049   }
42050
42051   jresult = (void *)result;
42052   return jresult;
42053 }
42054
42055
42056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42057   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42058
42059   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42060   {
42061     try {
42062       delete arg1;
42063     } CALL_CATCH_EXCEPTION();
42064   }
42065
42066 }
42067
42068
42069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42070   void * jresult ;
42071   Dali::Toolkit::ItemView *result = 0 ;
42072
42073   {
42074     try {
42075       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42076     } CALL_CATCH_EXCEPTION(0);
42077   }
42078
42079   jresult = (void *)result;
42080   return jresult;
42081 }
42082
42083
42084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42085   void * jresult ;
42086   Dali::Toolkit::ItemView *arg1 = 0 ;
42087   Dali::Toolkit::ItemView *result = 0 ;
42088
42089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42090   if (!arg1) {
42091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42092     return 0;
42093   }
42094   {
42095     try {
42096       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42097     } CALL_CATCH_EXCEPTION(0);
42098   }
42099
42100   jresult = (void *)result;
42101   return jresult;
42102 }
42103
42104
42105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42106   void * jresult ;
42107   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42108   Dali::Toolkit::ItemView *arg2 = 0 ;
42109   Dali::Toolkit::ItemView *result = 0 ;
42110
42111   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42112   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42113   if (!arg2) {
42114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42115     return 0;
42116   }
42117   {
42118     try {
42119       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42120     } CALL_CATCH_EXCEPTION(0);
42121   }
42122
42123   jresult = (void *)result;
42124   return jresult;
42125 }
42126
42127
42128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42130
42131   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42132   {
42133     try {
42134       delete arg1;
42135     } CALL_CATCH_EXCEPTION();
42136   }
42137
42138 }
42139
42140
42141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42142   void * jresult ;
42143   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42144   Dali::Toolkit::ItemView result;
42145
42146   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42147   if (!arg1) {
42148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42149     return 0;
42150   }
42151   {
42152     try {
42153       result = Dali::Toolkit::ItemView::New(*arg1);
42154     } CALL_CATCH_EXCEPTION(0);
42155   }
42156
42157   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42158   return jresult;
42159 }
42160
42161
42162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42163   void * jresult ;
42164   Dali::BaseHandle arg1 ;
42165   Dali::BaseHandle *argp1 ;
42166   Dali::Toolkit::ItemView result;
42167
42168   argp1 = (Dali::BaseHandle *)jarg1;
42169   if (!argp1) {
42170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42171     return 0;
42172   }
42173   arg1 = *argp1;
42174   {
42175     try {
42176       result = Dali::Toolkit::ItemView::DownCast(arg1);
42177     } CALL_CATCH_EXCEPTION(0);
42178   }
42179
42180   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42181   return jresult;
42182 }
42183
42184
42185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42186   unsigned int jresult ;
42187   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42188   unsigned int result;
42189
42190   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42191   {
42192     try {
42193       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42194     } CALL_CATCH_EXCEPTION(0);
42195   }
42196
42197   jresult = result;
42198   return jresult;
42199 }
42200
42201
42202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42204   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42205
42206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42207   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42208   if (!arg2) {
42209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42210     return ;
42211   }
42212   {
42213     try {
42214       (arg1)->AddLayout(*arg2);
42215     } CALL_CATCH_EXCEPTION();
42216   }
42217
42218 }
42219
42220
42221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42222   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42223   unsigned int arg2 ;
42224
42225   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42226   arg2 = (unsigned int)jarg2;
42227   {
42228     try {
42229       (arg1)->RemoveLayout(arg2);
42230     } CALL_CATCH_EXCEPTION();
42231   }
42232
42233 }
42234
42235
42236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42237   void * jresult ;
42238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42239   unsigned int arg2 ;
42240   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42241
42242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42243   arg2 = (unsigned int)jarg2;
42244   {
42245     try {
42246       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42247     } CALL_CATCH_EXCEPTION(0);
42248   }
42249
42250   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42251   return jresult;
42252 }
42253
42254
42255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42256   void * jresult ;
42257   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42258   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42259
42260   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42261   {
42262     try {
42263       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42264     } CALL_CATCH_EXCEPTION(0);
42265   }
42266
42267   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42268   return jresult;
42269 }
42270
42271
42272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42273   float jresult ;
42274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42275   Dali::Toolkit::ItemId arg2 ;
42276   float result;
42277
42278   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42279   arg2 = (Dali::Toolkit::ItemId)jarg2;
42280   {
42281     try {
42282       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42283     } CALL_CATCH_EXCEPTION(0);
42284   }
42285
42286   jresult = result;
42287   return jresult;
42288 }
42289
42290
42291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42292   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42293   unsigned int arg2 ;
42294   Dali::Vector3 arg3 ;
42295   float arg4 ;
42296   Dali::Vector3 *argp3 ;
42297
42298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42299   arg2 = (unsigned int)jarg2;
42300   argp3 = (Dali::Vector3 *)jarg3;
42301   if (!argp3) {
42302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42303     return ;
42304   }
42305   arg3 = *argp3;
42306   arg4 = (float)jarg4;
42307   {
42308     try {
42309       (arg1)->ActivateLayout(arg2,arg3,arg4);
42310     } CALL_CATCH_EXCEPTION();
42311   }
42312
42313 }
42314
42315
42316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42317   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42318
42319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42320   {
42321     try {
42322       (arg1)->DeactivateCurrentLayout();
42323     } CALL_CATCH_EXCEPTION();
42324   }
42325
42326 }
42327
42328
42329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42330   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42331   float arg2 ;
42332
42333   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42334   arg2 = (float)jarg2;
42335   {
42336     try {
42337       (arg1)->SetMinimumSwipeSpeed(arg2);
42338     } CALL_CATCH_EXCEPTION();
42339   }
42340
42341 }
42342
42343
42344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42345   float jresult ;
42346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42347   float result;
42348
42349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42350   {
42351     try {
42352       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42353     } CALL_CATCH_EXCEPTION(0);
42354   }
42355
42356   jresult = result;
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42362   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42363   float arg2 ;
42364
42365   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42366   arg2 = (float)jarg2;
42367   {
42368     try {
42369       (arg1)->SetMinimumSwipeDistance(arg2);
42370     } CALL_CATCH_EXCEPTION();
42371   }
42372
42373 }
42374
42375
42376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42377   float jresult ;
42378   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42379   float result;
42380
42381   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42382   {
42383     try {
42384       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42385     } CALL_CATCH_EXCEPTION(0);
42386   }
42387
42388   jresult = result;
42389   return jresult;
42390 }
42391
42392
42393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42394   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42395   float arg2 ;
42396
42397   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42398   arg2 = (float)jarg2;
42399   {
42400     try {
42401       (arg1)->SetWheelScrollDistanceStep(arg2);
42402     } CALL_CATCH_EXCEPTION();
42403   }
42404
42405 }
42406
42407
42408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42409   float jresult ;
42410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42411   float result;
42412
42413   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42414   {
42415     try {
42416       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42417     } CALL_CATCH_EXCEPTION(0);
42418   }
42419
42420   jresult = result;
42421   return jresult;
42422 }
42423
42424
42425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42426   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42427   bool arg2 ;
42428
42429   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42430   arg2 = jarg2 ? true : false;
42431   {
42432     try {
42433       (arg1)->SetAnchoring(arg2);
42434     } CALL_CATCH_EXCEPTION();
42435   }
42436
42437 }
42438
42439 //// ========================= end of part 3 =============================
42440
42441 //// ========================== start part 4 ===============================
42442
42443
42444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42445   unsigned int jresult ;
42446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42447   bool result;
42448
42449   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42450   {
42451     try {
42452       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42453     } CALL_CATCH_EXCEPTION(0);
42454   }
42455
42456   jresult = result;
42457   return jresult;
42458 }
42459
42460
42461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42462   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42463   float arg2 ;
42464
42465   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42466   arg2 = (float)jarg2;
42467   {
42468     try {
42469       (arg1)->SetAnchoringDuration(arg2);
42470     } CALL_CATCH_EXCEPTION();
42471   }
42472
42473 }
42474
42475
42476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42477   float jresult ;
42478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42479   float result;
42480
42481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42482   {
42483     try {
42484       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42485     } CALL_CATCH_EXCEPTION(0);
42486   }
42487
42488   jresult = result;
42489   return jresult;
42490 }
42491
42492
42493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42494   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42495   Dali::Toolkit::ItemId arg2 ;
42496   float arg3 ;
42497
42498   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42499   arg2 = (Dali::Toolkit::ItemId)jarg2;
42500   arg3 = (float)jarg3;
42501   {
42502     try {
42503       (arg1)->ScrollToItem(arg2,arg3);
42504     } CALL_CATCH_EXCEPTION();
42505   }
42506
42507 }
42508
42509
42510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42512   float arg2 ;
42513
42514   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42515   arg2 = (float)jarg2;
42516   {
42517     try {
42518       (arg1)->SetRefreshInterval(arg2);
42519     } CALL_CATCH_EXCEPTION();
42520   }
42521
42522 }
42523
42524
42525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42526   float jresult ;
42527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42528   float result;
42529
42530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42531   {
42532     try {
42533       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42534     } CALL_CATCH_EXCEPTION(0);
42535   }
42536
42537   jresult = result;
42538   return jresult;
42539 }
42540
42541
42542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42544
42545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42546   {
42547     try {
42548       (arg1)->Refresh();
42549     } CALL_CATCH_EXCEPTION();
42550   }
42551
42552 }
42553
42554
42555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42556   void * jresult ;
42557   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42558   Dali::Toolkit::ItemId arg2 ;
42559   Dali::Actor result;
42560
42561   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42562   arg2 = (Dali::Toolkit::ItemId)jarg2;
42563   {
42564     try {
42565       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42566     } CALL_CATCH_EXCEPTION(0);
42567   }
42568
42569   jresult = new Dali::Actor((const Dali::Actor &)result);
42570   return jresult;
42571 }
42572
42573
42574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42575   unsigned int jresult ;
42576   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42577   Dali::Actor arg2 ;
42578   Dali::Actor *argp2 ;
42579   Dali::Toolkit::ItemId result;
42580
42581   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42582   argp2 = (Dali::Actor *)jarg2;
42583   if (!argp2) {
42584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42585     return 0;
42586   }
42587   arg2 = *argp2;
42588   {
42589     try {
42590       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42591     } CALL_CATCH_EXCEPTION(0);
42592   }
42593
42594   jresult = result;
42595   return jresult;
42596 }
42597
42598
42599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42600   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42601   Dali::Toolkit::Item arg2 ;
42602   float arg3 ;
42603   Dali::Toolkit::Item *argp2 ;
42604
42605   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42606   argp2 = (Dali::Toolkit::Item *)jarg2;
42607   if (!argp2) {
42608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42609     return ;
42610   }
42611   arg2 = *argp2;
42612   arg3 = (float)jarg3;
42613   {
42614     try {
42615       (arg1)->InsertItem(arg2,arg3);
42616     } CALL_CATCH_EXCEPTION();
42617   }
42618
42619 }
42620
42621
42622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42623   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42624   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42625   float arg3 ;
42626
42627   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42628   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42629   if (!arg2) {
42630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42631     return ;
42632   }
42633   arg3 = (float)jarg3;
42634   {
42635     try {
42636       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42637     } CALL_CATCH_EXCEPTION();
42638   }
42639
42640 }
42641
42642
42643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42644   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42645   Dali::Toolkit::ItemId arg2 ;
42646   float arg3 ;
42647
42648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42649   arg2 = (Dali::Toolkit::ItemId)jarg2;
42650   arg3 = (float)jarg3;
42651   {
42652     try {
42653       (arg1)->RemoveItem(arg2,arg3);
42654     } CALL_CATCH_EXCEPTION();
42655   }
42656
42657 }
42658
42659
42660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42662   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42663   float arg3 ;
42664
42665   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42666   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42667   if (!arg2) {
42668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42669     return ;
42670   }
42671   arg3 = (float)jarg3;
42672   {
42673     try {
42674       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42675     } CALL_CATCH_EXCEPTION();
42676   }
42677
42678 }
42679
42680
42681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42682   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42683   Dali::Toolkit::Item arg2 ;
42684   float arg3 ;
42685   Dali::Toolkit::Item *argp2 ;
42686
42687   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42688   argp2 = (Dali::Toolkit::Item *)jarg2;
42689   if (!argp2) {
42690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42691     return ;
42692   }
42693   arg2 = *argp2;
42694   arg3 = (float)jarg3;
42695   {
42696     try {
42697       (arg1)->ReplaceItem(arg2,arg3);
42698     } CALL_CATCH_EXCEPTION();
42699   }
42700
42701 }
42702
42703
42704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42705   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42706   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42707   float arg3 ;
42708
42709   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42710   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42711   if (!arg2) {
42712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42713     return ;
42714   }
42715   arg3 = (float)jarg3;
42716   {
42717     try {
42718       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42719     } CALL_CATCH_EXCEPTION();
42720   }
42721
42722 }
42723
42724
42725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42727   Dali::Vector3 *arg2 = 0 ;
42728
42729   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42730   arg2 = (Dali::Vector3 *)jarg2;
42731   if (!arg2) {
42732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42733     return ;
42734   }
42735   {
42736     try {
42737       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42738     } CALL_CATCH_EXCEPTION();
42739   }
42740
42741 }
42742
42743
42744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42745   void * jresult ;
42746   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42747   Dali::Vector3 result;
42748
42749   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42750   {
42751     try {
42752       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42753     } CALL_CATCH_EXCEPTION(0);
42754   }
42755
42756   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42757   return jresult;
42758 }
42759
42760
42761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
42762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42763   Dali::Vector3 *arg2 = 0 ;
42764
42765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42766   arg2 = (Dali::Vector3 *)jarg2;
42767   if (!arg2) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42769     return ;
42770   }
42771   {
42772     try {
42773       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
42774     } CALL_CATCH_EXCEPTION();
42775   }
42776
42777 }
42778
42779
42780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
42781   void * jresult ;
42782   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42783   Dali::Vector3 result;
42784
42785   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42786   {
42787     try {
42788       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
42789     } CALL_CATCH_EXCEPTION(0);
42790   }
42791
42792   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
42798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42799   Dali::Toolkit::ItemRange *arg2 = 0 ;
42800
42801   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42802   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42803   if (!arg2) {
42804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
42805     return ;
42806   }
42807   {
42808     try {
42809       (arg1)->GetItemsRange(*arg2);
42810     } CALL_CATCH_EXCEPTION();
42811   }
42812
42813 }
42814
42815
42816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
42817   void * jresult ;
42818   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42819   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
42820
42821   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42822   {
42823     try {
42824       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
42825     } CALL_CATCH_EXCEPTION(0);
42826   }
42827
42828   jresult = (void *)result;
42829   return jresult;
42830 }
42831
42832
42833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
42834   Dali::Vector3 *arg1 = 0 ;
42835   PropertyInputContainer *arg2 = 0 ;
42836
42837   arg1 = (Dali::Vector3 *)jarg1;
42838   if (!arg1) {
42839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42840     return ;
42841   }
42842   arg2 = (PropertyInputContainer *)jarg2;
42843   if (!arg2) {
42844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
42845     return ;
42846   }
42847   {
42848     try {
42849       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
42850     } CALL_CATCH_EXCEPTION();
42851   }
42852
42853 }
42854
42855
42856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
42857   Dali::Vector3 *arg1 = 0 ;
42858   PropertyInputContainer *arg2 = 0 ;
42859
42860   arg1 = (Dali::Vector3 *)jarg1;
42861   if (!arg1) {
42862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42863     return ;
42864   }
42865   arg2 = (PropertyInputContainer *)jarg2;
42866   if (!arg2) {
42867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
42868     return ;
42869   }
42870   {
42871     try {
42872       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
42873     } CALL_CATCH_EXCEPTION();
42874   }
42875
42876 }
42877
42878
42879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
42880   void * jresult ;
42881   Dali::Toolkit::ScrollViewEffect *result = 0 ;
42882
42883   {
42884     try {
42885       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
42886     } CALL_CATCH_EXCEPTION(0);
42887   }
42888
42889   jresult = (void *)result;
42890   return jresult;
42891 }
42892
42893
42894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
42895   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
42896
42897   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
42898   {
42899     try {
42900       delete arg1;
42901     } CALL_CATCH_EXCEPTION();
42902   }
42903
42904 }
42905
42906
42907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
42908   void * jresult ;
42909   Dali::Path arg1 ;
42910   Dali::Vector3 *arg2 = 0 ;
42911   Dali::Property::Index arg3 ;
42912   Dali::Vector3 *arg4 = 0 ;
42913   unsigned int arg5 ;
42914   Dali::Path *argp1 ;
42915   Dali::Toolkit::ScrollViewPagePathEffect result;
42916
42917   argp1 = (Dali::Path *)jarg1;
42918   if (!argp1) {
42919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
42920     return 0;
42921   }
42922   arg1 = *argp1;
42923   arg2 = (Dali::Vector3 *)jarg2;
42924   if (!arg2) {
42925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42926     return 0;
42927   }
42928   arg3 = (Dali::Property::Index)jarg3;
42929   arg4 = (Dali::Vector3 *)jarg4;
42930   if (!arg4) {
42931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42932     return 0;
42933   }
42934   arg5 = (unsigned int)jarg5;
42935   {
42936     try {
42937       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
42938     } CALL_CATCH_EXCEPTION(0);
42939   }
42940
42941   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
42942   return jresult;
42943 }
42944
42945
42946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
42947   void * jresult ;
42948   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
42949
42950   {
42951     try {
42952       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
42953     } CALL_CATCH_EXCEPTION(0);
42954   }
42955
42956   jresult = (void *)result;
42957   return jresult;
42958 }
42959
42960
42961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
42962   void * jresult ;
42963   Dali::BaseHandle arg1 ;
42964   Dali::BaseHandle *argp1 ;
42965   Dali::Toolkit::ScrollViewPagePathEffect result;
42966
42967   argp1 = (Dali::BaseHandle *)jarg1;
42968   if (!argp1) {
42969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42970     return 0;
42971   }
42972   arg1 = *argp1;
42973   {
42974     try {
42975       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
42976     } CALL_CATCH_EXCEPTION(0);
42977   }
42978
42979   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
42980   return jresult;
42981 }
42982
42983
42984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
42985   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
42986   Dali::Actor arg2 ;
42987   unsigned int arg3 ;
42988   Dali::Actor *argp2 ;
42989
42990   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
42991   argp2 = (Dali::Actor *)jarg2;
42992   if (!argp2) {
42993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42994     return ;
42995   }
42996   arg2 = *argp2;
42997   arg3 = (unsigned int)jarg3;
42998   {
42999     try {
43000       (arg1)->ApplyToPage(arg2,arg3);
43001     } CALL_CATCH_EXCEPTION();
43002   }
43003
43004 }
43005
43006
43007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43008   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43009
43010   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43011   {
43012     try {
43013       delete arg1;
43014     } CALL_CATCH_EXCEPTION();
43015   }
43016
43017 }
43018
43019
43020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43021   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43022   Dali::Toolkit::ClampState arg2 ;
43023
43024   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43025   arg2 = (Dali::Toolkit::ClampState)jarg2;
43026   if (arg1) (arg1)->x = arg2;
43027 }
43028
43029
43030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43031   int jresult ;
43032   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43033   Dali::Toolkit::ClampState result;
43034
43035   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43036   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43037   jresult = (int)result;
43038   return jresult;
43039 }
43040
43041
43042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43043   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43044   Dali::Toolkit::ClampState arg2 ;
43045
43046   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43047   arg2 = (Dali::Toolkit::ClampState)jarg2;
43048   if (arg1) (arg1)->y = arg2;
43049 }
43050
43051
43052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43053   int jresult ;
43054   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43055   Dali::Toolkit::ClampState result;
43056
43057   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43058   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43059   jresult = (int)result;
43060   return jresult;
43061 }
43062
43063
43064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43065   void * jresult ;
43066   Dali::Toolkit::ClampState2D *result = 0 ;
43067
43068   {
43069     try {
43070       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43071     } CALL_CATCH_EXCEPTION(0);
43072   }
43073
43074   jresult = (void *)result;
43075   return jresult;
43076 }
43077
43078
43079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43080   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43081
43082   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43083   {
43084     try {
43085       delete arg1;
43086     } CALL_CATCH_EXCEPTION();
43087   }
43088
43089 }
43090
43091
43092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43093   void * jresult ;
43094   float arg1 ;
43095   float arg2 ;
43096   bool arg3 ;
43097   Dali::Toolkit::RulerDomain *result = 0 ;
43098
43099   arg1 = (float)jarg1;
43100   arg2 = (float)jarg2;
43101   arg3 = jarg3 ? true : false;
43102   {
43103     try {
43104       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43105     } CALL_CATCH_EXCEPTION(0);
43106   }
43107
43108   jresult = (void *)result;
43109   return jresult;
43110 }
43111
43112
43113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43114   void * jresult ;
43115   float arg1 ;
43116   float arg2 ;
43117   Dali::Toolkit::RulerDomain *result = 0 ;
43118
43119   arg1 = (float)jarg1;
43120   arg2 = (float)jarg2;
43121   {
43122     try {
43123       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43124     } CALL_CATCH_EXCEPTION(0);
43125   }
43126
43127   jresult = (void *)result;
43128   return jresult;
43129 }
43130
43131
43132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43133   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43134   float arg2 ;
43135
43136   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43137   arg2 = (float)jarg2;
43138   if (arg1) (arg1)->min = arg2;
43139 }
43140
43141
43142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43143   float jresult ;
43144   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43145   float result;
43146
43147   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43148   result = (float) ((arg1)->min);
43149   jresult = result;
43150   return jresult;
43151 }
43152
43153
43154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43155   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43156   float arg2 ;
43157
43158   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43159   arg2 = (float)jarg2;
43160   if (arg1) (arg1)->max = arg2;
43161 }
43162
43163
43164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43165   float jresult ;
43166   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43167   float result;
43168
43169   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43170   result = (float) ((arg1)->max);
43171   jresult = result;
43172   return jresult;
43173 }
43174
43175
43176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43177   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43178   bool arg2 ;
43179
43180   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43181   arg2 = jarg2 ? true : false;
43182   if (arg1) (arg1)->enabled = arg2;
43183 }
43184
43185
43186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43187   unsigned int jresult ;
43188   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43189   bool result;
43190
43191   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43192   result = (bool) ((arg1)->enabled);
43193   jresult = result;
43194   return jresult;
43195 }
43196
43197
43198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43199   float jresult ;
43200   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43201   float arg2 ;
43202   float arg3 ;
43203   float arg4 ;
43204   float result;
43205
43206   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43207   arg2 = (float)jarg2;
43208   arg3 = (float)jarg3;
43209   arg4 = (float)jarg4;
43210   {
43211     try {
43212       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43213     } CALL_CATCH_EXCEPTION(0);
43214   }
43215
43216   jresult = result;
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43222   float jresult ;
43223   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43224   float arg2 ;
43225   float arg3 ;
43226   float result;
43227
43228   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43229   arg2 = (float)jarg2;
43230   arg3 = (float)jarg3;
43231   {
43232     try {
43233       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43234     } CALL_CATCH_EXCEPTION(0);
43235   }
43236
43237   jresult = result;
43238   return jresult;
43239 }
43240
43241
43242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43243   float jresult ;
43244   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43245   float arg2 ;
43246   float result;
43247
43248   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43249   arg2 = (float)jarg2;
43250   {
43251     try {
43252       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43253     } CALL_CATCH_EXCEPTION(0);
43254   }
43255
43256   jresult = result;
43257   return jresult;
43258 }
43259
43260
43261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43262   float jresult ;
43263   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43264   float arg2 ;
43265   float arg3 ;
43266   float arg4 ;
43267   Dali::Toolkit::ClampState *arg5 = 0 ;
43268   float result;
43269
43270   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43271   arg2 = (float)jarg2;
43272   arg3 = (float)jarg3;
43273   arg4 = (float)jarg4;
43274   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43275   if (!arg5) {
43276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43277     return 0;
43278   }
43279   {
43280     try {
43281       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43282     } CALL_CATCH_EXCEPTION(0);
43283   }
43284
43285   jresult = result;
43286   return jresult;
43287 }
43288
43289
43290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43291   float jresult ;
43292   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43293   float result;
43294
43295   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43296   {
43297     try {
43298       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43299     } CALL_CATCH_EXCEPTION(0);
43300   }
43301
43302   jresult = result;
43303   return jresult;
43304 }
43305
43306
43307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43308   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43309
43310   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43311   {
43312     try {
43313       delete arg1;
43314     } CALL_CATCH_EXCEPTION();
43315   }
43316
43317 }
43318
43319
43320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43321   float jresult ;
43322   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43323   float arg2 ;
43324   float arg3 ;
43325   float result;
43326
43327   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43328   arg2 = (float)jarg2;
43329   arg3 = (float)jarg3;
43330   {
43331     try {
43332       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43333     } CALL_CATCH_EXCEPTION(0);
43334   }
43335
43336   jresult = result;
43337   return jresult;
43338 }
43339
43340
43341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43342   float jresult ;
43343   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43344   float arg2 ;
43345   float result;
43346
43347   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43348   arg2 = (float)jarg2;
43349   {
43350     try {
43351       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43352     } CALL_CATCH_EXCEPTION(0);
43353   }
43354
43355   jresult = result;
43356   return jresult;
43357 }
43358
43359
43360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43361   float jresult ;
43362   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43363   unsigned int arg2 ;
43364   unsigned int *arg3 = 0 ;
43365   bool arg4 ;
43366   float result;
43367
43368   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43369   arg2 = (unsigned int)jarg2;
43370   arg3 = (unsigned int *)jarg3;
43371   arg4 = jarg4 ? true : false;
43372   {
43373     try {
43374       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43375     } CALL_CATCH_EXCEPTION(0);
43376   }
43377
43378   jresult = result;
43379   return jresult;
43380 }
43381
43382
43383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43384   unsigned int jresult ;
43385   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43386   float arg2 ;
43387   bool arg3 ;
43388   unsigned int result;
43389
43390   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43391   arg2 = (float)jarg2;
43392   arg3 = jarg3 ? true : false;
43393   {
43394     try {
43395       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43396     } CALL_CATCH_EXCEPTION(0);
43397   }
43398
43399   jresult = result;
43400   return jresult;
43401 }
43402
43403
43404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43405   unsigned int jresult ;
43406   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43407   unsigned int result;
43408
43409   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43410   {
43411     try {
43412       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43413     } CALL_CATCH_EXCEPTION(0);
43414   }
43415
43416   jresult = result;
43417   return jresult;
43418 }
43419
43420
43421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43422   int jresult ;
43423   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43424   Dali::Toolkit::Ruler::RulerType result;
43425
43426   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43427   {
43428     try {
43429       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43430     } CALL_CATCH_EXCEPTION(0);
43431   }
43432
43433   jresult = (int)result;
43434   return jresult;
43435 }
43436
43437
43438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43439   unsigned int jresult ;
43440   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43441   bool result;
43442
43443   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43444   {
43445     try {
43446       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43447     } CALL_CATCH_EXCEPTION(0);
43448   }
43449
43450   jresult = result;
43451   return jresult;
43452 }
43453
43454
43455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43456   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43457
43458   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43459   {
43460     try {
43461       (arg1)->Enable();
43462     } CALL_CATCH_EXCEPTION();
43463   }
43464
43465 }
43466
43467
43468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43469   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43470
43471   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43472   {
43473     try {
43474       (arg1)->Disable();
43475     } CALL_CATCH_EXCEPTION();
43476   }
43477
43478 }
43479
43480
43481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43482   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43483   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43484   Dali::Toolkit::RulerDomain *argp2 ;
43485
43486   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43487   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43488   if (!argp2) {
43489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43490     return ;
43491   }
43492   arg2 = *argp2;
43493   {
43494     try {
43495       (arg1)->SetDomain(arg2);
43496     } CALL_CATCH_EXCEPTION();
43497   }
43498
43499 }
43500
43501
43502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43503   void * jresult ;
43504   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43505   Dali::Toolkit::RulerDomain *result = 0 ;
43506
43507   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43508   {
43509     try {
43510       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43511     } CALL_CATCH_EXCEPTION(0);
43512   }
43513
43514   jresult = (void *)result;
43515   return jresult;
43516 }
43517
43518
43519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43520   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43521
43522   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43523   {
43524     try {
43525       (arg1)->DisableDomain();
43526     } CALL_CATCH_EXCEPTION();
43527   }
43528
43529 }
43530
43531
43532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43533   float jresult ;
43534   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43535   float arg2 ;
43536   float arg3 ;
43537   float arg4 ;
43538   float result;
43539
43540   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43541   arg2 = (float)jarg2;
43542   arg3 = (float)jarg3;
43543   arg4 = (float)jarg4;
43544   {
43545     try {
43546       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43547     } CALL_CATCH_EXCEPTION(0);
43548   }
43549
43550   jresult = result;
43551   return jresult;
43552 }
43553
43554
43555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43556   float jresult ;
43557   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43558   float arg2 ;
43559   float arg3 ;
43560   float result;
43561
43562   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43563   arg2 = (float)jarg2;
43564   arg3 = (float)jarg3;
43565   {
43566     try {
43567       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43568     } CALL_CATCH_EXCEPTION(0);
43569   }
43570
43571   jresult = result;
43572   return jresult;
43573 }
43574
43575
43576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43577   float jresult ;
43578   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43579   float arg2 ;
43580   float result;
43581
43582   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43583   arg2 = (float)jarg2;
43584   {
43585     try {
43586       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43587     } CALL_CATCH_EXCEPTION(0);
43588   }
43589
43590   jresult = result;
43591   return jresult;
43592 }
43593
43594
43595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43596   float jresult ;
43597   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43598   float arg2 ;
43599   float arg3 ;
43600   float arg4 ;
43601   Dali::Toolkit::ClampState *arg5 = 0 ;
43602   float result;
43603
43604   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43605   arg2 = (float)jarg2;
43606   arg3 = (float)jarg3;
43607   arg4 = (float)jarg4;
43608   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43609   if (!arg5) {
43610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43611     return 0;
43612   }
43613   {
43614     try {
43615       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43616     } CALL_CATCH_EXCEPTION(0);
43617   }
43618
43619   jresult = result;
43620   return jresult;
43621 }
43622
43623
43624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43625   float jresult ;
43626   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43627   float arg2 ;
43628   float arg3 ;
43629   float arg4 ;
43630   float arg5 ;
43631   float result;
43632
43633   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43634   arg2 = (float)jarg2;
43635   arg3 = (float)jarg3;
43636   arg4 = (float)jarg4;
43637   arg5 = (float)jarg5;
43638   {
43639     try {
43640       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43641     } CALL_CATCH_EXCEPTION(0);
43642   }
43643
43644   jresult = result;
43645   return jresult;
43646 }
43647
43648
43649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43650   float jresult ;
43651   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43652   float arg2 ;
43653   float arg3 ;
43654   float arg4 ;
43655   float result;
43656
43657   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43658   arg2 = (float)jarg2;
43659   arg3 = (float)jarg3;
43660   arg4 = (float)jarg4;
43661   {
43662     try {
43663       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43664     } CALL_CATCH_EXCEPTION(0);
43665   }
43666
43667   jresult = result;
43668   return jresult;
43669 }
43670
43671
43672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43673   float jresult ;
43674   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43675   float arg2 ;
43676   float arg3 ;
43677   float result;
43678
43679   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43680   arg2 = (float)jarg2;
43681   arg3 = (float)jarg3;
43682   {
43683     try {
43684       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43685     } CALL_CATCH_EXCEPTION(0);
43686   }
43687
43688   jresult = result;
43689   return jresult;
43690 }
43691
43692
43693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43694   float jresult ;
43695   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43696   float arg2 ;
43697   float result;
43698
43699   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43700   arg2 = (float)jarg2;
43701   {
43702     try {
43703       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43704     } CALL_CATCH_EXCEPTION(0);
43705   }
43706
43707   jresult = result;
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43713   float jresult ;
43714   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43715   float arg2 ;
43716   float arg3 ;
43717   float arg4 ;
43718   float arg5 ;
43719   Dali::Toolkit::ClampState *arg6 = 0 ;
43720   float result;
43721
43722   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43723   arg2 = (float)jarg2;
43724   arg3 = (float)jarg3;
43725   arg4 = (float)jarg4;
43726   arg5 = (float)jarg5;
43727   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43728   if (!arg6) {
43729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43730     return 0;
43731   }
43732   {
43733     try {
43734       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43735     } CALL_CATCH_EXCEPTION(0);
43736   }
43737
43738   jresult = result;
43739   return jresult;
43740 }
43741
43742
43743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43744   void * jresult ;
43745   Dali::Toolkit::DefaultRuler *result = 0 ;
43746
43747   {
43748     try {
43749       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43750     } CALL_CATCH_EXCEPTION(0);
43751   }
43752
43753   jresult = (void *)result;
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43759   float jresult ;
43760   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43761   float arg2 ;
43762   float arg3 ;
43763   float result;
43764
43765   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43766   arg2 = (float)jarg2;
43767   arg3 = (float)jarg3;
43768   {
43769     try {
43770       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
43771     } CALL_CATCH_EXCEPTION(0);
43772   }
43773
43774   jresult = result;
43775   return jresult;
43776 }
43777
43778
43779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43780   float jresult ;
43781   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43782   unsigned int arg2 ;
43783   unsigned int *arg3 = 0 ;
43784   bool arg4 ;
43785   float result;
43786
43787   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43788   arg2 = (unsigned int)jarg2;
43789   arg3 = (unsigned int *)jarg3;
43790   arg4 = jarg4 ? true : false;
43791   {
43792     try {
43793       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43794     } CALL_CATCH_EXCEPTION(0);
43795   }
43796
43797   jresult = result;
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43803   unsigned int jresult ;
43804   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43805   float arg2 ;
43806   bool arg3 ;
43807   unsigned int result;
43808
43809   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43810   arg2 = (float)jarg2;
43811   arg3 = jarg3 ? true : false;
43812   {
43813     try {
43814       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43815     } CALL_CATCH_EXCEPTION(0);
43816   }
43817
43818   jresult = result;
43819   return jresult;
43820 }
43821
43822
43823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
43824   unsigned int jresult ;
43825   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43826   unsigned int result;
43827
43828   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43829   {
43830     try {
43831       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
43832     } CALL_CATCH_EXCEPTION(0);
43833   }
43834
43835   jresult = result;
43836   return jresult;
43837 }
43838
43839
43840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
43841   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43842
43843   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43844   {
43845     try {
43846       delete arg1;
43847     } CALL_CATCH_EXCEPTION();
43848   }
43849
43850 }
43851
43852
43853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
43854   void * jresult ;
43855   float arg1 ;
43856   Dali::Toolkit::FixedRuler *result = 0 ;
43857
43858   arg1 = (float)jarg1;
43859   {
43860     try {
43861       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
43862     } CALL_CATCH_EXCEPTION(0);
43863   }
43864
43865   jresult = (void *)result;
43866   return jresult;
43867 }
43868
43869
43870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
43871   void * jresult ;
43872   Dali::Toolkit::FixedRuler *result = 0 ;
43873
43874   {
43875     try {
43876       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
43877     } CALL_CATCH_EXCEPTION(0);
43878   }
43879
43880   jresult = (void *)result;
43881   return jresult;
43882 }
43883
43884
43885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43886   float jresult ;
43887   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43888   float arg2 ;
43889   float arg3 ;
43890   float result;
43891
43892   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43893   arg2 = (float)jarg2;
43894   arg3 = (float)jarg3;
43895   {
43896     try {
43897       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
43898     } CALL_CATCH_EXCEPTION(0);
43899   }
43900
43901   jresult = result;
43902   return jresult;
43903 }
43904
43905
43906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43907   float jresult ;
43908   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43909   unsigned int arg2 ;
43910   unsigned int *arg3 = 0 ;
43911   bool arg4 ;
43912   float result;
43913
43914   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43915   arg2 = (unsigned int)jarg2;
43916   arg3 = (unsigned int *)jarg3;
43917   arg4 = jarg4 ? true : false;
43918   {
43919     try {
43920       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43921     } CALL_CATCH_EXCEPTION(0);
43922   }
43923
43924   jresult = result;
43925   return jresult;
43926 }
43927
43928
43929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43930   unsigned int jresult ;
43931   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43932   float arg2 ;
43933   bool arg3 ;
43934   unsigned int result;
43935
43936   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43937   arg2 = (float)jarg2;
43938   arg3 = jarg3 ? true : false;
43939   {
43940     try {
43941       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43942     } CALL_CATCH_EXCEPTION(0);
43943   }
43944
43945   jresult = result;
43946   return jresult;
43947 }
43948
43949
43950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
43951   unsigned int jresult ;
43952   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43953   unsigned int result;
43954
43955   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43956   {
43957     try {
43958       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
43959     } CALL_CATCH_EXCEPTION(0);
43960   }
43961
43962   jresult = result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
43968   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43969
43970   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43971   {
43972     try {
43973       delete arg1;
43974     } CALL_CATCH_EXCEPTION();
43975   }
43976
43977 }
43978
43979
43980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
43981   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43982   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
43983
43984   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43985   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
43986   if (arg1) (arg1)->scale = *arg2;
43987 }
43988
43989
43990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
43991   void * jresult ;
43992   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43993   Dali::Toolkit::ClampState2D *result = 0 ;
43994
43995   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43996   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
43997   jresult = (void *)result;
43998   return jresult;
43999 }
44000
44001
44002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44003   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44004   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44005
44006   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44007   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44008   if (arg1) (arg1)->position = *arg2;
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44013   void * jresult ;
44014   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44015   Dali::Toolkit::ClampState2D *result = 0 ;
44016
44017   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44018   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44019   jresult = (void *)result;
44020   return jresult;
44021 }
44022
44023
44024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44025   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44026   Dali::Toolkit::ClampState arg2 ;
44027
44028   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44029   arg2 = (Dali::Toolkit::ClampState)jarg2;
44030   if (arg1) (arg1)->rotation = arg2;
44031 }
44032
44033
44034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44035   int jresult ;
44036   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44037   Dali::Toolkit::ClampState result;
44038
44039   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44040   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44041   jresult = (int)result;
44042   return jresult;
44043 }
44044
44045
44046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44047   void * jresult ;
44048   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44049
44050   {
44051     try {
44052       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44053     } CALL_CATCH_EXCEPTION(0);
44054   }
44055
44056   jresult = (void *)result;
44057   return jresult;
44058 }
44059
44060
44061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44062   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44063
44064   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44065   {
44066     try {
44067       delete arg1;
44068     } CALL_CATCH_EXCEPTION();
44069   }
44070
44071 }
44072
44073
44074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44075   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44076   Dali::Toolkit::SnapType arg2 ;
44077
44078   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44079   arg2 = (Dali::Toolkit::SnapType)jarg2;
44080   if (arg1) (arg1)->type = arg2;
44081 }
44082
44083
44084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44085   int jresult ;
44086   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44087   Dali::Toolkit::SnapType result;
44088
44089   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44090   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44091   jresult = (int)result;
44092   return jresult;
44093 }
44094
44095
44096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44097   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44098   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44099
44100   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44101   arg2 = (Dali::Vector2 *)jarg2;
44102   if (arg1) (arg1)->position = *arg2;
44103 }
44104
44105
44106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44107   void * jresult ;
44108   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44109   Dali::Vector2 *result = 0 ;
44110
44111   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44112   result = (Dali::Vector2 *)& ((arg1)->position);
44113   jresult = (void *)result;
44114   return jresult;
44115 }
44116
44117
44118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44119   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44120   float arg2 ;
44121
44122   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44123   arg2 = (float)jarg2;
44124   if (arg1) (arg1)->duration = arg2;
44125 }
44126
44127
44128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44129   float jresult ;
44130   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44131   float result;
44132
44133   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44134   result = (float) ((arg1)->duration);
44135   jresult = result;
44136   return jresult;
44137 }
44138
44139
44140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44141   void * jresult ;
44142   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44143
44144   {
44145     try {
44146       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44147     } CALL_CATCH_EXCEPTION(0);
44148   }
44149
44150   jresult = (void *)result;
44151   return jresult;
44152 }
44153
44154
44155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44156   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44157
44158   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44159   {
44160     try {
44161       delete arg1;
44162     } CALL_CATCH_EXCEPTION();
44163   }
44164
44165 }
44166
44167
44168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44169   int jresult ;
44170   int result;
44171
44172   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44173   jresult = (int)result;
44174   return jresult;
44175 }
44176
44177
44178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44179   int jresult ;
44180   int result;
44181
44182   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44183   jresult = (int)result;
44184   return jresult;
44185 }
44186
44187
44188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44189   int jresult ;
44190   int result;
44191
44192   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44193   jresult = (int)result;
44194   return jresult;
44195 }
44196
44197
44198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44199   int jresult ;
44200   int result;
44201
44202   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44203   jresult = (int)result;
44204   return jresult;
44205 }
44206
44207
44208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44209   int jresult ;
44210   int result;
44211
44212   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44213   jresult = (int)result;
44214   return jresult;
44215 }
44216
44217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44218   int jresult ;
44219   int result;
44220
44221   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44222   jresult = (int)result;
44223   return jresult;
44224 }
44225
44226
44227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44228   int jresult ;
44229   int result;
44230
44231   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44232   jresult = (int)result;
44233   return jresult;
44234 }
44235
44236
44237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44238   int jresult ;
44239   int result;
44240
44241   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44242   jresult = (int)result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44248   int jresult ;
44249   int result;
44250
44251   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44252   jresult = (int)result;
44253   return jresult;
44254 }
44255
44256
44257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44258   int jresult ;
44259   int result;
44260
44261   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44262   jresult = (int)result;
44263   return jresult;
44264 }
44265
44266
44267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44268   int jresult ;
44269   int result;
44270
44271   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44272   jresult = (int)result;
44273   return jresult;
44274 }
44275
44276
44277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44278   int jresult ;
44279   int result;
44280
44281   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44282   jresult = (int)result;
44283   return jresult;
44284 }
44285
44286
44287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44288   int jresult ;
44289   int result;
44290
44291   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44292   jresult = (int)result;
44293   return jresult;
44294 }
44295
44296
44297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44298   int jresult ;
44299   int result;
44300
44301   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44302   jresult = (int)result;
44303   return jresult;
44304 }
44305
44306
44307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44308   int jresult ;
44309   int result;
44310
44311   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44312   jresult = (int)result;
44313   return jresult;
44314 }
44315
44316
44317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44318   int jresult ;
44319   int result;
44320
44321   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44322   jresult = (int)result;
44323   return jresult;
44324 }
44325
44326
44327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44328   int jresult ;
44329   int result;
44330
44331   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44332   jresult = (int)result;
44333   return jresult;
44334 }
44335
44336
44337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44338   int jresult ;
44339   int result;
44340
44341   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44342   jresult = (int)result;
44343   return jresult;
44344 }
44345
44346
44347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44348   int jresult ;
44349   int result;
44350
44351   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44352   jresult = (int)result;
44353   return jresult;
44354 }
44355
44356
44357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44358   int jresult ;
44359   int result;
44360
44361   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44362   jresult = (int)result;
44363   return jresult;
44364 }
44365
44366
44367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44368   int jresult ;
44369   int result;
44370
44371   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44372   jresult = (int)result;
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44378   int jresult ;
44379   int result;
44380
44381   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44382   jresult = (int)result;
44383   return jresult;
44384 }
44385
44386
44387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44388   int jresult ;
44389   int result;
44390
44391   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44392   jresult = (int)result;
44393   return jresult;
44394 }
44395
44396
44397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44398   int jresult ;
44399   int result;
44400
44401   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44402   jresult = (int)result;
44403   return jresult;
44404 }
44405
44406
44407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44408   int jresult ;
44409   int result;
44410
44411   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44412   jresult = (int)result;
44413   return jresult;
44414 }
44415
44416
44417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44418   int jresult ;
44419   int result;
44420
44421   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44422   jresult = (int)result;
44423   return jresult;
44424 }
44425
44426
44427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44428   void * jresult ;
44429   Dali::Toolkit::ScrollView::Property *result = 0 ;
44430
44431   {
44432     try {
44433       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44434     } CALL_CATCH_EXCEPTION(0);
44435   }
44436
44437   jresult = (void *)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44443   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44444
44445   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44446   {
44447     try {
44448       delete arg1;
44449     } CALL_CATCH_EXCEPTION();
44450   }
44451
44452 }
44453
44454
44455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44456   void * jresult ;
44457   Dali::Toolkit::ScrollView *result = 0 ;
44458
44459   {
44460     try {
44461       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44462     } CALL_CATCH_EXCEPTION(0);
44463   }
44464
44465   jresult = (void *)result;
44466   return jresult;
44467 }
44468
44469
44470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44471   void * jresult ;
44472   Dali::Toolkit::ScrollView *arg1 = 0 ;
44473   Dali::Toolkit::ScrollView *result = 0 ;
44474
44475   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44476   if (!arg1) {
44477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44478     return 0;
44479   }
44480   {
44481     try {
44482       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44483     } CALL_CATCH_EXCEPTION(0);
44484   }
44485
44486   jresult = (void *)result;
44487   return jresult;
44488 }
44489
44490
44491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44492   void * jresult ;
44493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44494   Dali::Toolkit::ScrollView *arg2 = 0 ;
44495   Dali::Toolkit::ScrollView *result = 0 ;
44496
44497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44498   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44499   if (!arg2) {
44500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44501     return 0;
44502   }
44503   {
44504     try {
44505       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44506     } CALL_CATCH_EXCEPTION(0);
44507   }
44508
44509   jresult = (void *)result;
44510   return jresult;
44511 }
44512
44513
44514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44516
44517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44518   {
44519     try {
44520       delete arg1;
44521     } CALL_CATCH_EXCEPTION();
44522   }
44523
44524 }
44525
44526
44527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44528   void * jresult ;
44529   Dali::Toolkit::ScrollView result;
44530
44531   {
44532     try {
44533       result = Dali::Toolkit::ScrollView::New();
44534     } CALL_CATCH_EXCEPTION(0);
44535   }
44536
44537   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44543   void * jresult ;
44544   Dali::BaseHandle arg1 ;
44545   Dali::BaseHandle *argp1 ;
44546   Dali::Toolkit::ScrollView result;
44547
44548   argp1 = (Dali::BaseHandle *)jarg1;
44549   if (!argp1) {
44550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44551     return 0;
44552   }
44553   arg1 = *argp1;
44554   {
44555     try {
44556       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44557     } CALL_CATCH_EXCEPTION(0);
44558   }
44559
44560   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44561   return jresult;
44562 }
44563
44564
44565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44566   void * jresult ;
44567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44568   Dali::AlphaFunction result;
44569
44570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44571   {
44572     try {
44573       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44574     } CALL_CATCH_EXCEPTION(0);
44575   }
44576
44577   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44578   return jresult;
44579 }
44580
44581
44582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44584   Dali::AlphaFunction arg2 ;
44585   Dali::AlphaFunction *argp2 ;
44586
44587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44588   argp2 = (Dali::AlphaFunction *)jarg2;
44589   if (!argp2) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44591     return ;
44592   }
44593   arg2 = *argp2;
44594   {
44595     try {
44596       (arg1)->SetScrollSnapAlphaFunction(arg2);
44597     } CALL_CATCH_EXCEPTION();
44598   }
44599
44600 }
44601
44602
44603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44604   void * jresult ;
44605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44606   Dali::AlphaFunction result;
44607
44608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44609   {
44610     try {
44611       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44612     } CALL_CATCH_EXCEPTION(0);
44613   }
44614
44615   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44616   return jresult;
44617 }
44618
44619
44620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44622   Dali::AlphaFunction arg2 ;
44623   Dali::AlphaFunction *argp2 ;
44624
44625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44626   argp2 = (Dali::AlphaFunction *)jarg2;
44627   if (!argp2) {
44628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44629     return ;
44630   }
44631   arg2 = *argp2;
44632   {
44633     try {
44634       (arg1)->SetScrollFlickAlphaFunction(arg2);
44635     } CALL_CATCH_EXCEPTION();
44636   }
44637
44638 }
44639
44640
44641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44642   float jresult ;
44643   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44644   float result;
44645
44646   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44647   {
44648     try {
44649       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44650     } CALL_CATCH_EXCEPTION(0);
44651   }
44652
44653   jresult = result;
44654   return jresult;
44655 }
44656
44657
44658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44659   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44660   float arg2 ;
44661
44662   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44663   arg2 = (float)jarg2;
44664   {
44665     try {
44666       (arg1)->SetScrollSnapDuration(arg2);
44667     } CALL_CATCH_EXCEPTION();
44668   }
44669
44670 }
44671
44672
44673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44674   float jresult ;
44675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44676   float result;
44677
44678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44679   {
44680     try {
44681       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44682     } CALL_CATCH_EXCEPTION(0);
44683   }
44684
44685   jresult = result;
44686   return jresult;
44687 }
44688
44689
44690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44692   float arg2 ;
44693
44694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44695   arg2 = (float)jarg2;
44696   {
44697     try {
44698       (arg1)->SetScrollFlickDuration(arg2);
44699     } CALL_CATCH_EXCEPTION();
44700   }
44701
44702 }
44703
44704
44705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44707   Dali::Toolkit::RulerPtr arg2 ;
44708   Dali::Toolkit::RulerPtr *argp2 ;
44709
44710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44711   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44712   if (!argp2) {
44713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44714     return ;
44715   }
44716   arg2 = *argp2;
44717   {
44718     try {
44719       (arg1)->SetRulerX(arg2);
44720     } CALL_CATCH_EXCEPTION();
44721   }
44722
44723 }
44724
44725
44726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44728   Dali::Toolkit::RulerPtr arg2 ;
44729   Dali::Toolkit::RulerPtr *argp2 ;
44730
44731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44732   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44733   if (!argp2) {
44734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44735     return ;
44736   }
44737   arg2 = *argp2;
44738   {
44739     try {
44740       (arg1)->SetRulerY(arg2);
44741     } CALL_CATCH_EXCEPTION();
44742   }
44743
44744 }
44745
44746
44747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44749   bool arg2 ;
44750
44751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44752   arg2 = jarg2 ? true : false;
44753   {
44754     try {
44755       (arg1)->SetScrollSensitive(arg2);
44756     } CALL_CATCH_EXCEPTION();
44757   }
44758
44759 }
44760
44761
44762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
44763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44764   float arg2 ;
44765   float arg3 ;
44766
44767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44768   arg2 = (float)jarg2;
44769   arg3 = (float)jarg3;
44770   {
44771     try {
44772       (arg1)->SetMaxOvershoot(arg2,arg3);
44773     } CALL_CATCH_EXCEPTION();
44774   }
44775
44776 }
44777
44778
44779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
44780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44781   Dali::AlphaFunction arg2 ;
44782   Dali::AlphaFunction *argp2 ;
44783
44784   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44785   argp2 = (Dali::AlphaFunction *)jarg2;
44786   if (!argp2) {
44787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44788     return ;
44789   }
44790   arg2 = *argp2;
44791   {
44792     try {
44793       (arg1)->SetSnapOvershootAlphaFunction(arg2);
44794     } CALL_CATCH_EXCEPTION();
44795   }
44796
44797 }
44798
44799
44800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
44801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44802   float arg2 ;
44803
44804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44805   arg2 = (float)jarg2;
44806   {
44807     try {
44808       (arg1)->SetSnapOvershootDuration(arg2);
44809     } CALL_CATCH_EXCEPTION();
44810   }
44811
44812 }
44813
44814
44815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
44816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44817   bool arg2 ;
44818
44819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44820   arg2 = jarg2 ? true : false;
44821   {
44822     try {
44823       (arg1)->SetActorAutoSnap(arg2);
44824     } CALL_CATCH_EXCEPTION();
44825   }
44826
44827 }
44828
44829
44830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
44831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44832   bool arg2 ;
44833
44834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44835   arg2 = jarg2 ? true : false;
44836   {
44837     try {
44838       (arg1)->SetWrapMode(arg2);
44839     } CALL_CATCH_EXCEPTION();
44840   }
44841
44842 }
44843
44844
44845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
44846   int jresult ;
44847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44848   int result;
44849
44850   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44851   {
44852     try {
44853       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
44854     } CALL_CATCH_EXCEPTION(0);
44855   }
44856
44857   jresult = result;
44858   return jresult;
44859 }
44860
44861
44862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
44863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44864   int arg2 ;
44865
44866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44867   arg2 = (int)jarg2;
44868   {
44869     try {
44870       (arg1)->SetScrollUpdateDistance(arg2);
44871     } CALL_CATCH_EXCEPTION();
44872   }
44873
44874 }
44875
44876
44877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
44878   unsigned int jresult ;
44879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44880   bool result;
44881
44882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44883   {
44884     try {
44885       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
44886     } CALL_CATCH_EXCEPTION(0);
44887   }
44888
44889   jresult = result;
44890   return jresult;
44891 }
44892
44893
44894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
44895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44896   bool arg2 ;
44897
44898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44899   arg2 = jarg2 ? true : false;
44900   {
44901     try {
44902       (arg1)->SetAxisAutoLock(arg2);
44903     } CALL_CATCH_EXCEPTION();
44904   }
44905
44906 }
44907
44908
44909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
44910   float jresult ;
44911   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44912   float result;
44913
44914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44915   {
44916     try {
44917       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
44918     } CALL_CATCH_EXCEPTION(0);
44919   }
44920
44921   jresult = result;
44922   return jresult;
44923 }
44924
44925
44926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
44927   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44928   float arg2 ;
44929
44930   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44931   arg2 = (float)jarg2;
44932   {
44933     try {
44934       (arg1)->SetAxisAutoLockGradient(arg2);
44935     } CALL_CATCH_EXCEPTION();
44936   }
44937
44938 }
44939
44940
44941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
44942   float jresult ;
44943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44944   float result;
44945
44946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44947   {
44948     try {
44949       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
44950     } CALL_CATCH_EXCEPTION(0);
44951   }
44952
44953   jresult = result;
44954   return jresult;
44955 }
44956
44957
44958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
44959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44960   float arg2 ;
44961
44962   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44963   arg2 = (float)jarg2;
44964   {
44965     try {
44966       (arg1)->SetFrictionCoefficient(arg2);
44967     } CALL_CATCH_EXCEPTION();
44968   }
44969
44970 }
44971
44972
44973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
44974   float jresult ;
44975   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44976   float result;
44977
44978   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44979   {
44980     try {
44981       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
44982     } CALL_CATCH_EXCEPTION(0);
44983   }
44984
44985   jresult = result;
44986   return jresult;
44987 }
44988
44989
44990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
44991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44992   float arg2 ;
44993
44994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44995   arg2 = (float)jarg2;
44996   {
44997     try {
44998       (arg1)->SetFlickSpeedCoefficient(arg2);
44999     } CALL_CATCH_EXCEPTION();
45000   }
45001
45002 }
45003
45004
45005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45006   void * jresult ;
45007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45008   Dali::Vector2 result;
45009
45010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45011   {
45012     try {
45013       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45014     } CALL_CATCH_EXCEPTION(0);
45015   }
45016
45017   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45018   return jresult;
45019 }
45020
45021
45022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45024   Dali::Vector2 *arg2 = 0 ;
45025
45026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45027   arg2 = (Dali::Vector2 *)jarg2;
45028   if (!arg2) {
45029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45030     return ;
45031   }
45032   {
45033     try {
45034       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45035     } CALL_CATCH_EXCEPTION();
45036   }
45037
45038 }
45039
45040
45041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45042   float jresult ;
45043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45044   float result;
45045
45046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45047   {
45048     try {
45049       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45050     } CALL_CATCH_EXCEPTION(0);
45051   }
45052
45053   jresult = result;
45054   return jresult;
45055 }
45056
45057
45058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45060   float arg2 ;
45061
45062   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45063   arg2 = (float)jarg2;
45064   {
45065     try {
45066       (arg1)->SetMinimumSpeedForFlick(arg2);
45067     } CALL_CATCH_EXCEPTION();
45068   }
45069
45070 }
45071
45072
45073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45074   float jresult ;
45075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45076   float result;
45077
45078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45079   {
45080     try {
45081       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45082     } CALL_CATCH_EXCEPTION(0);
45083   }
45084
45085   jresult = result;
45086   return jresult;
45087 }
45088
45089
45090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45091   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45092   float arg2 ;
45093
45094   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45095   arg2 = (float)jarg2;
45096   {
45097     try {
45098       (arg1)->SetMaxFlickSpeed(arg2);
45099     } CALL_CATCH_EXCEPTION();
45100   }
45101
45102 }
45103
45104
45105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45106   void * jresult ;
45107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45108   Dali::Vector2 result;
45109
45110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45111   {
45112     try {
45113       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45114     } CALL_CATCH_EXCEPTION(0);
45115   }
45116
45117   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45118   return jresult;
45119 }
45120
45121
45122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45123   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45124   Dali::Vector2 arg2 ;
45125   Dali::Vector2 *argp2 ;
45126
45127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45128   argp2 = (Dali::Vector2 *)jarg2;
45129   if (!argp2) {
45130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45131     return ;
45132   }
45133   arg2 = *argp2;
45134   {
45135     try {
45136       (arg1)->SetWheelScrollDistanceStep(arg2);
45137     } CALL_CATCH_EXCEPTION();
45138   }
45139
45140 }
45141
45142
45143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45144   void * jresult ;
45145   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45146   Dali::Vector2 result;
45147
45148   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45149   {
45150     try {
45151       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45152     } CALL_CATCH_EXCEPTION(0);
45153   }
45154
45155   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45156   return jresult;
45157 }
45158
45159
45160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45161   unsigned int jresult ;
45162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45163   unsigned int result;
45164
45165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45166   {
45167     try {
45168       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45169     } CALL_CATCH_EXCEPTION(0);
45170   }
45171
45172   jresult = result;
45173   return jresult;
45174 }
45175
45176
45177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45179   Dali::Vector2 *arg2 = 0 ;
45180
45181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45182   arg2 = (Dali::Vector2 *)jarg2;
45183   if (!arg2) {
45184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45185     return ;
45186   }
45187   {
45188     try {
45189       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45190     } CALL_CATCH_EXCEPTION();
45191   }
45192
45193 }
45194
45195
45196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45198   Dali::Vector2 *arg2 = 0 ;
45199   float arg3 ;
45200
45201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45202   arg2 = (Dali::Vector2 *)jarg2;
45203   if (!arg2) {
45204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45205     return ;
45206   }
45207   arg3 = (float)jarg3;
45208   {
45209     try {
45210       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45211     } CALL_CATCH_EXCEPTION();
45212   }
45213
45214 }
45215
45216
45217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45218   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45219   Dali::Vector2 *arg2 = 0 ;
45220   float arg3 ;
45221   Dali::AlphaFunction arg4 ;
45222   Dali::AlphaFunction *argp4 ;
45223
45224   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45225   arg2 = (Dali::Vector2 *)jarg2;
45226   if (!arg2) {
45227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45228     return ;
45229   }
45230   arg3 = (float)jarg3;
45231   argp4 = (Dali::AlphaFunction *)jarg4;
45232   if (!argp4) {
45233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45234     return ;
45235   }
45236   arg4 = *argp4;
45237   {
45238     try {
45239       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45240     } CALL_CATCH_EXCEPTION();
45241   }
45242
45243 }
45244
45245
45246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45247   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45248   Dali::Vector2 *arg2 = 0 ;
45249   float arg3 ;
45250   Dali::Toolkit::DirectionBias arg4 ;
45251   Dali::Toolkit::DirectionBias arg5 ;
45252
45253   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45254   arg2 = (Dali::Vector2 *)jarg2;
45255   if (!arg2) {
45256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45257     return ;
45258   }
45259   arg3 = (float)jarg3;
45260   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45261   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45262   {
45263     try {
45264       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45265     } CALL_CATCH_EXCEPTION();
45266   }
45267
45268 }
45269
45270
45271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45273   Dali::Vector2 *arg2 = 0 ;
45274   float arg3 ;
45275   Dali::AlphaFunction arg4 ;
45276   Dali::Toolkit::DirectionBias arg5 ;
45277   Dali::Toolkit::DirectionBias arg6 ;
45278   Dali::AlphaFunction *argp4 ;
45279
45280   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45281   arg2 = (Dali::Vector2 *)jarg2;
45282   if (!arg2) {
45283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45284     return ;
45285   }
45286   arg3 = (float)jarg3;
45287   argp4 = (Dali::AlphaFunction *)jarg4;
45288   if (!argp4) {
45289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45290     return ;
45291   }
45292   arg4 = *argp4;
45293   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45294   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45295   {
45296     try {
45297       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45298     } CALL_CATCH_EXCEPTION();
45299   }
45300
45301 }
45302
45303
45304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45306   unsigned int arg2 ;
45307
45308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45309   arg2 = (unsigned int)jarg2;
45310   {
45311     try {
45312       (arg1)->ScrollTo(arg2);
45313     } CALL_CATCH_EXCEPTION();
45314   }
45315
45316 }
45317
45318
45319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45321   unsigned int arg2 ;
45322   float arg3 ;
45323
45324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45325   arg2 = (unsigned int)jarg2;
45326   arg3 = (float)jarg3;
45327   {
45328     try {
45329       (arg1)->ScrollTo(arg2,arg3);
45330     } CALL_CATCH_EXCEPTION();
45331   }
45332
45333 }
45334
45335
45336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45338   unsigned int arg2 ;
45339   float arg3 ;
45340   Dali::Toolkit::DirectionBias arg4 ;
45341
45342   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45343   arg2 = (unsigned int)jarg2;
45344   arg3 = (float)jarg3;
45345   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45346   {
45347     try {
45348       (arg1)->ScrollTo(arg2,arg3,arg4);
45349     } CALL_CATCH_EXCEPTION();
45350   }
45351
45352 }
45353
45354
45355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45357   Dali::Actor *arg2 = 0 ;
45358
45359   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45360   arg2 = (Dali::Actor *)jarg2;
45361   if (!arg2) {
45362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45363     return ;
45364   }
45365   {
45366     try {
45367       (arg1)->ScrollTo(*arg2);
45368     } CALL_CATCH_EXCEPTION();
45369   }
45370
45371 }
45372
45373
45374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45376   Dali::Actor *arg2 = 0 ;
45377   float arg3 ;
45378
45379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45380   arg2 = (Dali::Actor *)jarg2;
45381   if (!arg2) {
45382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45383     return ;
45384   }
45385   arg3 = (float)jarg3;
45386   {
45387     try {
45388       (arg1)->ScrollTo(*arg2,arg3);
45389     } CALL_CATCH_EXCEPTION();
45390   }
45391
45392 }
45393
45394
45395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45396   unsigned int jresult ;
45397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45398   bool result;
45399
45400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45401   {
45402     try {
45403       result = (bool)(arg1)->ScrollToSnapPoint();
45404     } CALL_CATCH_EXCEPTION(0);
45405   }
45406
45407   jresult = result;
45408   return jresult;
45409 }
45410
45411
45412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45414   Dali::Constraint arg2 ;
45415   Dali::Constraint *argp2 ;
45416
45417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45418   argp2 = (Dali::Constraint *)jarg2;
45419   if (!argp2) {
45420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45421     return ;
45422   }
45423   arg2 = *argp2;
45424   {
45425     try {
45426       (arg1)->ApplyConstraintToChildren(arg2);
45427     } CALL_CATCH_EXCEPTION();
45428   }
45429
45430 }
45431
45432
45433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45435
45436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45437   {
45438     try {
45439       (arg1)->RemoveConstraintsFromChildren();
45440     } CALL_CATCH_EXCEPTION();
45441   }
45442
45443 }
45444
45445
45446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45448   Dali::Toolkit::ScrollViewEffect arg2 ;
45449   Dali::Toolkit::ScrollViewEffect *argp2 ;
45450
45451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45452   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45453   if (!argp2) {
45454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45455     return ;
45456   }
45457   arg2 = *argp2;
45458   {
45459     try {
45460       (arg1)->ApplyEffect(arg2);
45461     } CALL_CATCH_EXCEPTION();
45462   }
45463
45464 }
45465
45466
45467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45469   Dali::Toolkit::ScrollViewEffect arg2 ;
45470   Dali::Toolkit::ScrollViewEffect *argp2 ;
45471
45472   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45473   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45474   if (!argp2) {
45475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45476     return ;
45477   }
45478   arg2 = *argp2;
45479   {
45480     try {
45481       (arg1)->RemoveEffect(arg2);
45482     } CALL_CATCH_EXCEPTION();
45483   }
45484
45485 }
45486
45487
45488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45490
45491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45492   {
45493     try {
45494       (arg1)->RemoveAllEffects();
45495     } CALL_CATCH_EXCEPTION();
45496   }
45497
45498 }
45499
45500
45501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45502   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45503   Dali::Actor arg2 ;
45504   Dali::Actor *argp2 ;
45505
45506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45507   argp2 = (Dali::Actor *)jarg2;
45508   if (!argp2) {
45509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45510     return ;
45511   }
45512   arg2 = *argp2;
45513   {
45514     try {
45515       (arg1)->BindActor(arg2);
45516     } CALL_CATCH_EXCEPTION();
45517   }
45518
45519 }
45520
45521
45522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45523   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45524   Dali::Actor arg2 ;
45525   Dali::Actor *argp2 ;
45526
45527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45528   argp2 = (Dali::Actor *)jarg2;
45529   if (!argp2) {
45530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45531     return ;
45532   }
45533   arg2 = *argp2;
45534   {
45535     try {
45536       (arg1)->UnbindActor(arg2);
45537     } CALL_CATCH_EXCEPTION();
45538   }
45539
45540 }
45541
45542
45543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45545   Dali::Radian arg2 ;
45546   Dali::Radian arg3 ;
45547   Dali::Radian *argp2 ;
45548   Dali::Radian *argp3 ;
45549
45550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45551   argp2 = (Dali::Radian *)jarg2;
45552   if (!argp2) {
45553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45554     return ;
45555   }
45556   arg2 = *argp2;
45557   argp3 = (Dali::Radian *)jarg3;
45558   if (!argp3) {
45559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45560     return ;
45561   }
45562   arg3 = *argp3;
45563   {
45564     try {
45565       (arg1)->SetScrollingDirection(arg2,arg3);
45566     } CALL_CATCH_EXCEPTION();
45567   }
45568
45569 }
45570
45571
45572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45574   Dali::Radian arg2 ;
45575   Dali::Radian *argp2 ;
45576
45577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45578   argp2 = (Dali::Radian *)jarg2;
45579   if (!argp2) {
45580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45581     return ;
45582   }
45583   arg2 = *argp2;
45584   {
45585     try {
45586       (arg1)->SetScrollingDirection(arg2);
45587     } CALL_CATCH_EXCEPTION();
45588   }
45589
45590 }
45591
45592
45593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45595   Dali::Radian arg2 ;
45596   Dali::Radian *argp2 ;
45597
45598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45599   argp2 = (Dali::Radian *)jarg2;
45600   if (!argp2) {
45601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45602     return ;
45603   }
45604   arg2 = *argp2;
45605   {
45606     try {
45607       (arg1)->RemoveScrollingDirection(arg2);
45608     } CALL_CATCH_EXCEPTION();
45609   }
45610
45611 }
45612
45613
45614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45615   void * jresult ;
45616   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45617   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45618
45619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45620   {
45621     try {
45622       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45623     } CALL_CATCH_EXCEPTION(0);
45624   }
45625
45626   jresult = (void *)result;
45627   return jresult;
45628 }
45629
45630
45631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45632   int jresult ;
45633   int result;
45634
45635   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45636   jresult = (int)result;
45637   return jresult;
45638 }
45639
45640
45641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45642   int jresult ;
45643   int result;
45644
45645   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45646   jresult = (int)result;
45647   return jresult;
45648 }
45649
45650
45651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45652   int jresult ;
45653   int result;
45654
45655   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45656   jresult = (int)result;
45657   return jresult;
45658 }
45659
45660
45661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45662   int jresult ;
45663   int result;
45664
45665   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45666   jresult = (int)result;
45667   return jresult;
45668 }
45669
45670
45671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45672   int jresult ;
45673   int result;
45674
45675   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45676   jresult = (int)result;
45677   return jresult;
45678 }
45679
45680
45681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45682   void * jresult ;
45683   Dali::Toolkit::TableView::Property *result = 0 ;
45684
45685   {
45686     try {
45687       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45688     } CALL_CATCH_EXCEPTION(0);
45689   }
45690
45691   jresult = (void *)result;
45692   return jresult;
45693 }
45694
45695
45696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45697   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45698
45699   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45700   {
45701     try {
45702       delete arg1;
45703     } CALL_CATCH_EXCEPTION();
45704   }
45705
45706 }
45707
45708
45709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45710   int jresult ;
45711   int result;
45712
45713   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45714   jresult = (int)result;
45715   return jresult;
45716 }
45717
45718
45719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45720   int jresult ;
45721   int result;
45722
45723   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45724   jresult = (int)result;
45725   return jresult;
45726 }
45727
45728
45729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45730   int jresult ;
45731   int result;
45732
45733   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45734   jresult = (int)result;
45735   return jresult;
45736 }
45737
45738
45739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45740   int jresult ;
45741   int result;
45742
45743   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45744   jresult = (int)result;
45745   return jresult;
45746 }
45747
45748
45749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45750   int jresult ;
45751   int result;
45752
45753   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45754   jresult = (int)result;
45755   return jresult;
45756 }
45757
45758
45759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45760   void * jresult ;
45761   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45762
45763   {
45764     try {
45765       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
45766     } CALL_CATCH_EXCEPTION(0);
45767   }
45768
45769   jresult = (void *)result;
45770   return jresult;
45771 }
45772
45773
45774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
45775   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
45776
45777   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
45778   {
45779     try {
45780       delete arg1;
45781     } CALL_CATCH_EXCEPTION();
45782   }
45783
45784 }
45785
45786
45787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
45788   void * jresult ;
45789   unsigned int arg1 ;
45790   unsigned int arg2 ;
45791   unsigned int arg3 ;
45792   unsigned int arg4 ;
45793   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45794
45795   arg1 = (unsigned int)jarg1;
45796   arg2 = (unsigned int)jarg2;
45797   arg3 = (unsigned int)jarg3;
45798   arg4 = (unsigned int)jarg4;
45799   {
45800     try {
45801       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
45802     } CALL_CATCH_EXCEPTION(0);
45803   }
45804
45805   jresult = (void *)result;
45806   return jresult;
45807 }
45808
45809
45810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
45811   void * jresult ;
45812   unsigned int arg1 ;
45813   unsigned int arg2 ;
45814   unsigned int arg3 ;
45815   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45816
45817   arg1 = (unsigned int)jarg1;
45818   arg2 = (unsigned int)jarg2;
45819   arg3 = (unsigned int)jarg3;
45820   {
45821     try {
45822       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
45823     } CALL_CATCH_EXCEPTION(0);
45824   }
45825
45826   jresult = (void *)result;
45827   return jresult;
45828 }
45829
45830
45831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
45832   void * jresult ;
45833   unsigned int arg1 ;
45834   unsigned int arg2 ;
45835   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45836
45837   arg1 = (unsigned int)jarg1;
45838   arg2 = (unsigned int)jarg2;
45839   {
45840     try {
45841       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
45842     } CALL_CATCH_EXCEPTION(0);
45843   }
45844
45845   jresult = (void *)result;
45846   return jresult;
45847 }
45848
45849
45850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
45851   void * jresult ;
45852   unsigned int arg1 ;
45853   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45854
45855   arg1 = (unsigned int)jarg1;
45856   {
45857     try {
45858       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
45859     } CALL_CATCH_EXCEPTION(0);
45860   }
45861
45862   jresult = (void *)result;
45863   return jresult;
45864 }
45865
45866
45867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
45868   void * jresult ;
45869   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45870
45871   {
45872     try {
45873       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
45874     } CALL_CATCH_EXCEPTION(0);
45875   }
45876
45877   jresult = (void *)result;
45878   return jresult;
45879 }
45880
45881
45882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
45883   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45884   unsigned int arg2 ;
45885
45886   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45887   arg2 = (unsigned int)jarg2;
45888   if (arg1) (arg1)->rowIndex = arg2;
45889 }
45890
45891
45892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
45893   unsigned int jresult ;
45894   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45895   unsigned int result;
45896
45897   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45898   result = (unsigned int) ((arg1)->rowIndex);
45899   jresult = result;
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
45905   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45906   unsigned int arg2 ;
45907
45908   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45909   arg2 = (unsigned int)jarg2;
45910   if (arg1) (arg1)->columnIndex = arg2;
45911 }
45912
45913
45914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
45915   unsigned int jresult ;
45916   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45917   unsigned int result;
45918
45919   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45920   result = (unsigned int) ((arg1)->columnIndex);
45921   jresult = result;
45922   return jresult;
45923 }
45924
45925
45926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
45927   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45928   unsigned int arg2 ;
45929
45930   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45931   arg2 = (unsigned int)jarg2;
45932   if (arg1) (arg1)->rowSpan = arg2;
45933 }
45934
45935
45936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
45937   unsigned int jresult ;
45938   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45939   unsigned int result;
45940
45941   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45942   result = (unsigned int) ((arg1)->rowSpan);
45943   jresult = result;
45944   return jresult;
45945 }
45946
45947
45948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
45949   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45950   unsigned int arg2 ;
45951
45952   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45953   arg2 = (unsigned int)jarg2;
45954   if (arg1) (arg1)->columnSpan = arg2;
45955 }
45956
45957
45958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
45959   unsigned int jresult ;
45960   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45961   unsigned int result;
45962
45963   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45964   result = (unsigned int) ((arg1)->columnSpan);
45965   jresult = result;
45966   return jresult;
45967 }
45968
45969
45970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
45971   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45972
45973   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45974   {
45975     try {
45976       delete arg1;
45977     } CALL_CATCH_EXCEPTION();
45978   }
45979
45980 }
45981
45982
45983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
45984   void * jresult ;
45985   Dali::Toolkit::TableView *result = 0 ;
45986
45987   {
45988     try {
45989       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
45990     } CALL_CATCH_EXCEPTION(0);
45991   }
45992
45993   jresult = (void *)result;
45994   return jresult;
45995 }
45996
45997
45998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
45999   void * jresult ;
46000   Dali::Toolkit::TableView *arg1 = 0 ;
46001   Dali::Toolkit::TableView *result = 0 ;
46002
46003   arg1 = (Dali::Toolkit::TableView *)jarg1;
46004   if (!arg1) {
46005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46006     return 0;
46007   }
46008   {
46009     try {
46010       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46011     } CALL_CATCH_EXCEPTION(0);
46012   }
46013
46014   jresult = (void *)result;
46015   return jresult;
46016 }
46017
46018
46019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46020   void * jresult ;
46021   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46022   Dali::Toolkit::TableView *arg2 = 0 ;
46023   Dali::Toolkit::TableView *result = 0 ;
46024
46025   arg1 = (Dali::Toolkit::TableView *)jarg1;
46026   arg2 = (Dali::Toolkit::TableView *)jarg2;
46027   if (!arg2) {
46028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46029     return 0;
46030   }
46031   {
46032     try {
46033       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46034     } CALL_CATCH_EXCEPTION(0);
46035   }
46036
46037   jresult = (void *)result;
46038   return jresult;
46039 }
46040
46041
46042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46043   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46044
46045   arg1 = (Dali::Toolkit::TableView *)jarg1;
46046   {
46047     try {
46048       delete arg1;
46049     } CALL_CATCH_EXCEPTION();
46050   }
46051
46052 }
46053
46054
46055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46056   void * jresult ;
46057   unsigned int arg1 ;
46058   unsigned int arg2 ;
46059   Dali::Toolkit::TableView result;
46060
46061   arg1 = (unsigned int)jarg1;
46062   arg2 = (unsigned int)jarg2;
46063   {
46064     try {
46065       result = Dali::Toolkit::TableView::New(arg1,arg2);
46066     } CALL_CATCH_EXCEPTION(0);
46067   }
46068
46069   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46070   return jresult;
46071 }
46072
46073
46074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46075   void * jresult ;
46076   Dali::BaseHandle arg1 ;
46077   Dali::BaseHandle *argp1 ;
46078   Dali::Toolkit::TableView result;
46079
46080   argp1 = (Dali::BaseHandle *)jarg1;
46081   if (!argp1) {
46082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46083     return 0;
46084   }
46085   arg1 = *argp1;
46086   {
46087     try {
46088       result = Dali::Toolkit::TableView::DownCast(arg1);
46089     } CALL_CATCH_EXCEPTION(0);
46090   }
46091
46092   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46093   return jresult;
46094 }
46095
46096
46097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46098   unsigned int jresult ;
46099   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46100   Dali::Actor arg2 ;
46101   Dali::Toolkit::TableView::CellPosition arg3 ;
46102   Dali::Actor *argp2 ;
46103   Dali::Toolkit::TableView::CellPosition *argp3 ;
46104   bool result;
46105
46106   arg1 = (Dali::Toolkit::TableView *)jarg1;
46107   argp2 = (Dali::Actor *)jarg2;
46108   if (!argp2) {
46109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46110     return 0;
46111   }
46112   arg2 = *argp2;
46113   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46114   if (!argp3) {
46115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46116     return 0;
46117   }
46118   arg3 = *argp3;
46119   {
46120     try {
46121       result = (bool)(arg1)->AddChild(arg2,arg3);
46122     } CALL_CATCH_EXCEPTION(0);
46123   }
46124
46125   jresult = result;
46126   return jresult;
46127 }
46128
46129
46130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46131   void * jresult ;
46132   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46133   Dali::Toolkit::TableView::CellPosition arg2 ;
46134   Dali::Toolkit::TableView::CellPosition *argp2 ;
46135   Dali::Actor result;
46136
46137   arg1 = (Dali::Toolkit::TableView *)jarg1;
46138   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46139   if (!argp2) {
46140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46141     return 0;
46142   }
46143   arg2 = *argp2;
46144   {
46145     try {
46146       result = (arg1)->GetChildAt(arg2);
46147     } CALL_CATCH_EXCEPTION(0);
46148   }
46149
46150   jresult = new Dali::Actor((const Dali::Actor &)result);
46151   return jresult;
46152 }
46153
46154
46155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46156   void * jresult ;
46157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46158   Dali::Toolkit::TableView::CellPosition arg2 ;
46159   Dali::Toolkit::TableView::CellPosition *argp2 ;
46160   Dali::Actor result;
46161
46162   arg1 = (Dali::Toolkit::TableView *)jarg1;
46163   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46164   if (!argp2) {
46165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46166     return 0;
46167   }
46168   arg2 = *argp2;
46169   {
46170     try {
46171       result = (arg1)->RemoveChildAt(arg2);
46172     } CALL_CATCH_EXCEPTION(0);
46173   }
46174
46175   jresult = new Dali::Actor((const Dali::Actor &)result);
46176   return jresult;
46177 }
46178
46179
46180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46181   unsigned int jresult ;
46182   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46183   Dali::Actor arg2 ;
46184   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46185   Dali::Actor *argp2 ;
46186   bool result;
46187
46188   arg1 = (Dali::Toolkit::TableView *)jarg1;
46189   argp2 = (Dali::Actor *)jarg2;
46190   if (!argp2) {
46191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46192     return 0;
46193   }
46194   arg2 = *argp2;
46195   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46196   if (!arg3) {
46197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46198     return 0;
46199   }
46200   {
46201     try {
46202       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46203     } CALL_CATCH_EXCEPTION(0);
46204   }
46205
46206   jresult = result;
46207   return jresult;
46208 }
46209
46210
46211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46212   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46213   unsigned int arg2 ;
46214
46215   arg1 = (Dali::Toolkit::TableView *)jarg1;
46216   arg2 = (unsigned int)jarg2;
46217   {
46218     try {
46219       (arg1)->InsertRow(arg2);
46220     } CALL_CATCH_EXCEPTION();
46221   }
46222
46223 }
46224
46225
46226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46227   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46228   unsigned int arg2 ;
46229
46230   arg1 = (Dali::Toolkit::TableView *)jarg1;
46231   arg2 = (unsigned int)jarg2;
46232   {
46233     try {
46234       (arg1)->DeleteRow(arg2);
46235     } CALL_CATCH_EXCEPTION();
46236   }
46237
46238 }
46239
46240
46241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46242   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46243   unsigned int arg2 ;
46244   std::vector< Dali::Actor > *arg3 = 0 ;
46245
46246   arg1 = (Dali::Toolkit::TableView *)jarg1;
46247   arg2 = (unsigned int)jarg2;
46248   arg3 = (std::vector< Dali::Actor > *)jarg3;
46249   if (!arg3) {
46250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46251     return ;
46252   }
46253   {
46254     try {
46255       (arg1)->DeleteRow(arg2,*arg3);
46256     } CALL_CATCH_EXCEPTION();
46257   }
46258
46259 }
46260
46261
46262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46263   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46264   unsigned int arg2 ;
46265
46266   arg1 = (Dali::Toolkit::TableView *)jarg1;
46267   arg2 = (unsigned int)jarg2;
46268   {
46269     try {
46270       (arg1)->InsertColumn(arg2);
46271     } CALL_CATCH_EXCEPTION();
46272   }
46273
46274 }
46275
46276
46277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46279   unsigned int arg2 ;
46280
46281   arg1 = (Dali::Toolkit::TableView *)jarg1;
46282   arg2 = (unsigned int)jarg2;
46283   {
46284     try {
46285       (arg1)->DeleteColumn(arg2);
46286     } CALL_CATCH_EXCEPTION();
46287   }
46288
46289 }
46290
46291
46292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46293   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46294   unsigned int arg2 ;
46295   std::vector< Dali::Actor > *arg3 = 0 ;
46296
46297   arg1 = (Dali::Toolkit::TableView *)jarg1;
46298   arg2 = (unsigned int)jarg2;
46299   arg3 = (std::vector< Dali::Actor > *)jarg3;
46300   if (!arg3) {
46301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46302     return ;
46303   }
46304   {
46305     try {
46306       (arg1)->DeleteColumn(arg2,*arg3);
46307     } CALL_CATCH_EXCEPTION();
46308   }
46309
46310 }
46311
46312
46313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46315   unsigned int arg2 ;
46316   unsigned int arg3 ;
46317
46318   arg1 = (Dali::Toolkit::TableView *)jarg1;
46319   arg2 = (unsigned int)jarg2;
46320   arg3 = (unsigned int)jarg3;
46321   {
46322     try {
46323       (arg1)->Resize(arg2,arg3);
46324     } CALL_CATCH_EXCEPTION();
46325   }
46326
46327 }
46328
46329
46330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46331   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46332   unsigned int arg2 ;
46333   unsigned int arg3 ;
46334   std::vector< Dali::Actor > *arg4 = 0 ;
46335
46336   arg1 = (Dali::Toolkit::TableView *)jarg1;
46337   arg2 = (unsigned int)jarg2;
46338   arg3 = (unsigned int)jarg3;
46339   arg4 = (std::vector< Dali::Actor > *)jarg4;
46340   if (!arg4) {
46341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46342     return ;
46343   }
46344   {
46345     try {
46346       (arg1)->Resize(arg2,arg3,*arg4);
46347     } CALL_CATCH_EXCEPTION();
46348   }
46349
46350 }
46351
46352
46353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46355   Dali::Size arg2 ;
46356   Dali::Size *argp2 ;
46357
46358   arg1 = (Dali::Toolkit::TableView *)jarg1;
46359   argp2 = (Dali::Size *)jarg2;
46360   if (!argp2) {
46361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46362     return ;
46363   }
46364   arg2 = *argp2;
46365   {
46366     try {
46367       (arg1)->SetCellPadding(arg2);
46368     } CALL_CATCH_EXCEPTION();
46369   }
46370
46371 }
46372
46373
46374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46375   void * jresult ;
46376   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46377   Dali::Size result;
46378
46379   arg1 = (Dali::Toolkit::TableView *)jarg1;
46380   {
46381     try {
46382       result = (arg1)->GetCellPadding();
46383     } CALL_CATCH_EXCEPTION(0);
46384   }
46385
46386   jresult = new Dali::Size((const Dali::Size &)result);
46387   return jresult;
46388 }
46389
46390
46391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46392   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46393   unsigned int arg2 ;
46394
46395   arg1 = (Dali::Toolkit::TableView *)jarg1;
46396   arg2 = (unsigned int)jarg2;
46397   {
46398     try {
46399       (arg1)->SetFitHeight(arg2);
46400     } CALL_CATCH_EXCEPTION();
46401   }
46402
46403 }
46404
46405
46406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46407   unsigned int jresult ;
46408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46409   unsigned int arg2 ;
46410   bool result;
46411
46412   arg1 = (Dali::Toolkit::TableView *)jarg1;
46413   arg2 = (unsigned int)jarg2;
46414   {
46415     try {
46416       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46417     } CALL_CATCH_EXCEPTION(0);
46418   }
46419
46420   jresult = result;
46421   return jresult;
46422 }
46423
46424
46425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46426   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46427   unsigned int arg2 ;
46428
46429   arg1 = (Dali::Toolkit::TableView *)jarg1;
46430   arg2 = (unsigned int)jarg2;
46431   {
46432     try {
46433       (arg1)->SetFitWidth(arg2);
46434     } CALL_CATCH_EXCEPTION();
46435   }
46436
46437 }
46438
46439
46440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46441   unsigned int jresult ;
46442   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46443   unsigned int arg2 ;
46444   bool result;
46445
46446   arg1 = (Dali::Toolkit::TableView *)jarg1;
46447   arg2 = (unsigned int)jarg2;
46448   {
46449     try {
46450       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46451     } CALL_CATCH_EXCEPTION(0);
46452   }
46453
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46460   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46461   unsigned int arg2 ;
46462   float arg3 ;
46463
46464   arg1 = (Dali::Toolkit::TableView *)jarg1;
46465   arg2 = (unsigned int)jarg2;
46466   arg3 = (float)jarg3;
46467   {
46468     try {
46469       (arg1)->SetFixedHeight(arg2,arg3);
46470     } CALL_CATCH_EXCEPTION();
46471   }
46472
46473 }
46474
46475
46476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46477   float jresult ;
46478   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46479   unsigned int arg2 ;
46480   float result;
46481
46482   arg1 = (Dali::Toolkit::TableView *)jarg1;
46483   arg2 = (unsigned int)jarg2;
46484   {
46485     try {
46486       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46487     } CALL_CATCH_EXCEPTION(0);
46488   }
46489
46490   jresult = result;
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46496   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46497   unsigned int arg2 ;
46498   float arg3 ;
46499
46500   arg1 = (Dali::Toolkit::TableView *)jarg1;
46501   arg2 = (unsigned int)jarg2;
46502   arg3 = (float)jarg3;
46503   {
46504     try {
46505       (arg1)->SetRelativeHeight(arg2,arg3);
46506     } CALL_CATCH_EXCEPTION();
46507   }
46508
46509 }
46510
46511
46512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
46513   float jresult ;
46514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46515   unsigned int arg2 ;
46516   float result;
46517
46518   arg1 = (Dali::Toolkit::TableView *)jarg1;
46519   arg2 = (unsigned int)jarg2;
46520   {
46521     try {
46522       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
46523     } CALL_CATCH_EXCEPTION(0);
46524   }
46525
46526   jresult = result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46533   unsigned int arg2 ;
46534   float arg3 ;
46535
46536   arg1 = (Dali::Toolkit::TableView *)jarg1;
46537   arg2 = (unsigned int)jarg2;
46538   arg3 = (float)jarg3;
46539   {
46540     try {
46541       (arg1)->SetFixedWidth(arg2,arg3);
46542     } CALL_CATCH_EXCEPTION();
46543   }
46544
46545 }
46546
46547
46548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
46549   float jresult ;
46550   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46551   unsigned int arg2 ;
46552   float result;
46553
46554   arg1 = (Dali::Toolkit::TableView *)jarg1;
46555   arg2 = (unsigned int)jarg2;
46556   {
46557     try {
46558       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
46559     } CALL_CATCH_EXCEPTION(0);
46560   }
46561
46562   jresult = result;
46563   return jresult;
46564 }
46565
46566
46567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46569   unsigned int arg2 ;
46570   float arg3 ;
46571
46572   arg1 = (Dali::Toolkit::TableView *)jarg1;
46573   arg2 = (unsigned int)jarg2;
46574   arg3 = (float)jarg3;
46575   {
46576     try {
46577       (arg1)->SetRelativeWidth(arg2,arg3);
46578     } CALL_CATCH_EXCEPTION();
46579   }
46580
46581 }
46582
46583
46584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
46585   float jresult ;
46586   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46587   unsigned int arg2 ;
46588   float result;
46589
46590   arg1 = (Dali::Toolkit::TableView *)jarg1;
46591   arg2 = (unsigned int)jarg2;
46592   {
46593     try {
46594       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
46595     } CALL_CATCH_EXCEPTION(0);
46596   }
46597
46598   jresult = result;
46599   return jresult;
46600 }
46601
46602
46603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46604   unsigned int jresult ;
46605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46606   unsigned int result;
46607
46608   arg1 = (Dali::Toolkit::TableView *)jarg1;
46609   {
46610     try {
46611       result = (unsigned int)(arg1)->GetRows();
46612     } CALL_CATCH_EXCEPTION(0);
46613   }
46614
46615   jresult = result;
46616   return jresult;
46617 }
46618
46619
46620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
46621   unsigned int jresult ;
46622   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46623   unsigned int result;
46624
46625   arg1 = (Dali::Toolkit::TableView *)jarg1;
46626   {
46627     try {
46628       result = (unsigned int)(arg1)->GetColumns();
46629     } CALL_CATCH_EXCEPTION(0);
46630   }
46631
46632   jresult = result;
46633   return jresult;
46634 }
46635
46636
46637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46638   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46639   Dali::Toolkit::TableView::CellPosition arg2 ;
46640   Dali::HorizontalAlignment::Type arg3 ;
46641   Dali::VerticalAlignment::Type arg4 ;
46642   Dali::Toolkit::TableView::CellPosition *argp2 ;
46643
46644   arg1 = (Dali::Toolkit::TableView *)jarg1;
46645   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46646   if (!argp2) {
46647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46648     return ;
46649   }
46650   arg2 = *argp2;
46651   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46652   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46653   {
46654     try {
46655       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46656     } CALL_CATCH_EXCEPTION();
46657   }
46658
46659 }
46660
46661
46662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46663   unsigned int jresult ;
46664   unsigned int result;
46665
46666   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46667   jresult = result;
46668   return jresult;
46669 }
46670
46671
46672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46673   int jresult ;
46674   int result;
46675
46676   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46677   jresult = (int)result;
46678   return jresult;
46679 }
46680
46681
46682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46683   int jresult ;
46684   int result;
46685
46686   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46687   jresult = (int)result;
46688   return jresult;
46689 }
46690
46691
46692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46693   int jresult ;
46694   int result;
46695
46696   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46697   jresult = (int)result;
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46703   int jresult ;
46704   int result;
46705
46706   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46707   jresult = (int)result;
46708   return jresult;
46709 }
46710
46711
46712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46713   int jresult ;
46714   int result;
46715
46716   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46717   jresult = (int)result;
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46723   int jresult ;
46724   int result;
46725
46726   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46727   jresult = (int)result;
46728   return jresult;
46729 }
46730
46731
46732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46733   int jresult ;
46734   int result;
46735
46736   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46737   jresult = (int)result;
46738   return jresult;
46739 }
46740
46741
46742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46743   int jresult ;
46744   int result;
46745
46746   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46747   jresult = (int)result;
46748   return jresult;
46749 }
46750
46751
46752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46753   int jresult ;
46754   int result;
46755
46756   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46757   jresult = (int)result;
46758   return jresult;
46759 }
46760
46761
46762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
46763   int jresult ;
46764   int result;
46765
46766   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
46767   jresult = (int)result;
46768   return jresult;
46769 }
46770
46771
46772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
46773   int jresult ;
46774   int result;
46775
46776   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
46777   jresult = (int)result;
46778   return jresult;
46779 }
46780
46781
46782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
46783   int jresult ;
46784   int result;
46785
46786   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
46787   jresult = (int)result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
46793   int jresult ;
46794   int result;
46795
46796   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
46797   jresult = (int)result;
46798   return jresult;
46799 }
46800
46801
46802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
46803   int jresult ;
46804   int result;
46805
46806   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
46807   jresult = (int)result;
46808   return jresult;
46809 }
46810
46811
46812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
46813   int jresult ;
46814   int result;
46815
46816   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
46817   jresult = (int)result;
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
46823   int jresult ;
46824   int result;
46825
46826   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
46827   jresult = (int)result;
46828   return jresult;
46829 }
46830
46831
46832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
46833   int jresult ;
46834   int result;
46835
46836   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
46837   jresult = (int)result;
46838   return jresult;
46839 }
46840
46841
46842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
46843   int jresult ;
46844   int result;
46845
46846   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
46847   jresult = (int)result;
46848   return jresult;
46849 }
46850
46851
46852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
46853   void * jresult ;
46854   Dali::Toolkit::TextLabel::Property *result = 0 ;
46855
46856   {
46857     try {
46858       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
46859     } CALL_CATCH_EXCEPTION(0);
46860   }
46861
46862   jresult = (void *)result;
46863   return jresult;
46864 }
46865
46866
46867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
46868   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
46869
46870   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
46871   {
46872     try {
46873       delete arg1;
46874     } CALL_CATCH_EXCEPTION();
46875   }
46876
46877 }
46878
46879
46880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
46881   void * jresult ;
46882   Dali::Toolkit::TextLabel result;
46883
46884   {
46885     try {
46886       result = Dali::Toolkit::TextLabel::New();
46887     } CALL_CATCH_EXCEPTION(0);
46888   }
46889
46890   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
46891   return jresult;
46892 }
46893
46894
46895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
46896   void * jresult ;
46897   std::string *arg1 = 0 ;
46898   Dali::Toolkit::TextLabel result;
46899
46900   if (!jarg1) {
46901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46902     return 0;
46903   }
46904   std::string arg1_str(jarg1);
46905   arg1 = &arg1_str;
46906   {
46907     try {
46908       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
46909     } CALL_CATCH_EXCEPTION(0);
46910   }
46911
46912   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
46913
46914   //argout typemap for const std::string&
46915
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
46921   void * jresult ;
46922   Dali::Toolkit::TextLabel *result = 0 ;
46923
46924   {
46925     try {
46926       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
46927     } CALL_CATCH_EXCEPTION(0);
46928   }
46929
46930   jresult = (void *)result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
46936   void * jresult ;
46937   Dali::Toolkit::TextLabel *arg1 = 0 ;
46938   Dali::Toolkit::TextLabel *result = 0 ;
46939
46940   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46941   if (!arg1) {
46942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
46943     return 0;
46944   }
46945   {
46946     try {
46947       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
46948     } CALL_CATCH_EXCEPTION(0);
46949   }
46950
46951   jresult = (void *)result;
46952   return jresult;
46953 }
46954
46955
46956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
46957   void * jresult ;
46958   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
46959   Dali::Toolkit::TextLabel *arg2 = 0 ;
46960   Dali::Toolkit::TextLabel *result = 0 ;
46961
46962   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46963   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
46964   if (!arg2) {
46965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
46966     return 0;
46967   }
46968   {
46969     try {
46970       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
46971     } CALL_CATCH_EXCEPTION(0);
46972   }
46973
46974   jresult = (void *)result;
46975   return jresult;
46976 }
46977
46978
46979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
46980   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
46981
46982   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46983   {
46984     try {
46985       delete arg1;
46986     } CALL_CATCH_EXCEPTION();
46987   }
46988
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
46993   void * jresult ;
46994   Dali::BaseHandle arg1 ;
46995   Dali::BaseHandle *argp1 ;
46996   Dali::Toolkit::TextLabel result;
46997
46998   argp1 = (Dali::BaseHandle *)jarg1;
46999   if (!argp1) {
47000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47001     return 0;
47002   }
47003   arg1 = *argp1;
47004   {
47005     try {
47006       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47007     } CALL_CATCH_EXCEPTION(0);
47008   }
47009
47010   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47011   return jresult;
47012 }
47013
47014
47015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47016   void * jresult ;
47017   Dali::Toolkit::AccessibilityManager *result = 0 ;
47018
47019   {
47020     try {
47021       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47022     } CALL_CATCH_EXCEPTION(0);
47023   }
47024
47025   jresult = (void *)result;
47026   return jresult;
47027 }
47028
47029
47030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47032
47033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47034   {
47035     try {
47036       delete arg1;
47037     } CALL_CATCH_EXCEPTION();
47038   }
47039
47040 }
47041
47042
47043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47044   void * jresult ;
47045   Dali::Toolkit::AccessibilityManager result;
47046
47047   {
47048     try {
47049       result = Dali::Toolkit::AccessibilityManager::Get();
47050     } CALL_CATCH_EXCEPTION(0);
47051   }
47052
47053   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47054   return jresult;
47055 }
47056
47057
47058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47060   Dali::Actor arg2 ;
47061   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47062   std::string *arg4 = 0 ;
47063   Dali::Actor *argp2 ;
47064
47065   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47066   argp2 = (Dali::Actor *)jarg2;
47067   if (!argp2) {
47068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47069     return ;
47070   }
47071   arg2 = *argp2;
47072   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47073   if (!jarg4) {
47074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47075     return ;
47076   }
47077   std::string arg4_str(jarg4);
47078   arg4 = &arg4_str;
47079   {
47080     try {
47081       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47082     } CALL_CATCH_EXCEPTION();
47083   }
47084
47085
47086   //argout typemap for const std::string&
47087
47088 }
47089
47090
47091 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47092   char * jresult ;
47093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47094   Dali::Actor arg2 ;
47095   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47096   Dali::Actor *argp2 ;
47097   std::string result;
47098
47099   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47100   argp2 = (Dali::Actor *)jarg2;
47101   if (!argp2) {
47102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47103     return 0;
47104   }
47105   arg2 = *argp2;
47106   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47107   {
47108     try {
47109       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47110     } CALL_CATCH_EXCEPTION(0);
47111   }
47112
47113   jresult = SWIG_csharp_string_callback((&result)->c_str());
47114   return jresult;
47115 }
47116
47117
47118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47119   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47120   Dali::Actor arg2 ;
47121   unsigned int arg3 ;
47122   Dali::Actor *argp2 ;
47123
47124   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47125   argp2 = (Dali::Actor *)jarg2;
47126   if (!argp2) {
47127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47128     return ;
47129   }
47130   arg2 = *argp2;
47131   arg3 = (unsigned int)jarg3;
47132   {
47133     try {
47134       (arg1)->SetFocusOrder(arg2,arg3);
47135     } CALL_CATCH_EXCEPTION();
47136   }
47137
47138 }
47139
47140
47141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47142   unsigned int jresult ;
47143   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47144   Dali::Actor arg2 ;
47145   Dali::Actor *argp2 ;
47146   unsigned int result;
47147
47148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47149   argp2 = (Dali::Actor *)jarg2;
47150   if (!argp2) {
47151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47152     return 0;
47153   }
47154   arg2 = *argp2;
47155   {
47156     try {
47157       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47158     } CALL_CATCH_EXCEPTION(0);
47159   }
47160
47161   jresult = result;
47162   return jresult;
47163 }
47164
47165
47166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47167   unsigned int jresult ;
47168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47169   unsigned int result;
47170
47171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47172   {
47173     try {
47174       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47175     } CALL_CATCH_EXCEPTION(0);
47176   }
47177
47178   jresult = result;
47179   return jresult;
47180 }
47181
47182
47183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47184   void * jresult ;
47185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47186   unsigned int arg2 ;
47187   Dali::Actor result;
47188
47189   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47190   arg2 = (unsigned int)jarg2;
47191   {
47192     try {
47193       result = (arg1)->GetActorByFocusOrder(arg2);
47194     } CALL_CATCH_EXCEPTION(0);
47195   }
47196
47197   jresult = new Dali::Actor((const Dali::Actor &)result);
47198   return jresult;
47199 }
47200
47201
47202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47203   unsigned int jresult ;
47204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47205   Dali::Actor arg2 ;
47206   Dali::Actor *argp2 ;
47207   bool result;
47208
47209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47210   argp2 = (Dali::Actor *)jarg2;
47211   if (!argp2) {
47212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47213     return 0;
47214   }
47215   arg2 = *argp2;
47216   {
47217     try {
47218       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47219     } CALL_CATCH_EXCEPTION(0);
47220   }
47221
47222   jresult = result;
47223   return jresult;
47224 }
47225
47226
47227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47228   void * jresult ;
47229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47230   Dali::Actor result;
47231
47232   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47233   {
47234     try {
47235       result = (arg1)->GetCurrentFocusActor();
47236     } CALL_CATCH_EXCEPTION(0);
47237   }
47238
47239   jresult = new Dali::Actor((const Dali::Actor &)result);
47240   return jresult;
47241 }
47242
47243
47244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47245   void * jresult ;
47246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47247   Dali::Actor result;
47248
47249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47250   {
47251     try {
47252       result = (arg1)->GetCurrentFocusGroup();
47253     } CALL_CATCH_EXCEPTION(0);
47254   }
47255
47256   jresult = new Dali::Actor((const Dali::Actor &)result);
47257   return jresult;
47258 }
47259
47260
47261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47262   unsigned int jresult ;
47263   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47264   unsigned int result;
47265
47266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47267   {
47268     try {
47269       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47270     } CALL_CATCH_EXCEPTION(0);
47271   }
47272
47273   jresult = result;
47274   return jresult;
47275 }
47276
47277
47278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47279   unsigned int jresult ;
47280   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47281   bool result;
47282
47283   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47284   {
47285     try {
47286       result = (bool)(arg1)->MoveFocusForward();
47287     } CALL_CATCH_EXCEPTION(0);
47288   }
47289
47290   jresult = result;
47291   return jresult;
47292 }
47293
47294
47295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
47296   unsigned int jresult ;
47297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47298   bool result;
47299
47300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47301   {
47302     try {
47303       result = (bool)(arg1)->MoveFocusBackward();
47304     } CALL_CATCH_EXCEPTION(0);
47305   }
47306
47307   jresult = result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47314
47315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47316   {
47317     try {
47318       (arg1)->ClearFocus();
47319     } CALL_CATCH_EXCEPTION();
47320   }
47321
47322 }
47323
47324
47325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47327
47328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47329   {
47330     try {
47331       (arg1)->Reset();
47332     } CALL_CATCH_EXCEPTION();
47333   }
47334
47335 }
47336
47337
47338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47340   Dali::Actor arg2 ;
47341   bool 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 = jarg3 ? true : false;
47352   {
47353     try {
47354       (arg1)->SetFocusGroup(arg2,arg3);
47355     } CALL_CATCH_EXCEPTION();
47356   }
47357
47358 }
47359
47360
47361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(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   bool 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 = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47378     } CALL_CATCH_EXCEPTION(0);
47379   }
47380
47381   jresult = result;
47382   return jresult;
47383 }
47384
47385
47386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47388   bool arg2 ;
47389
47390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47391   arg2 = jarg2 ? true : false;
47392   {
47393     try {
47394       (arg1)->SetGroupMode(arg2);
47395     } CALL_CATCH_EXCEPTION();
47396   }
47397
47398 }
47399
47400
47401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47402   unsigned int jresult ;
47403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47404   bool result;
47405
47406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47407   {
47408     try {
47409       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47410     } CALL_CATCH_EXCEPTION(0);
47411   }
47412
47413   jresult = result;
47414   return jresult;
47415 }
47416
47417
47418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47419   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47420   bool arg2 ;
47421
47422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47423   arg2 = jarg2 ? true : false;
47424   {
47425     try {
47426       (arg1)->SetWrapMode(arg2);
47427     } CALL_CATCH_EXCEPTION();
47428   }
47429
47430 }
47431
47432
47433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47434   unsigned int jresult ;
47435   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47436   bool result;
47437
47438   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47439   {
47440     try {
47441       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47442     } CALL_CATCH_EXCEPTION(0);
47443   }
47444
47445   jresult = result;
47446   return jresult;
47447 }
47448
47449
47450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47452   Dali::Actor arg2 ;
47453   Dali::Actor *argp2 ;
47454
47455   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47456   argp2 = (Dali::Actor *)jarg2;
47457   if (!argp2) {
47458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47459     return ;
47460   }
47461   arg2 = *argp2;
47462   {
47463     try {
47464       (arg1)->SetFocusIndicatorActor(arg2);
47465     } CALL_CATCH_EXCEPTION();
47466   }
47467
47468 }
47469
47470
47471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47472   void * jresult ;
47473   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47474   Dali::Actor result;
47475
47476   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47477   {
47478     try {
47479       result = (arg1)->GetFocusIndicatorActor();
47480     } CALL_CATCH_EXCEPTION(0);
47481   }
47482
47483   jresult = new Dali::Actor((const Dali::Actor &)result);
47484   return jresult;
47485 }
47486
47487
47488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47489   void * jresult ;
47490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47491   Dali::Actor arg2 ;
47492   Dali::Actor *argp2 ;
47493   Dali::Actor result;
47494
47495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47496   argp2 = (Dali::Actor *)jarg2;
47497   if (!argp2) {
47498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47499     return 0;
47500   }
47501   arg2 = *argp2;
47502   {
47503     try {
47504       result = (arg1)->GetFocusGroup(arg2);
47505     } CALL_CATCH_EXCEPTION(0);
47506   }
47507
47508   jresult = new Dali::Actor((const Dali::Actor &)result);
47509   return jresult;
47510 }
47511
47512
47513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47514   void * jresult ;
47515   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47516   Dali::Vector2 result;
47517
47518   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47519   {
47520     try {
47521       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47522     } CALL_CATCH_EXCEPTION(0);
47523   }
47524
47525   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47526   return jresult;
47527 }
47528
47529
47530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47531   void * jresult ;
47532   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47533   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47534
47535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47536   {
47537     try {
47538       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47539     } CALL_CATCH_EXCEPTION(0);
47540   }
47541
47542   jresult = (void *)result;
47543   return jresult;
47544 }
47545
47546
47547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47548   void * jresult ;
47549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47550   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47551
47552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47553   {
47554     try {
47555       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47556     } CALL_CATCH_EXCEPTION(0);
47557   }
47558
47559   jresult = (void *)result;
47560   return jresult;
47561 }
47562
47563
47564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47565   void * jresult ;
47566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47567   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47568
47569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47570   {
47571     try {
47572       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47573     } CALL_CATCH_EXCEPTION(0);
47574   }
47575
47576   jresult = (void *)result;
47577   return jresult;
47578 }
47579
47580
47581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47582   void * jresult ;
47583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47584   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47585
47586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47587   {
47588     try {
47589       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47590     } CALL_CATCH_EXCEPTION(0);
47591   }
47592
47593   jresult = (void *)result;
47594   return jresult;
47595 }
47596
47597
47598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
47599   void * jresult ;
47600   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47601   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47602
47603   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47604   {
47605     try {
47606       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
47607     } CALL_CATCH_EXCEPTION(0);
47608   }
47609
47610   jresult = (void *)result;
47611   return jresult;
47612 }
47613
47614
47615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
47616   void * jresult ;
47617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47618   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47619
47620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47621   {
47622     try {
47623       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
47624     } CALL_CATCH_EXCEPTION(0);
47625   }
47626
47627   jresult = (void *)result;
47628   return jresult;
47629 }
47630
47631
47632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
47633   void * jresult ;
47634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47635   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47636
47637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47638   {
47639     try {
47640       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
47641     } CALL_CATCH_EXCEPTION(0);
47642   }
47643
47644   jresult = (void *)result;
47645   return jresult;
47646 }
47647
47648
47649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
47650   void * jresult ;
47651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47652   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47653
47654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47655   {
47656     try {
47657       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
47658     } CALL_CATCH_EXCEPTION(0);
47659   }
47660
47661   jresult = (void *)result;
47662   return jresult;
47663 }
47664
47665
47666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
47667   void * jresult ;
47668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47669   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47670
47671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47672   {
47673     try {
47674       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
47675     } CALL_CATCH_EXCEPTION(0);
47676   }
47677
47678   jresult = (void *)result;
47679   return jresult;
47680 }
47681
47682
47683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
47684   void * jresult ;
47685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47686   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47687
47688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47689   {
47690     try {
47691       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
47692     } CALL_CATCH_EXCEPTION(0);
47693   }
47694
47695   jresult = (void *)result;
47696   return jresult;
47697 }
47698
47699
47700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
47701   void * jresult ;
47702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47703   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47704
47705   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47706   {
47707     try {
47708       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
47709     } CALL_CATCH_EXCEPTION(0);
47710   }
47711
47712   jresult = (void *)result;
47713   return jresult;
47714 }
47715
47716
47717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
47718   void * jresult ;
47719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47720   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47721
47722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47723   {
47724     try {
47725       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
47726     } CALL_CATCH_EXCEPTION(0);
47727   }
47728
47729   jresult = (void *)result;
47730   return jresult;
47731 }
47732
47733
47734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
47735   void * jresult ;
47736   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47737   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47738
47739   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47740   {
47741     try {
47742       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
47743     } CALL_CATCH_EXCEPTION(0);
47744   }
47745
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
47752   void * jresult ;
47753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47754   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47755
47756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47757   {
47758     try {
47759       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
47760     } CALL_CATCH_EXCEPTION(0);
47761   }
47762
47763   jresult = (void *)result;
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
47769   void * jresult ;
47770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47771   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47772
47773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47774   {
47775     try {
47776       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
47777     } CALL_CATCH_EXCEPTION(0);
47778   }
47779
47780   jresult = (void *)result;
47781   return jresult;
47782 }
47783
47784
47785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
47786   void * jresult ;
47787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47789
47790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47791   {
47792     try {
47793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
47794     } CALL_CATCH_EXCEPTION(0);
47795   }
47796
47797   jresult = (void *)result;
47798   return jresult;
47799 }
47800
47801
47802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
47803   void * jresult ;
47804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47805   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47806
47807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47808   {
47809     try {
47810       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
47811     } CALL_CATCH_EXCEPTION(0);
47812   }
47813
47814   jresult = (void *)result;
47815   return jresult;
47816 }
47817
47818
47819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
47820   void * jresult ;
47821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47822   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47823
47824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47825   {
47826     try {
47827       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
47828     } CALL_CATCH_EXCEPTION(0);
47829   }
47830
47831   jresult = (void *)result;
47832   return jresult;
47833 }
47834
47835
47836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
47837   void * jresult ;
47838   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47839   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47840
47841   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47842   {
47843     try {
47844       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
47845     } CALL_CATCH_EXCEPTION(0);
47846   }
47847
47848   jresult = (void *)result;
47849   return jresult;
47850 }
47851
47852
47853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
47854   void * jresult ;
47855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47856   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47857
47858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47859   {
47860     try {
47861       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
47862     } CALL_CATCH_EXCEPTION(0);
47863   }
47864
47865   jresult = (void *)result;
47866   return jresult;
47867 }
47868
47869
47870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
47871   void * jresult ;
47872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47873   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47874
47875   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47876   {
47877     try {
47878       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
47879     } CALL_CATCH_EXCEPTION(0);
47880   }
47881
47882   jresult = (void *)result;
47883   return jresult;
47884 }
47885
47886
47887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
47888   void * jresult ;
47889   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47890   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47891
47892   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47893   {
47894     try {
47895       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
47896     } CALL_CATCH_EXCEPTION(0);
47897   }
47898
47899   jresult = (void *)result;
47900   return jresult;
47901 }
47902
47903
47904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
47905   void * jresult ;
47906   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47907   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47908
47909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47910   {
47911     try {
47912       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
47913     } CALL_CATCH_EXCEPTION(0);
47914   }
47915
47916   jresult = (void *)result;
47917   return jresult;
47918 }
47919
47920
47921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
47922   void * jresult ;
47923   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47924   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47925
47926   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47927   {
47928     try {
47929       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
47930     } CALL_CATCH_EXCEPTION(0);
47931   }
47932
47933   jresult = (void *)result;
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
47939   void * jresult ;
47940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47941   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47942
47943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47944   {
47945     try {
47946       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
47947     } CALL_CATCH_EXCEPTION(0);
47948   }
47949
47950   jresult = (void *)result;
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
47956   void * jresult ;
47957   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47958   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47959
47960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47961   {
47962     try {
47963       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
47964     } CALL_CATCH_EXCEPTION(0);
47965   }
47966
47967   jresult = (void *)result;
47968   return jresult;
47969 }
47970
47971
47972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
47973   void * jresult ;
47974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47975   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47976
47977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47978   {
47979     try {
47980       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
47981     } CALL_CATCH_EXCEPTION(0);
47982   }
47983
47984   jresult = (void *)result;
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
47990   void * jresult ;
47991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47992   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47993
47994   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47995   {
47996     try {
47997       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
47998     } CALL_CATCH_EXCEPTION(0);
47999   }
48000
48001   jresult = (void *)result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48007   void * jresult ;
48008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48009   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48010
48011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48012   {
48013     try {
48014       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48015     } CALL_CATCH_EXCEPTION(0);
48016   }
48017
48018   jresult = (void *)result;
48019   return jresult;
48020 }
48021
48022
48023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48024   void * jresult ;
48025   Dali::Toolkit::StyleManager *result = 0 ;
48026
48027   {
48028     try {
48029       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48030     } CALL_CATCH_EXCEPTION(0);
48031   }
48032
48033   jresult = (void *)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48039   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48040
48041   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48042   {
48043     try {
48044       delete arg1;
48045     } CALL_CATCH_EXCEPTION();
48046   }
48047
48048 }
48049
48050
48051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48052   void * jresult ;
48053   Dali::Toolkit::StyleManager result;
48054
48055   {
48056     try {
48057       result = Dali::Toolkit::StyleManager::Get();
48058     } CALL_CATCH_EXCEPTION(0);
48059   }
48060
48061   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48062   return jresult;
48063 }
48064
48065
48066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48067   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48068   std::string *arg2 = 0 ;
48069
48070   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48071   if (!jarg2) {
48072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48073     return ;
48074   }
48075   std::string arg2_str(jarg2);
48076   arg2 = &arg2_str;
48077   {
48078     try {
48079       (arg1)->ApplyTheme((std::string const &)*arg2);
48080     } CALL_CATCH_EXCEPTION();
48081   }
48082
48083
48084   //argout typemap for const std::string&
48085
48086 }
48087
48088
48089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48090   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48091
48092   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48093   {
48094     try {
48095       (arg1)->ApplyDefaultTheme();
48096     } CALL_CATCH_EXCEPTION();
48097   }
48098
48099 }
48100
48101
48102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48103   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48104   std::string *arg2 = 0 ;
48105   Dali::Property::Value *arg3 = 0 ;
48106
48107   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48108   if (!jarg2) {
48109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48110     return ;
48111   }
48112   std::string arg2_str(jarg2);
48113   arg2 = &arg2_str;
48114   arg3 = (Dali::Property::Value *)jarg3;
48115   if (!arg3) {
48116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48117     return ;
48118   }
48119   {
48120     try {
48121       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48122     } CALL_CATCH_EXCEPTION();
48123   }
48124
48125
48126   //argout typemap for const std::string&
48127
48128 }
48129
48130
48131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48132   unsigned int jresult ;
48133   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48134   std::string *arg2 = 0 ;
48135   Dali::Property::Value *arg3 = 0 ;
48136   bool result;
48137
48138   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48139   if (!jarg2) {
48140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48141     return 0;
48142   }
48143   std::string arg2_str(jarg2);
48144   arg2 = &arg2_str;
48145   arg3 = (Dali::Property::Value *)jarg3;
48146   if (!arg3) {
48147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48148     return 0;
48149   }
48150   {
48151     try {
48152       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48153     } CALL_CATCH_EXCEPTION(0);
48154   }
48155
48156   jresult = result;
48157
48158   //argout typemap for const std::string&
48159
48160   return jresult;
48161 }
48162
48163
48164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48165   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48166   Dali::Toolkit::Control arg2 ;
48167   std::string *arg3 = 0 ;
48168   std::string *arg4 = 0 ;
48169   Dali::Toolkit::Control *argp2 ;
48170
48171   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48172   argp2 = (Dali::Toolkit::Control *)jarg2;
48173   if (!argp2) {
48174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48175     return ;
48176   }
48177   arg2 = *argp2;
48178   if (!jarg3) {
48179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48180     return ;
48181   }
48182   std::string arg3_str(jarg3);
48183   arg3 = &arg3_str;
48184   if (!jarg4) {
48185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48186     return ;
48187   }
48188   std::string arg4_str(jarg4);
48189   arg4 = &arg4_str;
48190   {
48191     try {
48192       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48193     } CALL_CATCH_EXCEPTION();
48194   }
48195
48196
48197   //argout typemap for const std::string&
48198
48199
48200   //argout typemap for const std::string&
48201
48202 }
48203
48204
48205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48206   void * jresult ;
48207   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48208   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48209
48210   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48211   {
48212     try {
48213       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48214     } CALL_CATCH_EXCEPTION(0);
48215   }
48216
48217   jresult = (void *)result;
48218   return jresult;
48219 }
48220
48221
48222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48223   int jresult ;
48224   int result;
48225
48226   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48227   jresult = (int)result;
48228   return jresult;
48229 }
48230
48231
48232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48233   int jresult ;
48234   int result;
48235
48236   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48237   jresult = (int)result;
48238   return jresult;
48239 }
48240
48241
48242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48243   int jresult ;
48244   int result;
48245
48246   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48247   jresult = (int)result;
48248   return jresult;
48249 }
48250
48251
48252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48253   int jresult ;
48254   int result;
48255
48256   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48257   jresult = (int)result;
48258   return jresult;
48259 }
48260
48261
48262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48263   int jresult ;
48264   int result;
48265
48266   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48267   jresult = (int)result;
48268   return jresult;
48269 }
48270
48271
48272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48273   int jresult ;
48274   int result;
48275
48276   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48277   jresult = (int)result;
48278   return jresult;
48279 }
48280
48281
48282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48283   int jresult ;
48284   int result;
48285
48286   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48287   jresult = (int)result;
48288   return jresult;
48289 }
48290
48291
48292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48293   int jresult ;
48294   int result;
48295
48296   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48297   jresult = (int)result;
48298   return jresult;
48299 }
48300
48301
48302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48303   int jresult ;
48304   int result;
48305
48306   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48307   jresult = (int)result;
48308   return jresult;
48309 }
48310
48311
48312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48313   int jresult ;
48314   int result;
48315
48316   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48317   jresult = (int)result;
48318   return jresult;
48319 }
48320
48321
48322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48323   int jresult ;
48324   int result;
48325
48326   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48327   jresult = (int)result;
48328   return jresult;
48329 }
48330
48331
48332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48333   int jresult ;
48334   int result;
48335
48336   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48337   jresult = (int)result;
48338   return jresult;
48339 }
48340
48341
48342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48343   int jresult ;
48344   int result;
48345
48346   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48347   jresult = (int)result;
48348   return jresult;
48349 }
48350
48351
48352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48353   int jresult ;
48354   int result;
48355
48356   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48357   jresult = (int)result;
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48363   int jresult ;
48364   int result;
48365
48366   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48367   jresult = (int)result;
48368   return jresult;
48369 }
48370
48371
48372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48373   void * jresult ;
48374   Dali::Toolkit::Slider::Property *result = 0 ;
48375
48376   {
48377     try {
48378       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48379     } CALL_CATCH_EXCEPTION(0);
48380   }
48381
48382   jresult = (void *)result;
48383   return jresult;
48384 }
48385
48386
48387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48388   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48389
48390   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48391   {
48392     try {
48393       delete arg1;
48394     } CALL_CATCH_EXCEPTION();
48395   }
48396
48397 }
48398
48399
48400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48401   void * jresult ;
48402   Dali::Toolkit::Slider result;
48403
48404   {
48405     try {
48406       result = Dali::Toolkit::Slider::New();
48407     } CALL_CATCH_EXCEPTION(0);
48408   }
48409
48410   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48411   return jresult;
48412 }
48413
48414
48415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48416   void * jresult ;
48417   Dali::Toolkit::Slider *result = 0 ;
48418
48419   {
48420     try {
48421       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48422     } CALL_CATCH_EXCEPTION(0);
48423   }
48424
48425   jresult = (void *)result;
48426   return jresult;
48427 }
48428
48429
48430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48431   void * jresult ;
48432   Dali::Toolkit::Slider *arg1 = 0 ;
48433   Dali::Toolkit::Slider *result = 0 ;
48434
48435   arg1 = (Dali::Toolkit::Slider *)jarg1;
48436   if (!arg1) {
48437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48438     return 0;
48439   }
48440   {
48441     try {
48442       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48443     } CALL_CATCH_EXCEPTION(0);
48444   }
48445
48446   jresult = (void *)result;
48447   return jresult;
48448 }
48449
48450
48451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48452   void * jresult ;
48453   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48454   Dali::Toolkit::Slider *arg2 = 0 ;
48455   Dali::Toolkit::Slider *result = 0 ;
48456
48457   arg1 = (Dali::Toolkit::Slider *)jarg1;
48458   arg2 = (Dali::Toolkit::Slider *)jarg2;
48459   if (!arg2) {
48460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48461     return 0;
48462   }
48463   {
48464     try {
48465       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48466     } CALL_CATCH_EXCEPTION(0);
48467   }
48468
48469   jresult = (void *)result;
48470   return jresult;
48471 }
48472
48473
48474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48475   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48476
48477   arg1 = (Dali::Toolkit::Slider *)jarg1;
48478   {
48479     try {
48480       delete arg1;
48481     } CALL_CATCH_EXCEPTION();
48482   }
48483
48484 }
48485
48486
48487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48488   void * jresult ;
48489   Dali::BaseHandle arg1 ;
48490   Dali::BaseHandle *argp1 ;
48491   Dali::Toolkit::Slider result;
48492
48493   argp1 = (Dali::BaseHandle *)jarg1;
48494   if (!argp1) {
48495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48496     return 0;
48497   }
48498   arg1 = *argp1;
48499   {
48500     try {
48501       result = Dali::Toolkit::Slider::DownCast(arg1);
48502     } CALL_CATCH_EXCEPTION(0);
48503   }
48504
48505   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48506   return jresult;
48507 }
48508
48509
48510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48511   void * jresult ;
48512   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48513   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48514
48515   arg1 = (Dali::Toolkit::Slider *)jarg1;
48516   {
48517     try {
48518       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48519     } CALL_CATCH_EXCEPTION(0);
48520   }
48521
48522   jresult = (void *)result;
48523   return jresult;
48524 }
48525
48526
48527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
48528   void * jresult ;
48529   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48530   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48531
48532   arg1 = (Dali::Toolkit::Slider *)jarg1;
48533   {
48534     try {
48535       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
48536     } CALL_CATCH_EXCEPTION(0);
48537   }
48538
48539   jresult = (void *)result;
48540   return jresult;
48541 }
48542
48543
48544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48545   void * jresult ;
48546   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48547   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48548
48549   arg1 = (Dali::Toolkit::Slider *)jarg1;
48550   {
48551     try {
48552       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48553     } CALL_CATCH_EXCEPTION(0);
48554   }
48555
48556   jresult = (void *)result;
48557   return jresult;
48558 }
48559
48560
48561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48562   int jresult ;
48563   int result;
48564
48565   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48566   jresult = (int)result;
48567   return jresult;
48568 }
48569
48570
48571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48572   int jresult ;
48573   int result;
48574
48575   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48576   jresult = (int)result;
48577   return jresult;
48578 }
48579
48580
48581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48582   int jresult ;
48583   int result;
48584
48585   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48586   jresult = (int)result;
48587   return jresult;
48588 }
48589
48590
48591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48592   int jresult ;
48593   int result;
48594
48595   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48596   jresult = (int)result;
48597   return jresult;
48598 }
48599
48600
48601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48602   int result;
48603
48604   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48605
48606   return result;
48607 }
48608
48609
48610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48611   void * jresult ;
48612   Dali::Toolkit::VideoView::Property *result = 0 ;
48613
48614   {
48615     try {
48616       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48617     } CALL_CATCH_EXCEPTION(0);
48618   }
48619
48620   jresult = (void *)result;
48621   return jresult;
48622 }
48623
48624
48625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48626   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48627
48628   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48629   {
48630     try {
48631       delete arg1;
48632     } CALL_CATCH_EXCEPTION();
48633   }
48634
48635 }
48636
48637
48638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48639   void * jresult ;
48640   Dali::Toolkit::VideoView result;
48641
48642   {
48643     try {
48644       result = Dali::Toolkit::VideoView::New();
48645     } CALL_CATCH_EXCEPTION(0);
48646   }
48647
48648   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48649   return jresult;
48650 }
48651
48652
48653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48654   void * jresult ;
48655   std::string *arg1 = 0 ;
48656   Dali::Toolkit::VideoView result;
48657
48658   if (!jarg1) {
48659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48660     return 0;
48661   }
48662   std::string arg1_str(jarg1);
48663   arg1 = &arg1_str;
48664   {
48665     try {
48666       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48667     } CALL_CATCH_EXCEPTION(0);
48668   }
48669
48670   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48671
48672   //argout typemap for const std::string&
48673
48674   return jresult;
48675 }
48676
48677
48678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48679   void * jresult ;
48680   Dali::Toolkit::VideoView result;
48681   {
48682     try {
48683       result = Dali::Toolkit::VideoView::New(swCodec);
48684     } CALL_CATCH_EXCEPTION(0);
48685   }
48686
48687   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48688
48689   //argout typemap for const std::string&
48690
48691   return jresult;
48692 }
48693
48694
48695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
48696   void * jresult ;
48697   std::string *arg1 = 0 ;
48698   Dali::Toolkit::VideoView result;
48699
48700   if (!jarg1) {
48701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48702     return 0;
48703   }
48704   std::string arg1_str(jarg1);
48705   arg1 = &arg1_str;
48706   {
48707     try {
48708       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48709     } CALL_CATCH_EXCEPTION(0);
48710   }
48711
48712   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48713
48714   //argout typemap for const std::string&
48715
48716   return jresult;
48717 }
48718
48719
48720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48721   void * jresult ;
48722   Dali::Toolkit::VideoView *result = 0 ;
48723
48724   {
48725     try {
48726       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48727     } CALL_CATCH_EXCEPTION(0);
48728   }
48729
48730   jresult = (void *)result;
48731   return jresult;
48732 }
48733
48734
48735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48736   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48737
48738   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48739   {
48740     try {
48741       delete arg1;
48742     } CALL_CATCH_EXCEPTION();
48743   }
48744
48745 }
48746
48747
48748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48749   void * jresult ;
48750   Dali::Toolkit::VideoView *arg1 = 0 ;
48751   Dali::Toolkit::VideoView *result = 0 ;
48752
48753   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48754   if (!arg1) {
48755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48756     return 0;
48757   }
48758   {
48759     try {
48760       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48761     } CALL_CATCH_EXCEPTION(0);
48762   }
48763
48764   jresult = (void *)result;
48765   return jresult;
48766 }
48767
48768
48769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
48770   void * jresult ;
48771   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48772   Dali::Toolkit::VideoView *arg2 = 0 ;
48773   Dali::Toolkit::VideoView *result = 0 ;
48774
48775   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48776   arg2 = (Dali::Toolkit::VideoView *)jarg2;
48777   if (!arg2) {
48778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48779     return 0;
48780   }
48781   {
48782     try {
48783       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
48784     } CALL_CATCH_EXCEPTION(0);
48785   }
48786
48787   jresult = (void *)result;
48788   return jresult;
48789 }
48790
48791
48792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
48793   void * jresult ;
48794   Dali::BaseHandle arg1 ;
48795   Dali::BaseHandle *argp1 ;
48796   Dali::Toolkit::VideoView result;
48797
48798   argp1 = (Dali::BaseHandle *)jarg1;
48799   if (!argp1) {
48800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48801     return 0;
48802   }
48803   arg1 = *argp1;
48804   {
48805     try {
48806       result = Dali::Toolkit::VideoView::DownCast(arg1);
48807     } CALL_CATCH_EXCEPTION(0);
48808   }
48809
48810   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48811   return jresult;
48812 }
48813
48814
48815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
48816   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48817
48818   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48819   {
48820     try {
48821       (arg1)->Play();
48822     } CALL_CATCH_EXCEPTION();
48823   }
48824
48825 }
48826
48827
48828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
48829   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48830
48831   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48832   {
48833     try {
48834       (arg1)->Pause();
48835     } CALL_CATCH_EXCEPTION();
48836   }
48837
48838 }
48839
48840
48841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
48842   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48843
48844   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48845   {
48846     try {
48847       (arg1)->Stop();
48848     } CALL_CATCH_EXCEPTION();
48849   }
48850
48851 }
48852
48853
48854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
48855   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48856   int arg2 ;
48857
48858   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48859   arg2 = (int)jarg2;
48860   {
48861     try {
48862       (arg1)->Forward(arg2);
48863     } CALL_CATCH_EXCEPTION();
48864   }
48865
48866 }
48867
48868
48869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
48870   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48871   int arg2 ;
48872
48873   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48874   arg2 = (int)jarg2;
48875   {
48876     try {
48877       (arg1)->Backward(arg2);
48878     } CALL_CATCH_EXCEPTION();
48879   }
48880
48881 }
48882
48883
48884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
48885   void * jresult ;
48886   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48887   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
48888
48889   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48890   {
48891     try {
48892       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
48893     } CALL_CATCH_EXCEPTION(0);
48894   }
48895
48896   jresult = (void *)result;
48897   return jresult;
48898 }
48899
48900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
48901 {
48902   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
48903   if( arg1 == nullptr )
48904   {
48905     DALI_LOG_ERROR("VideoView is nullptr!");
48906     return nullptr;
48907   }
48908   void * ret = nullptr;
48909   {
48910     try{
48911
48912       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
48913       ret = Dali::AnyCast< void * >( result );
48914
48915     } CALL_CATCH_EXCEPTION(0);
48916   }
48917   return ret;
48918 }
48919
48920
48921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
48922   int jresult ;
48923   int result;
48924
48925   result = (int)Dali::Toolkit::Popup::Property::TITLE;
48926   jresult = (int)result;
48927   return jresult;
48928 }
48929
48930
48931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
48932   int jresult ;
48933   int result;
48934
48935   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
48936   jresult = (int)result;
48937   return jresult;
48938 }
48939
48940
48941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
48942   int jresult ;
48943   int result;
48944
48945   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
48946   jresult = (int)result;
48947   return jresult;
48948 }
48949
48950
48951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
48952   int jresult ;
48953   int result;
48954
48955   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
48956   jresult = (int)result;
48957   return jresult;
48958 }
48959
48960
48961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
48962   int jresult ;
48963   int result;
48964
48965   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
48966   jresult = (int)result;
48967   return jresult;
48968 }
48969
48970
48971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
48972   int jresult ;
48973   int result;
48974
48975   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
48976   jresult = (int)result;
48977   return jresult;
48978 }
48979
48980
48981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
48982   int jresult ;
48983   int result;
48984
48985   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
48986   jresult = (int)result;
48987   return jresult;
48988 }
48989
48990
48991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
48992   int jresult ;
48993   int result;
48994
48995   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
48996   jresult = (int)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49002   int jresult ;
49003   int result;
49004
49005   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49006   jresult = (int)result;
49007   return jresult;
49008 }
49009
49010
49011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49012   int jresult ;
49013   int result;
49014
49015   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49016   jresult = (int)result;
49017   return jresult;
49018 }
49019
49020
49021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49022   int jresult ;
49023   int result;
49024
49025   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49026   jresult = (int)result;
49027   return jresult;
49028 }
49029
49030
49031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49032   int jresult ;
49033   int result;
49034
49035   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49036   jresult = (int)result;
49037   return jresult;
49038 }
49039
49040
49041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49042   int jresult ;
49043   int result;
49044
49045   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49046   jresult = (int)result;
49047   return jresult;
49048 }
49049
49050
49051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49052   int jresult ;
49053   int result;
49054
49055   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49056   jresult = (int)result;
49057   return jresult;
49058 }
49059
49060
49061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49062   int jresult ;
49063   int result;
49064
49065   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49066   jresult = (int)result;
49067   return jresult;
49068 }
49069
49070
49071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49072   int jresult ;
49073   int result;
49074
49075   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49076   jresult = (int)result;
49077   return jresult;
49078 }
49079
49080
49081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49082   int jresult ;
49083   int result;
49084
49085   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49086   jresult = (int)result;
49087   return jresult;
49088 }
49089
49090
49091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49092   int jresult ;
49093   int result;
49094
49095   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49096   jresult = (int)result;
49097   return jresult;
49098 }
49099
49100
49101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49102   int jresult ;
49103   int result;
49104
49105   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49106   jresult = (int)result;
49107   return jresult;
49108 }
49109
49110
49111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49112   int jresult ;
49113   int result;
49114
49115   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49116   jresult = (int)result;
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49122   int jresult ;
49123   int result;
49124
49125   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49126   jresult = (int)result;
49127   return jresult;
49128 }
49129
49130
49131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49132   void * jresult ;
49133   Dali::Toolkit::Popup::Property *result = 0 ;
49134
49135   {
49136     try {
49137       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49138     } CALL_CATCH_EXCEPTION(0);
49139   }
49140
49141   jresult = (void *)result;
49142   return jresult;
49143 }
49144
49145
49146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49147   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49148
49149   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49150   {
49151     try {
49152       delete arg1;
49153     } CALL_CATCH_EXCEPTION();
49154   }
49155
49156 }
49157
49158
49159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49160   void * jresult ;
49161   Dali::Toolkit::Popup *result = 0 ;
49162
49163   {
49164     try {
49165       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49166     } CALL_CATCH_EXCEPTION(0);
49167   }
49168
49169   jresult = (void *)result;
49170   return jresult;
49171 }
49172
49173
49174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49175   void * jresult ;
49176   Dali::Toolkit::Popup result;
49177
49178   {
49179     try {
49180       result = Dali::Toolkit::Popup::New();
49181     } CALL_CATCH_EXCEPTION(0);
49182   }
49183
49184   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49185   return jresult;
49186 }
49187
49188
49189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49190   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49191
49192   arg1 = (Dali::Toolkit::Popup *)jarg1;
49193   {
49194     try {
49195       delete arg1;
49196     } CALL_CATCH_EXCEPTION();
49197   }
49198
49199 }
49200
49201
49202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49203   void * jresult ;
49204   Dali::Toolkit::Popup *arg1 = 0 ;
49205   Dali::Toolkit::Popup *result = 0 ;
49206
49207   arg1 = (Dali::Toolkit::Popup *)jarg1;
49208   if (!arg1) {
49209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49210     return 0;
49211   }
49212   {
49213     try {
49214       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49215     } CALL_CATCH_EXCEPTION(0);
49216   }
49217
49218   jresult = (void *)result;
49219   return jresult;
49220 }
49221
49222
49223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49224   void * jresult ;
49225   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49226   Dali::Toolkit::Popup *arg2 = 0 ;
49227   Dali::Toolkit::Popup *result = 0 ;
49228
49229   arg1 = (Dali::Toolkit::Popup *)jarg1;
49230   arg2 = (Dali::Toolkit::Popup *)jarg2;
49231   if (!arg2) {
49232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49233     return 0;
49234   }
49235   {
49236     try {
49237       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49238     } CALL_CATCH_EXCEPTION(0);
49239   }
49240
49241   jresult = (void *)result;
49242   return jresult;
49243 }
49244
49245
49246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49247   void * jresult ;
49248   Dali::BaseHandle arg1 ;
49249   Dali::BaseHandle *argp1 ;
49250   Dali::Toolkit::Popup result;
49251
49252   argp1 = (Dali::BaseHandle *)jarg1;
49253   if (!argp1) {
49254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49255     return 0;
49256   }
49257   arg1 = *argp1;
49258   {
49259     try {
49260       result = Dali::Toolkit::Popup::DownCast(arg1);
49261     } CALL_CATCH_EXCEPTION(0);
49262   }
49263
49264   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49265   return jresult;
49266 }
49267
49268
49269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49270   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49271   Dali::Actor arg2 ;
49272   Dali::Actor *argp2 ;
49273
49274   arg1 = (Dali::Toolkit::Popup *)jarg1;
49275   argp2 = (Dali::Actor *)jarg2;
49276   if (!argp2) {
49277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49278     return ;
49279   }
49280   arg2 = *argp2;
49281   {
49282     try {
49283       (arg1)->SetTitle(arg2);
49284     } CALL_CATCH_EXCEPTION();
49285   }
49286
49287 }
49288
49289
49290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49291   void * jresult ;
49292   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49293   Dali::Actor result;
49294
49295   arg1 = (Dali::Toolkit::Popup *)jarg1;
49296   {
49297     try {
49298       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49299     } CALL_CATCH_EXCEPTION(0);
49300   }
49301
49302   jresult = new Dali::Actor((const Dali::Actor &)result);
49303   return jresult;
49304 }
49305
49306
49307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49308   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49309   Dali::Actor arg2 ;
49310   Dali::Actor *argp2 ;
49311
49312   arg1 = (Dali::Toolkit::Popup *)jarg1;
49313   argp2 = (Dali::Actor *)jarg2;
49314   if (!argp2) {
49315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49316     return ;
49317   }
49318   arg2 = *argp2;
49319   {
49320     try {
49321       (arg1)->SetContent(arg2);
49322     } CALL_CATCH_EXCEPTION();
49323   }
49324
49325 }
49326
49327
49328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49329   void * jresult ;
49330   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49331   Dali::Actor result;
49332
49333   arg1 = (Dali::Toolkit::Popup *)jarg1;
49334   {
49335     try {
49336       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49337     } CALL_CATCH_EXCEPTION(0);
49338   }
49339
49340   jresult = new Dali::Actor((const Dali::Actor &)result);
49341   return jresult;
49342 }
49343
49344
49345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49346   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49347   Dali::Actor arg2 ;
49348   Dali::Actor *argp2 ;
49349
49350   arg1 = (Dali::Toolkit::Popup *)jarg1;
49351   argp2 = (Dali::Actor *)jarg2;
49352   if (!argp2) {
49353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49354     return ;
49355   }
49356   arg2 = *argp2;
49357   {
49358     try {
49359       (arg1)->SetFooter(arg2);
49360     } CALL_CATCH_EXCEPTION();
49361   }
49362
49363 }
49364
49365
49366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49367   void * jresult ;
49368   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49369   Dali::Actor result;
49370
49371   arg1 = (Dali::Toolkit::Popup *)jarg1;
49372   {
49373     try {
49374       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49375     } CALL_CATCH_EXCEPTION(0);
49376   }
49377
49378   jresult = new Dali::Actor((const Dali::Actor &)result);
49379   return jresult;
49380 }
49381
49382
49383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49384   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49385   Dali::Toolkit::Popup::DisplayState arg2 ;
49386
49387   arg1 = (Dali::Toolkit::Popup *)jarg1;
49388   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49389   {
49390     try {
49391       (arg1)->SetDisplayState(arg2);
49392     } CALL_CATCH_EXCEPTION();
49393   }
49394
49395 }
49396
49397
49398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49399   int jresult ;
49400   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49401   Dali::Toolkit::Popup::DisplayState result;
49402
49403   arg1 = (Dali::Toolkit::Popup *)jarg1;
49404   {
49405     try {
49406       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49407     } CALL_CATCH_EXCEPTION(0);
49408   }
49409
49410   jresult = (int)result;
49411   return jresult;
49412 }
49413
49414
49415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49416   void * jresult ;
49417   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49418   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49419
49420   arg1 = (Dali::Toolkit::Popup *)jarg1;
49421   {
49422     try {
49423       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49424     } CALL_CATCH_EXCEPTION(0);
49425   }
49426
49427   jresult = (void *)result;
49428   return jresult;
49429 }
49430
49431
49432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49433   void * jresult ;
49434   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49435   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49436
49437   arg1 = (Dali::Toolkit::Popup *)jarg1;
49438   {
49439     try {
49440       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49441     } CALL_CATCH_EXCEPTION(0);
49442   }
49443
49444   jresult = (void *)result;
49445   return jresult;
49446 }
49447
49448
49449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
49450   void * jresult ;
49451   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49452   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49453
49454   arg1 = (Dali::Toolkit::Popup *)jarg1;
49455   {
49456     try {
49457       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
49458     } CALL_CATCH_EXCEPTION(0);
49459   }
49460
49461   jresult = (void *)result;
49462   return jresult;
49463 }
49464
49465
49466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
49467   void * jresult ;
49468   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49469   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49470
49471   arg1 = (Dali::Toolkit::Popup *)jarg1;
49472   {
49473     try {
49474       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
49475     } CALL_CATCH_EXCEPTION(0);
49476   }
49477
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
49484   void * jresult ;
49485   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49486   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49487
49488   arg1 = (Dali::Toolkit::Popup *)jarg1;
49489   {
49490     try {
49491       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
49492     } CALL_CATCH_EXCEPTION(0);
49493   }
49494
49495   jresult = (void *)result;
49496   return jresult;
49497 }
49498
49499
49500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49501   int jresult ;
49502   int result;
49503
49504   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49505   jresult = (int)result;
49506   return jresult;
49507 }
49508
49509
49510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49511   int jresult ;
49512   int result;
49513
49514   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49515   jresult = (int)result;
49516   return jresult;
49517 }
49518
49519
49520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49521   int jresult ;
49522   int result;
49523
49524   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49525   jresult = (int)result;
49526   return jresult;
49527 }
49528
49529
49530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49531   int jresult ;
49532   int result;
49533
49534   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49535   jresult = (int)result;
49536   return jresult;
49537 }
49538
49539
49540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49541   int jresult ;
49542   int result;
49543
49544   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49545   jresult = (int)result;
49546   return jresult;
49547 }
49548
49549
49550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49551   int jresult ;
49552   int result;
49553
49554   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49555   jresult = (int)result;
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49561   int jresult ;
49562   int result;
49563
49564   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49565   jresult = (int)result;
49566   return jresult;
49567 }
49568
49569
49570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49571   int jresult ;
49572   int result;
49573
49574   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49575   jresult = (int)result;
49576   return jresult;
49577 }
49578
49579
49580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49581   int jresult ;
49582   int result;
49583
49584   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49585   jresult = (int)result;
49586   return jresult;
49587 }
49588
49589
49590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49591   void * jresult ;
49592   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49593
49594   {
49595     try {
49596       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49597     } CALL_CATCH_EXCEPTION(0);
49598   }
49599
49600   jresult = (void *)result;
49601   return jresult;
49602 }
49603
49604
49605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49606   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49607
49608   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49609   {
49610     try {
49611       delete arg1;
49612     } CALL_CATCH_EXCEPTION();
49613   }
49614
49615 }
49616
49617
49618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49619   void * jresult ;
49620   Dali::Toolkit::ProgressBar result;
49621
49622   {
49623     try {
49624       result = Dali::Toolkit::ProgressBar::New();
49625     } CALL_CATCH_EXCEPTION(0);
49626   }
49627
49628   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49629   return jresult;
49630 }
49631
49632
49633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49634   void * jresult ;
49635   Dali::Toolkit::ProgressBar *result = 0 ;
49636
49637   {
49638     try {
49639       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49640     } CALL_CATCH_EXCEPTION(0);
49641   }
49642
49643   jresult = (void *)result;
49644   return jresult;
49645 }
49646
49647
49648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49649   void * jresult ;
49650   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49651   Dali::Toolkit::ProgressBar *result = 0 ;
49652
49653   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49654   if (!arg1) {
49655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49656     return 0;
49657   }
49658   {
49659     try {
49660       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49661     } CALL_CATCH_EXCEPTION(0);
49662   }
49663
49664   jresult = (void *)result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49670   void * jresult ;
49671   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49672   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49673   Dali::Toolkit::ProgressBar *result = 0 ;
49674
49675   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49676   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49677   if (!arg2) {
49678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49679     return 0;
49680   }
49681   {
49682     try {
49683       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49684     } CALL_CATCH_EXCEPTION(0);
49685   }
49686
49687   jresult = (void *)result;
49688   return jresult;
49689 }
49690
49691
49692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49693   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49694
49695   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49696   {
49697     try {
49698       delete arg1;
49699     } CALL_CATCH_EXCEPTION();
49700   }
49701
49702 }
49703
49704
49705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49706   void * jresult ;
49707   Dali::BaseHandle arg1 ;
49708   Dali::BaseHandle *argp1 ;
49709   Dali::Toolkit::ProgressBar result;
49710
49711   argp1 = (Dali::BaseHandle *)jarg1;
49712   if (!argp1) {
49713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49714     return 0;
49715   }
49716   arg1 = *argp1;
49717   {
49718     try {
49719       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49720     } CALL_CATCH_EXCEPTION(0);
49721   }
49722
49723   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49724   return jresult;
49725 }
49726
49727
49728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49729   void * jresult ;
49730   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49731   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49732
49733   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49734   {
49735     try {
49736       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49737     } CALL_CATCH_EXCEPTION(0);
49738   }
49739
49740   jresult = (void *)result;
49741   return jresult;
49742 }
49743
49744
49745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49746   void * jresult ;
49747   Dali::Toolkit::GaussianBlurView *result = 0 ;
49748
49749   {
49750     try {
49751       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49752     } CALL_CATCH_EXCEPTION(0);
49753   }
49754
49755   jresult = (void *)result;
49756   return jresult;
49757 }
49758
49759
49760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49761   void * jresult ;
49762   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
49763   Dali::Toolkit::GaussianBlurView *result = 0 ;
49764
49765   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49766   if (!arg1) {
49767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49768     return 0;
49769   }
49770   {
49771     try {
49772       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
49773     } CALL_CATCH_EXCEPTION(0);
49774   }
49775
49776   jresult = (void *)result;
49777   return jresult;
49778 }
49779
49780
49781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
49782   void * jresult ;
49783   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49784   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
49785   Dali::Toolkit::GaussianBlurView *result = 0 ;
49786
49787   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49788   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
49789   if (!arg2) {
49790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49791     return 0;
49792   }
49793   {
49794     try {
49795       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
49796     } CALL_CATCH_EXCEPTION(0);
49797   }
49798
49799   jresult = (void *)result;
49800   return jresult;
49801 }
49802
49803
49804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
49805   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49806
49807   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49808   {
49809     try {
49810       delete arg1;
49811     } CALL_CATCH_EXCEPTION();
49812   }
49813
49814 }
49815
49816
49817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
49818   void * jresult ;
49819   Dali::BaseHandle arg1 ;
49820   Dali::BaseHandle *argp1 ;
49821   Dali::Toolkit::GaussianBlurView result;
49822
49823   argp1 = (Dali::BaseHandle *)jarg1;
49824   if (!argp1) {
49825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49826     return 0;
49827   }
49828   arg1 = *argp1;
49829   {
49830     try {
49831       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
49832     } CALL_CATCH_EXCEPTION(0);
49833   }
49834
49835   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49836   return jresult;
49837 }
49838
49839
49840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
49841   void * jresult ;
49842   Dali::Toolkit::GaussianBlurView result;
49843
49844   {
49845     try {
49846       result = Dali::Toolkit::GaussianBlurView::New();
49847     } CALL_CATCH_EXCEPTION(0);
49848   }
49849
49850   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49851   return jresult;
49852 }
49853
49854
49855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
49856   void * jresult ;
49857   unsigned int arg1 ;
49858   float arg2 ;
49859   Dali::Pixel::Format arg3 ;
49860   float arg4 ;
49861   float arg5 ;
49862   bool arg6 ;
49863   Dali::Toolkit::GaussianBlurView result;
49864
49865   arg1 = (unsigned int)jarg1;
49866   arg2 = (float)jarg2;
49867   arg3 = (Dali::Pixel::Format)jarg3;
49868   arg4 = (float)jarg4;
49869   arg5 = (float)jarg5;
49870   arg6 = jarg6 ? true : false;
49871   {
49872     try {
49873       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
49874     } CALL_CATCH_EXCEPTION(0);
49875   }
49876
49877   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49878   return jresult;
49879 }
49880
49881
49882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
49883   void * jresult ;
49884   unsigned int arg1 ;
49885   float arg2 ;
49886   Dali::Pixel::Format arg3 ;
49887   float arg4 ;
49888   float arg5 ;
49889   Dali::Toolkit::GaussianBlurView result;
49890
49891   arg1 = (unsigned int)jarg1;
49892   arg2 = (float)jarg2;
49893   arg3 = (Dali::Pixel::Format)jarg3;
49894   arg4 = (float)jarg4;
49895   arg5 = (float)jarg5;
49896   {
49897     try {
49898       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
49899     } CALL_CATCH_EXCEPTION(0);
49900   }
49901
49902   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
49908   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49909   Dali::Actor arg2 ;
49910   Dali::Actor *argp2 ;
49911
49912   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49913   argp2 = (Dali::Actor *)jarg2;
49914   if (!argp2) {
49915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49916     return ;
49917   }
49918   arg2 = *argp2;
49919   {
49920     try {
49921       (arg1)->Add(arg2);
49922     } CALL_CATCH_EXCEPTION();
49923   }
49924
49925 }
49926
49927
49928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
49929   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49930   Dali::Actor arg2 ;
49931   Dali::Actor *argp2 ;
49932
49933   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49934   argp2 = (Dali::Actor *)jarg2;
49935   if (!argp2) {
49936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49937     return ;
49938   }
49939   arg2 = *argp2;
49940   {
49941     try {
49942       (arg1)->Remove(arg2);
49943     } CALL_CATCH_EXCEPTION();
49944   }
49945
49946 }
49947
49948
49949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
49950   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49951
49952   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49953   {
49954     try {
49955       (arg1)->Activate();
49956     } CALL_CATCH_EXCEPTION();
49957   }
49958
49959 }
49960
49961
49962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
49963   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49964
49965   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49966   {
49967     try {
49968       (arg1)->ActivateOnce();
49969     } CALL_CATCH_EXCEPTION();
49970   }
49971
49972 }
49973
49974
49975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
49976   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49977
49978   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49979   {
49980     try {
49981       (arg1)->Deactivate();
49982     } CALL_CATCH_EXCEPTION();
49983   }
49984
49985 }
49986
49987
49988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
49989   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49990   Dali::Texture arg2 ;
49991   Dali::FrameBuffer arg3 ;
49992   Dali::Texture *argp2 ;
49993   Dali::FrameBuffer *argp3 ;
49994
49995   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49996   argp2 = (Dali::Texture *)jarg2;
49997   if (!argp2) {
49998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
49999     return ;
50000   }
50001   arg2 = *argp2;
50002   argp3 = (Dali::FrameBuffer *)jarg3;
50003   if (!argp3) {
50004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50005     return ;
50006   }
50007   arg3 = *argp3;
50008   {
50009     try {
50010       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50011     } CALL_CATCH_EXCEPTION();
50012   }
50013
50014 }
50015
50016
50017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50018   int jresult ;
50019   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50020   Dali::Property::Index result;
50021
50022   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50023   {
50024     try {
50025       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50026     } CALL_CATCH_EXCEPTION(0);
50027   }
50028
50029   jresult = result;
50030   return jresult;
50031 }
50032
50033
50034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50035   void * jresult ;
50036   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50037   Dali::FrameBuffer result;
50038
50039   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50040   {
50041     try {
50042       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50043     } CALL_CATCH_EXCEPTION(0);
50044   }
50045
50046   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50052   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50053   Dali::Vector4 *arg2 = 0 ;
50054
50055   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50056   arg2 = (Dali::Vector4 *)jarg2;
50057   if (!arg2) {
50058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50059     return ;
50060   }
50061   {
50062     try {
50063       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50064     } CALL_CATCH_EXCEPTION();
50065   }
50066
50067 }
50068
50069
50070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50071   void * jresult ;
50072   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50073   Dali::Vector4 result;
50074
50075   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50076   {
50077     try {
50078       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50079     } CALL_CATCH_EXCEPTION(0);
50080   }
50081
50082   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50083   return jresult;
50084 }
50085
50086
50087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50088   void * jresult ;
50089   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50090   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50091
50092   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50093   {
50094     try {
50095       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50096     } CALL_CATCH_EXCEPTION(0);
50097   }
50098
50099   jresult = (void *)result;
50100   return jresult;
50101 }
50102
50103
50104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50105   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50106
50107   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50108   {
50109     try {
50110       delete arg1;
50111     } CALL_CATCH_EXCEPTION();
50112   }
50113
50114 }
50115
50116
50117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50118   unsigned int jresult ;
50119   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50120   unsigned int result;
50121
50122   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50123   {
50124     try {
50125       result = (unsigned int)(arg1)->GetNumberOfPages();
50126     } CALL_CATCH_EXCEPTION(0);
50127   }
50128
50129   jresult = result;
50130   return jresult;
50131 }
50132
50133
50134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50135   void * jresult ;
50136   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50137   unsigned int arg2 ;
50138   Dali::Texture result;
50139
50140   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50141   arg2 = (unsigned int)jarg2;
50142   {
50143     try {
50144       result = (arg1)->NewPage(arg2);
50145     } CALL_CATCH_EXCEPTION(0);
50146   }
50147
50148   jresult = new Dali::Texture((const Dali::Texture &)result);
50149   return jresult;
50150 }
50151
50152
50153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50154   int jresult ;
50155   int result;
50156
50157   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50158   jresult = (int)result;
50159   return jresult;
50160 }
50161
50162
50163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50164   int jresult ;
50165   int result;
50166
50167   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50168   jresult = (int)result;
50169   return jresult;
50170 }
50171
50172
50173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50174   int jresult ;
50175   int result;
50176
50177   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50178   jresult = (int)result;
50179   return jresult;
50180 }
50181
50182
50183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50184   void * jresult ;
50185   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50186
50187   {
50188     try {
50189       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50190     } CALL_CATCH_EXCEPTION(0);
50191   }
50192
50193   jresult = (void *)result;
50194   return jresult;
50195 }
50196
50197
50198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50199   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50200
50201   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50202   {
50203     try {
50204       delete arg1;
50205     } CALL_CATCH_EXCEPTION();
50206   }
50207
50208 }
50209
50210
50211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50212   void * jresult ;
50213   Dali::Toolkit::PageTurnView *result = 0 ;
50214
50215   {
50216     try {
50217       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50218     } CALL_CATCH_EXCEPTION(0);
50219   }
50220
50221   jresult = (void *)result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50227   void * jresult ;
50228   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50229   Dali::Toolkit::PageTurnView *result = 0 ;
50230
50231   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50232   if (!arg1) {
50233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50234     return 0;
50235   }
50236   {
50237     try {
50238       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50239     } CALL_CATCH_EXCEPTION(0);
50240   }
50241
50242   jresult = (void *)result;
50243   return jresult;
50244 }
50245
50246
50247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50248   void * jresult ;
50249   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50250   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50251   Dali::Toolkit::PageTurnView *result = 0 ;
50252
50253   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50254   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50255   if (!arg2) {
50256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50257     return 0;
50258   }
50259   {
50260     try {
50261       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50262     } CALL_CATCH_EXCEPTION(0);
50263   }
50264
50265   jresult = (void *)result;
50266   return jresult;
50267 }
50268
50269
50270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50271   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50272
50273   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50274   {
50275     try {
50276       delete arg1;
50277     } CALL_CATCH_EXCEPTION();
50278   }
50279
50280 }
50281
50282
50283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50284   void * jresult ;
50285   Dali::BaseHandle arg1 ;
50286   Dali::BaseHandle *argp1 ;
50287   Dali::Toolkit::PageTurnView result;
50288
50289   argp1 = (Dali::BaseHandle *)jarg1;
50290   if (!argp1) {
50291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50292     return 0;
50293   }
50294   arg1 = *argp1;
50295   {
50296     try {
50297       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50298     } CALL_CATCH_EXCEPTION(0);
50299   }
50300
50301   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50302   return jresult;
50303 }
50304
50305
50306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50307   void * jresult ;
50308   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50309   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50310
50311   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50312   {
50313     try {
50314       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50315     } CALL_CATCH_EXCEPTION(0);
50316   }
50317
50318   jresult = (void *)result;
50319   return jresult;
50320 }
50321
50322
50323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
50324   void * jresult ;
50325   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50326   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50327
50328   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50329   {
50330     try {
50331       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
50332     } CALL_CATCH_EXCEPTION(0);
50333   }
50334
50335   jresult = (void *)result;
50336   return jresult;
50337 }
50338
50339
50340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50341   void * jresult ;
50342   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50343   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50344
50345   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50346   {
50347     try {
50348       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50349     } CALL_CATCH_EXCEPTION(0);
50350   }
50351
50352   jresult = (void *)result;
50353   return jresult;
50354 }
50355
50356
50357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
50358   void * jresult ;
50359   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50360   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50361
50362   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50363   {
50364     try {
50365       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
50366     } CALL_CATCH_EXCEPTION(0);
50367   }
50368
50369   jresult = (void *)result;
50370   return jresult;
50371 }
50372
50373
50374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50375   void * jresult ;
50376   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50377
50378   {
50379     try {
50380       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50381     } CALL_CATCH_EXCEPTION(0);
50382   }
50383
50384   jresult = (void *)result;
50385   return jresult;
50386 }
50387
50388
50389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50390   void * jresult ;
50391   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50392   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50393
50394   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50395   if (!arg1) {
50396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50397     return 0;
50398   }
50399   {
50400     try {
50401       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50402     } CALL_CATCH_EXCEPTION(0);
50403   }
50404
50405   jresult = (void *)result;
50406   return jresult;
50407 }
50408
50409
50410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50411   void * jresult ;
50412   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50413   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50414   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50415
50416   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50417   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50418   if (!arg2) {
50419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50420     return 0;
50421   }
50422   {
50423     try {
50424       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50425     } CALL_CATCH_EXCEPTION(0);
50426   }
50427
50428   jresult = (void *)result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50434   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50435
50436   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50437   {
50438     try {
50439       delete arg1;
50440     } CALL_CATCH_EXCEPTION();
50441   }
50442
50443 }
50444
50445
50446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50447   void * jresult ;
50448   Dali::Toolkit::PageFactory *arg1 = 0 ;
50449   Dali::Vector2 *arg2 = 0 ;
50450   Dali::Toolkit::PageTurnLandscapeView result;
50451
50452   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50453   if (!arg1) {
50454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50455     return 0;
50456   }
50457   arg2 = (Dali::Vector2 *)jarg2;
50458   if (!arg2) {
50459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50460     return 0;
50461   }
50462   {
50463     try {
50464       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50465     } CALL_CATCH_EXCEPTION(0);
50466   }
50467
50468   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50469   return jresult;
50470 }
50471
50472
50473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50474   void * jresult ;
50475   Dali::BaseHandle arg1 ;
50476   Dali::BaseHandle *argp1 ;
50477   Dali::Toolkit::PageTurnLandscapeView result;
50478
50479   argp1 = (Dali::BaseHandle *)jarg1;
50480   if (!argp1) {
50481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50482     return 0;
50483   }
50484   arg1 = *argp1;
50485   {
50486     try {
50487       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50488     } CALL_CATCH_EXCEPTION(0);
50489   }
50490
50491   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50492   return jresult;
50493 }
50494
50495
50496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50497   void * jresult ;
50498   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50499
50500   {
50501     try {
50502       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50503     } CALL_CATCH_EXCEPTION(0);
50504   }
50505
50506   jresult = (void *)result;
50507   return jresult;
50508 }
50509
50510
50511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50512   void * jresult ;
50513   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50514   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50515
50516   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50517   if (!arg1) {
50518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50519     return 0;
50520   }
50521   {
50522     try {
50523       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50524     } CALL_CATCH_EXCEPTION(0);
50525   }
50526
50527   jresult = (void *)result;
50528   return jresult;
50529 }
50530
50531
50532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50533   void * jresult ;
50534   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50535   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50536   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50537
50538   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50539   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50540   if (!arg2) {
50541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50542     return 0;
50543   }
50544   {
50545     try {
50546       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50547     } CALL_CATCH_EXCEPTION(0);
50548   }
50549
50550   jresult = (void *)result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50556   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50557
50558   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50559   {
50560     try {
50561       delete arg1;
50562     } CALL_CATCH_EXCEPTION();
50563   }
50564
50565 }
50566
50567
50568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50569   void * jresult ;
50570   Dali::Toolkit::PageFactory *arg1 = 0 ;
50571   Dali::Vector2 *arg2 = 0 ;
50572   Dali::Toolkit::PageTurnPortraitView result;
50573
50574   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50575   if (!arg1) {
50576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50577     return 0;
50578   }
50579   arg2 = (Dali::Vector2 *)jarg2;
50580   if (!arg2) {
50581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50582     return 0;
50583   }
50584   {
50585     try {
50586       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50587     } CALL_CATCH_EXCEPTION(0);
50588   }
50589
50590   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50591   return jresult;
50592 }
50593
50594
50595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50596   void * jresult ;
50597   Dali::BaseHandle arg1 ;
50598   Dali::BaseHandle *argp1 ;
50599   Dali::Toolkit::PageTurnPortraitView result;
50600
50601   argp1 = (Dali::BaseHandle *)jarg1;
50602   if (!argp1) {
50603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50604     return 0;
50605   }
50606   arg1 = *argp1;
50607   {
50608     try {
50609       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50610     } CALL_CATCH_EXCEPTION(0);
50611   }
50612
50613   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50614   return jresult;
50615 }
50616
50617
50618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50619   int jresult ;
50620   int result;
50621
50622   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50623   jresult = (int)result;
50624   return jresult;
50625 }
50626
50627
50628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50629   int jresult ;
50630   int result;
50631
50632   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50633   jresult = (int)result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50639   int jresult ;
50640   int result;
50641
50642   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50643   jresult = (int)result;
50644   return jresult;
50645 }
50646
50647
50648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50649   void * jresult ;
50650   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50651
50652   {
50653     try {
50654       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50655     } CALL_CATCH_EXCEPTION(0);
50656   }
50657
50658   jresult = (void *)result;
50659   return jresult;
50660 }
50661
50662
50663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50664   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50665
50666   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50667   {
50668     try {
50669       delete arg1;
50670     } CALL_CATCH_EXCEPTION();
50671   }
50672
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50677   void * jresult ;
50678   Dali::Toolkit::ToggleButton *result = 0 ;
50679
50680   {
50681     try {
50682       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50683     } CALL_CATCH_EXCEPTION(0);
50684   }
50685
50686   jresult = (void *)result;
50687   return jresult;
50688 }
50689
50690
50691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50692   void * jresult ;
50693   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50694   Dali::Toolkit::ToggleButton *result = 0 ;
50695
50696   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50697   if (!arg1) {
50698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50699     return 0;
50700   }
50701   {
50702     try {
50703       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50704     } CALL_CATCH_EXCEPTION(0);
50705   }
50706
50707   jresult = (void *)result;
50708   return jresult;
50709 }
50710
50711
50712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50713   void * jresult ;
50714   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50715   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50716   Dali::Toolkit::ToggleButton *result = 0 ;
50717
50718   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50719   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50720   if (!arg2) {
50721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50722     return 0;
50723   }
50724   {
50725     try {
50726       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50727     } CALL_CATCH_EXCEPTION(0);
50728   }
50729
50730   jresult = (void *)result;
50731   return jresult;
50732 }
50733
50734
50735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50736   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50737
50738   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50739   {
50740     try {
50741       delete arg1;
50742     } CALL_CATCH_EXCEPTION();
50743   }
50744
50745 }
50746
50747
50748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50749   void * jresult ;
50750   Dali::Toolkit::ToggleButton result;
50751
50752   {
50753     try {
50754       result = Dali::Toolkit::ToggleButton::New();
50755     } CALL_CATCH_EXCEPTION(0);
50756   }
50757
50758   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50759   return jresult;
50760 }
50761
50762
50763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
50764   void * jresult ;
50765   Dali::BaseHandle arg1 ;
50766   Dali::BaseHandle *argp1 ;
50767   Dali::Toolkit::ToggleButton result;
50768
50769   argp1 = (Dali::BaseHandle *)jarg1;
50770   if (!argp1) {
50771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50772     return 0;
50773   }
50774   arg1 = *argp1;
50775   {
50776     try {
50777       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
50778     } CALL_CATCH_EXCEPTION(0);
50779   }
50780
50781   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50782   return jresult;
50783 }
50784
50785
50786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
50787   void * jresult ;
50788   Dali::Toolkit::Visual::Base *result = 0 ;
50789
50790   {
50791     try {
50792       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
50793     } CALL_CATCH_EXCEPTION(0);
50794   }
50795
50796   jresult = (void *)result;
50797   return jresult;
50798 }
50799
50800
50801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
50802   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50803
50804   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50805   {
50806     try {
50807       delete arg1;
50808     } CALL_CATCH_EXCEPTION();
50809   }
50810
50811 }
50812
50813
50814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
50815   void * jresult ;
50816   Dali::Toolkit::Visual::Base *arg1 = 0 ;
50817   Dali::Toolkit::Visual::Base *result = 0 ;
50818
50819   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50820   if (!arg1) {
50821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
50822     return 0;
50823   }
50824   {
50825     try {
50826       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
50827     } CALL_CATCH_EXCEPTION(0);
50828   }
50829
50830   jresult = (void *)result;
50831   return jresult;
50832 }
50833
50834
50835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
50836   void * jresult ;
50837   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50838   Dali::Toolkit::Visual::Base *arg2 = 0 ;
50839   Dali::Toolkit::Visual::Base *result = 0 ;
50840
50841   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50842   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
50843   if (!arg2) {
50844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
50845     return 0;
50846   }
50847   {
50848     try {
50849       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
50850     } CALL_CATCH_EXCEPTION(0);
50851   }
50852
50853   jresult = (void *)result;
50854   return jresult;
50855 }
50856
50857
50858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
50859   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50860   std::string *arg2 = 0 ;
50861
50862   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50863   if (!jarg2) {
50864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50865     return ;
50866   }
50867   std::string arg2_str(jarg2);
50868   arg2 = &arg2_str;
50869   {
50870     try {
50871       (arg1)->SetName((std::string const &)*arg2);
50872     } CALL_CATCH_EXCEPTION();
50873   }
50874
50875
50876   //argout typemap for const std::string&
50877
50878 }
50879
50880
50881 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
50882   char * jresult ;
50883   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50884   std::string *result = 0 ;
50885
50886   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50887   {
50888     try {
50889       result = (std::string *) &(arg1)->GetName();
50890     } CALL_CATCH_EXCEPTION(0);
50891   }
50892
50893   jresult = SWIG_csharp_string_callback(result->c_str());
50894   return jresult;
50895 }
50896
50897
50898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
50899   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50900   Dali::Property::Map *arg2 = 0 ;
50901   Dali::Size arg3 ;
50902   Dali::Size *argp3 ;
50903
50904   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50905   arg2 = (Dali::Property::Map *)jarg2;
50906   if (!arg2) {
50907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
50908     return ;
50909   }
50910   argp3 = (Dali::Size *)jarg3;
50911   if (!argp3) {
50912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
50913     return ;
50914   }
50915   arg3 = *argp3;
50916   {
50917     try {
50918       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
50919     } CALL_CATCH_EXCEPTION();
50920   }
50921
50922 }
50923
50924
50925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
50926   float jresult ;
50927   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50928   float arg2 ;
50929   float result;
50930
50931   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50932   arg2 = (float)jarg2;
50933   {
50934     try {
50935       result = (float)(arg1)->GetHeightForWidth(arg2);
50936     } CALL_CATCH_EXCEPTION(0);
50937   }
50938
50939   jresult = result;
50940   return jresult;
50941 }
50942
50943
50944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
50945   float jresult ;
50946   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50947   float arg2 ;
50948   float result;
50949
50950   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50951   arg2 = (float)jarg2;
50952   {
50953     try {
50954       result = (float)(arg1)->GetWidthForHeight(arg2);
50955     } CALL_CATCH_EXCEPTION(0);
50956   }
50957
50958   jresult = result;
50959   return jresult;
50960 }
50961
50962
50963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
50964   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50965   Dali::Vector2 *arg2 = 0 ;
50966
50967   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50968   arg2 = (Dali::Vector2 *)jarg2;
50969   if (!arg2) {
50970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
50971     return ;
50972   }
50973   {
50974     try {
50975       (arg1)->GetNaturalSize(*arg2);
50976     } CALL_CATCH_EXCEPTION();
50977   }
50978
50979 }
50980
50981
50982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
50983   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50984   float arg2 ;
50985
50986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50987   arg2 = (int)jarg2;
50988   {
50989     try {
50990       (arg1)->SetDepthIndex(arg2);
50991     } CALL_CATCH_EXCEPTION();
50992   }
50993
50994 }
50995
50996
50997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
50998   int jresult ;
50999   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51000   int result;
51001
51002   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51003   {
51004     try {
51005       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51006     } CALL_CATCH_EXCEPTION(0);
51007   }
51008
51009   jresult = result;
51010   return jresult;
51011 }
51012
51013
51014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51015   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51016   Dali::Property::Map *arg2 = 0 ;
51017
51018   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51019   arg2 = (Dali::Property::Map *)jarg2;
51020   if (!arg2) {
51021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51022     return ;
51023   }
51024   {
51025     try {
51026       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51027     } CALL_CATCH_EXCEPTION();
51028   }
51029
51030 }
51031
51032
51033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51034   void * jresult ;
51035   Dali::Toolkit::VisualFactory result;
51036
51037   {
51038     try {
51039       result = Dali::Toolkit::VisualFactory::Get();
51040     } CALL_CATCH_EXCEPTION(0);
51041   }
51042
51043   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51044   return jresult;
51045 }
51046
51047
51048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51049   void * jresult ;
51050   Dali::Toolkit::VisualFactory *result = 0 ;
51051
51052   {
51053     try {
51054       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51055     } CALL_CATCH_EXCEPTION(0);
51056   }
51057
51058   jresult = (void *)result;
51059   return jresult;
51060 }
51061
51062
51063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51064   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51065
51066   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51067   {
51068     try {
51069       delete arg1;
51070     } CALL_CATCH_EXCEPTION();
51071   }
51072
51073 }
51074
51075
51076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51077   void * jresult ;
51078   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51079   Dali::Toolkit::VisualFactory *result = 0 ;
51080
51081   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51082   if (!arg1) {
51083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51084     return 0;
51085   }
51086   {
51087     try {
51088       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51089     } CALL_CATCH_EXCEPTION(0);
51090   }
51091
51092   jresult = (void *)result;
51093   return jresult;
51094 }
51095
51096
51097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51098   void * jresult ;
51099   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51100   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51101   Dali::Toolkit::VisualFactory *result = 0 ;
51102
51103   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51104   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51105   if (!arg2) {
51106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51107     return 0;
51108   }
51109   {
51110     try {
51111       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51112     } CALL_CATCH_EXCEPTION(0);
51113   }
51114
51115   jresult = (void *)result;
51116   return jresult;
51117 }
51118
51119
51120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51121   void * jresult ;
51122   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51123   Dali::Property::Map *arg2 = 0 ;
51124   Dali::Toolkit::Visual::Base result;
51125
51126   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51127   arg2 = (Dali::Property::Map *)jarg2;
51128   if (!arg2) {
51129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51130     return 0;
51131   }
51132   {
51133     try {
51134       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51135     } CALL_CATCH_EXCEPTION(0);
51136   }
51137
51138   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51139   return jresult;
51140 }
51141
51142
51143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51144   void * jresult ;
51145   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51146   std::string *arg2 = 0 ;
51147   Dali::ImageDimensions arg3 ;
51148   Dali::ImageDimensions *argp3 ;
51149   Dali::Toolkit::Visual::Base result;
51150
51151   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51152   if (!jarg2) {
51153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51154     return 0;
51155   }
51156   std::string arg2_str(jarg2);
51157   arg2 = &arg2_str;
51158   argp3 = (Dali::ImageDimensions *)jarg3;
51159   if (!argp3) {
51160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51161     return 0;
51162   }
51163   arg3 = *argp3;
51164   {
51165     try {
51166       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51167     } CALL_CATCH_EXCEPTION(0);
51168   }
51169
51170   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51171
51172   //argout typemap for const std::string&
51173
51174   return jresult;
51175 }
51176
51177
51178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51179   void * jresult ;
51180   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51181
51182   {
51183     try {
51184       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51185     } CALL_CATCH_EXCEPTION(0);
51186   }
51187
51188   jresult = (void *)result;
51189   return jresult;
51190 }
51191
51192
51193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51194   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51195
51196   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51197   {
51198     try {
51199       delete arg1;
51200     } CALL_CATCH_EXCEPTION();
51201   }
51202
51203 }
51204
51205
51206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51207   void * jresult ;
51208   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51209   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51210
51211   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51212   if (!arg1) {
51213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51214     return 0;
51215   }
51216   {
51217     try {
51218       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51219     } CALL_CATCH_EXCEPTION(0);
51220   }
51221
51222   jresult = (void *)result;
51223   return jresult;
51224 }
51225
51226
51227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51228   void * jresult ;
51229   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51230   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51231   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51232
51233   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51234   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51235   if (!arg2) {
51236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51237     return 0;
51238   }
51239   {
51240     try {
51241       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51242     } CALL_CATCH_EXCEPTION(0);
51243   }
51244
51245   jresult = (void *)result;
51246   return jresult;
51247 }
51248
51249
51250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51251   void * jresult ;
51252   Dali::Toolkit::AsyncImageLoader result;
51253
51254   {
51255     try {
51256       result = Dali::Toolkit::AsyncImageLoader::New();
51257     } CALL_CATCH_EXCEPTION(0);
51258   }
51259
51260   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51261   return jresult;
51262 }
51263
51264
51265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51266   void * jresult ;
51267   Dali::BaseHandle arg1 ;
51268   Dali::BaseHandle *argp1 ;
51269   Dali::Toolkit::AsyncImageLoader result;
51270
51271   argp1 = (Dali::BaseHandle *)jarg1;
51272   if (!argp1) {
51273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51274     return 0;
51275   }
51276   arg1 = *argp1;
51277   {
51278     try {
51279       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51280     } CALL_CATCH_EXCEPTION(0);
51281   }
51282
51283   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51284   return jresult;
51285 }
51286
51287
51288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51289   unsigned int jresult ;
51290   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51291   std::string *arg2 = 0 ;
51292   uint32_t result;
51293
51294   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51295   if (!jarg2) {
51296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51297     return 0;
51298   }
51299   std::string arg2_str(jarg2);
51300   arg2 = &arg2_str;
51301   {
51302     try {
51303       result = (arg1)->Load((std::string const &)*arg2);
51304     } CALL_CATCH_EXCEPTION(0);
51305   }
51306
51307   jresult = result;
51308
51309   //argout typemap for const std::string&
51310
51311   return jresult;
51312 }
51313
51314
51315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51316   unsigned int jresult ;
51317   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51318   std::string *arg2 = 0 ;
51319   Dali::ImageDimensions arg3 ;
51320   Dali::ImageDimensions *argp3 ;
51321   uint32_t result;
51322
51323   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51324   if (!jarg2) {
51325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51326     return 0;
51327   }
51328   std::string arg2_str(jarg2);
51329   arg2 = &arg2_str;
51330   argp3 = (Dali::ImageDimensions *)jarg3;
51331   if (!argp3) {
51332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51333     return 0;
51334   }
51335   arg3 = *argp3;
51336   {
51337     try {
51338       result = (arg1)->Load((std::string const &)*arg2,arg3);
51339     } CALL_CATCH_EXCEPTION(0);
51340   }
51341
51342   jresult = result;
51343
51344   //argout typemap for const std::string&
51345
51346   return jresult;
51347 }
51348
51349
51350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51351   unsigned int jresult ;
51352   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51353   std::string *arg2 = 0 ;
51354   Dali::ImageDimensions arg3 ;
51355   Dali::FittingMode::Type arg4 ;
51356   Dali::SamplingMode::Type arg5 ;
51357   bool arg6 ;
51358   Dali::ImageDimensions *argp3 ;
51359   uint32_t result;
51360
51361   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51362   if (!jarg2) {
51363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51364     return 0;
51365   }
51366   std::string arg2_str(jarg2);
51367   arg2 = &arg2_str;
51368   argp3 = (Dali::ImageDimensions *)jarg3;
51369   if (!argp3) {
51370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51371     return 0;
51372   }
51373   arg3 = *argp3;
51374   arg4 = (Dali::FittingMode::Type)jarg4;
51375   arg5 = (Dali::SamplingMode::Type)jarg5;
51376   arg6 = jarg6 ? true : false;
51377   {
51378     try {
51379       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51380     } CALL_CATCH_EXCEPTION(0);
51381   }
51382
51383   jresult = result;
51384
51385   //argout typemap for const std::string&
51386
51387   return jresult;
51388 }
51389
51390
51391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51392   unsigned int jresult ;
51393   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51394   uint32_t arg2 ;
51395   bool result;
51396
51397   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51398   arg2 = (uint32_t)jarg2;
51399   {
51400     try {
51401       result = (bool)(arg1)->Cancel(arg2);
51402     } CALL_CATCH_EXCEPTION(0);
51403   }
51404
51405   jresult = result;
51406   return jresult;
51407 }
51408
51409
51410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51411   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51412
51413   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51414   {
51415     try {
51416       (arg1)->CancelAll();
51417     } CALL_CATCH_EXCEPTION();
51418   }
51419
51420 }
51421
51422
51423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51424   void * jresult ;
51425   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51426   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51427
51428   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51429   {
51430     try {
51431       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51432     } CALL_CATCH_EXCEPTION(0);
51433   }
51434
51435   jresult = (void *)result;
51436   return jresult;
51437 }
51438
51439
51440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51441   void * jresult ;
51442   std::string *arg1 = 0 ;
51443   Dali::PixelData result;
51444
51445   if (!jarg1) {
51446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51447     return 0;
51448   }
51449   std::string arg1_str(jarg1);
51450   arg1 = &arg1_str;
51451   {
51452     try {
51453       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51454     } CALL_CATCH_EXCEPTION(0);
51455   }
51456
51457   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51458
51459   //argout typemap for const std::string&
51460
51461   return jresult;
51462 }
51463
51464
51465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51466   void * jresult ;
51467   std::string *arg1 = 0 ;
51468   Dali::ImageDimensions arg2 ;
51469   Dali::ImageDimensions *argp2 ;
51470   Dali::PixelData result;
51471
51472   if (!jarg1) {
51473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51474     return 0;
51475   }
51476   std::string arg1_str(jarg1);
51477   arg1 = &arg1_str;
51478   argp2 = (Dali::ImageDimensions *)jarg2;
51479   if (!argp2) {
51480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51481     return 0;
51482   }
51483   arg2 = *argp2;
51484   {
51485     try {
51486       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51487     } CALL_CATCH_EXCEPTION(0);
51488   }
51489
51490   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51491
51492   //argout typemap for const std::string&
51493
51494   return jresult;
51495 }
51496
51497
51498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51499   void * jresult ;
51500   std::string *arg1 = 0 ;
51501   Dali::ImageDimensions arg2 ;
51502   Dali::FittingMode::Type arg3 ;
51503   Dali::SamplingMode::Type arg4 ;
51504   bool arg5 ;
51505   Dali::ImageDimensions *argp2 ;
51506   Dali::PixelData result;
51507
51508   if (!jarg1) {
51509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51510     return 0;
51511   }
51512   std::string arg1_str(jarg1);
51513   arg1 = &arg1_str;
51514   argp2 = (Dali::ImageDimensions *)jarg2;
51515   if (!argp2) {
51516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51517     return 0;
51518   }
51519   arg2 = *argp2;
51520   arg3 = (Dali::FittingMode::Type)jarg3;
51521   arg4 = (Dali::SamplingMode::Type)jarg4;
51522   arg5 = jarg5 ? true : false;
51523   {
51524     try {
51525       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51526     } CALL_CATCH_EXCEPTION(0);
51527   }
51528
51529   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51530
51531   //argout typemap for const std::string&
51532
51533   return jresult;
51534 }
51535
51536
51537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51538   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51539
51540   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51541   {
51542     try {
51543       delete arg1;
51544     } CALL_CATCH_EXCEPTION();
51545   }
51546
51547 }
51548
51549
51550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51551   void * jresult ;
51552   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51553   Dali::Actor arg2 ;
51554   Dali::Actor arg3 ;
51555   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51556   Dali::Actor *argp2 ;
51557   Dali::Actor *argp3 ;
51558   Dali::Actor result;
51559
51560   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51561   argp2 = (Dali::Actor *)jarg2;
51562   if (!argp2) {
51563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51564     return 0;
51565   }
51566   arg2 = *argp2;
51567   argp3 = (Dali::Actor *)jarg3;
51568   if (!argp3) {
51569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51570     return 0;
51571   }
51572   arg3 = *argp3;
51573   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51574   {
51575     try {
51576       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51577     } CALL_CATCH_EXCEPTION(0);
51578   }
51579
51580   jresult = new Dali::Actor((const Dali::Actor &)result);
51581   return jresult;
51582 }
51583
51584
51585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51586   void * jresult ;
51587   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51588
51589   {
51590     try {
51591       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51592     } CALL_CATCH_EXCEPTION(0);
51593   }
51594
51595   jresult = (void *)result;
51596   return jresult;
51597 }
51598
51599
51600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51601   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51602   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51603   if (director) {
51604     director->swig_connect_director(callback0);
51605   }
51606 }
51607
51608
51609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51610   void * jresult ;
51611   Dali::FrameCallbackInterface *result = 0 ;
51612
51613   {
51614     try {
51615       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51616     } CALL_CATCH_EXCEPTION(0);
51617   }
51618
51619   jresult = (void *)result;
51620   return jresult;
51621 }
51622
51623 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51624   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51625   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51626   return proxy->GetPosition(id, *vector3);
51627 }
51628
51629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51630   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51631   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51632   return proxy->SetPosition(id, *vector3);
51633 }
51634
51635 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51636   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51637   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51638   return proxy->BakePosition(id, *vector3);
51639 }
51640
51641 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51642   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51643   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51644   return proxy->GetSize(id, *vector3);
51645 }
51646
51647 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51648   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51649   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51650   return proxy->SetSize(id, *vector3);
51651 }
51652 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51653   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51654   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51655   return proxy->BakeSize(id, *vector3);
51656 }
51657
51658 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51659   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51660   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51661   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51662   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51663 }
51664
51665 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51666   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51667   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51668   return proxy->GetScale(id,* vector3);
51669 }
51670
51671 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51672   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51673   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51674   return proxy->SetScale(id, *vector3);
51675 }
51676
51677 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51678   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51679   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51680   return proxy->BakeScale(id, *vector3);
51681 }
51682
51683 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51684   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51685   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51686   return proxy->GetColor(id, *vector4);
51687 }
51688
51689 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51690   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51691   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51692   return proxy->SetColor(id, *vector4);
51693 }
51694
51695 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51696   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51697   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51698   return proxy->BakeColor(id, *vector4);
51699 }
51700
51701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51702   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51703   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51704
51705   Dali::Stage *arg1 = (Dali::Stage *) 0;
51706   Dali::Actor *arg3 = 0;
51707
51708   arg1 = (Dali::Stage *)jarg1;
51709   arg3 = (Dali::Actor *)jarg3;
51710
51711   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51712   return;
51713 }
51714
51715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51716
51717   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51718   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51719
51720   Dali::Stage *arg1 = (Dali::Stage *) 0;
51721
51722   arg1 = (Dali::Stage *)jarg1;
51723
51724   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51725   return;
51726 }
51727
51728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51729   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51730   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51731   if (director) {
51732     director->swig_connect_director(callback0);
51733   }
51734 }
51735
51736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51737   KeyboardFocusManager arg1 ;
51738   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51739   KeyboardFocusManager *argp1 ;
51740
51741   argp1 = (KeyboardFocusManager *)jarg1;
51742   if (!argp1) {
51743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51744     return ;
51745   }
51746   arg1 = *argp1;
51747   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51748   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51749   {
51750     try {
51751       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51752     } CALL_CATCH_EXCEPTION();
51753   }
51754
51755 }
51756
51757
51758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51759   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51760
51761   arg1 = (std::vector< unsigned int > *)jarg1;
51762   {
51763     try {
51764       (arg1)->clear();
51765     } CALL_CATCH_EXCEPTION();
51766   }
51767
51768 }
51769
51770
51771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
51772   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51773   unsigned int *arg2 = 0 ;
51774   unsigned int temp2 ;
51775
51776   arg1 = (std::vector< unsigned int > *)jarg1;
51777   temp2 = (unsigned int)jarg2;
51778   arg2 = &temp2;
51779   {
51780     try {
51781       (arg1)->push_back((unsigned int const &)*arg2);
51782     } CALL_CATCH_EXCEPTION();
51783   }
51784
51785 }
51786
51787
51788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
51789   unsigned long jresult ;
51790   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51791   std::vector< unsigned int >::size_type result;
51792
51793   arg1 = (std::vector< unsigned int > *)jarg1;
51794   {
51795     try {
51796       result = ((std::vector< unsigned int > const *)arg1)->size();
51797     } CALL_CATCH_EXCEPTION(0);
51798   }
51799
51800   jresult = (unsigned long)result;
51801   return jresult;
51802 }
51803
51804
51805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
51806   unsigned long jresult ;
51807   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51808   std::vector< unsigned int >::size_type result;
51809
51810   arg1 = (std::vector< unsigned int > *)jarg1;
51811   {
51812     try {
51813       result = ((std::vector< unsigned int > const *)arg1)->capacity();
51814     } CALL_CATCH_EXCEPTION(0);
51815   }
51816
51817   jresult = (unsigned long)result;
51818   return jresult;
51819 }
51820
51821
51822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
51823   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51824   std::vector< unsigned int >::size_type arg2 ;
51825
51826   arg1 = (std::vector< unsigned int > *)jarg1;
51827   arg2 = (std::vector< unsigned int >::size_type)jarg2;
51828   {
51829     try {
51830       (arg1)->reserve(arg2);
51831     } CALL_CATCH_EXCEPTION();
51832   }
51833
51834 }
51835
51836
51837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
51838   void * jresult ;
51839   std::vector< unsigned int > *result = 0 ;
51840
51841   {
51842     try {
51843       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
51844     } CALL_CATCH_EXCEPTION(0);
51845   }
51846
51847   jresult = (void *)result;
51848   return jresult;
51849 }
51850
51851
51852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
51853   void * jresult ;
51854   std::vector< unsigned int > *arg1 = 0 ;
51855   std::vector< unsigned int > *result = 0 ;
51856
51857   arg1 = (std::vector< unsigned int > *)jarg1;
51858   if (!arg1) {
51859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
51860     return 0;
51861   }
51862   {
51863     try {
51864       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
51865     } CALL_CATCH_EXCEPTION(0);
51866   }
51867
51868   jresult = (void *)result;
51869   return jresult;
51870 }
51871
51872
51873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
51874   void * jresult ;
51875   int arg1 ;
51876   std::vector< unsigned int > *result = 0 ;
51877
51878   arg1 = (int)jarg1;
51879   {
51880     try {
51881       try {
51882         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
51883       }
51884       catch(std::out_of_range &_e) {
51885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51886         return 0;
51887       }
51888
51889     } CALL_CATCH_EXCEPTION(0);
51890   }
51891
51892   jresult = (void *)result;
51893   return jresult;
51894 }
51895
51896
51897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
51898   unsigned int jresult ;
51899   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51900   int arg2 ;
51901   unsigned int result;
51902
51903   arg1 = (std::vector< unsigned int > *)jarg1;
51904   arg2 = (int)jarg2;
51905   {
51906     try {
51907       try {
51908         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
51909       }
51910       catch(std::out_of_range &_e) {
51911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51912         return 0;
51913       }
51914
51915     } CALL_CATCH_EXCEPTION(0);
51916   }
51917
51918   jresult = result;
51919   return jresult;
51920 }
51921
51922
51923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
51924   unsigned int jresult ;
51925   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51926   int arg2 ;
51927   unsigned int *result = 0 ;
51928
51929   arg1 = (std::vector< unsigned int > *)jarg1;
51930   arg2 = (int)jarg2;
51931   {
51932     try {
51933       try {
51934         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
51935       }
51936       catch(std::out_of_range &_e) {
51937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51938         return 0;
51939       }
51940
51941     } CALL_CATCH_EXCEPTION(0);
51942   }
51943
51944   jresult = *result;
51945   return jresult;
51946 }
51947
51948
51949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
51950   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51951   int arg2 ;
51952   unsigned int *arg3 = 0 ;
51953   unsigned int temp3 ;
51954
51955   arg1 = (std::vector< unsigned int > *)jarg1;
51956   arg2 = (int)jarg2;
51957   temp3 = (unsigned int)jarg3;
51958   arg3 = &temp3;
51959   {
51960     try {
51961       try {
51962         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
51963       }
51964       catch(std::out_of_range &_e) {
51965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51966         return ;
51967       }
51968
51969     } CALL_CATCH_EXCEPTION();
51970   }
51971
51972 }
51973
51974
51975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
51976   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51977   std::vector< unsigned int > *arg2 = 0 ;
51978
51979   arg1 = (std::vector< unsigned int > *)jarg1;
51980   arg2 = (std::vector< unsigned int > *)jarg2;
51981   if (!arg2) {
51982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
51983     return ;
51984   }
51985   {
51986     try {
51987       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
51988     } CALL_CATCH_EXCEPTION();
51989   }
51990
51991 }
51992
51993
51994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
51995   void * jresult ;
51996   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51997   int arg2 ;
51998   int arg3 ;
51999   std::vector< unsigned int > *result = 0 ;
52000
52001   arg1 = (std::vector< unsigned int > *)jarg1;
52002   arg2 = (int)jarg2;
52003   arg3 = (int)jarg3;
52004   {
52005     try {
52006       try {
52007         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52008       }
52009       catch(std::out_of_range &_e) {
52010         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52011         return 0;
52012       }
52013       catch(std::invalid_argument &_e) {
52014         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52015         return 0;
52016       }
52017
52018     } CALL_CATCH_EXCEPTION(0);
52019   }
52020
52021   jresult = (void *)result;
52022   return jresult;
52023 }
52024
52025
52026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52027   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52028   int arg2 ;
52029   unsigned int *arg3 = 0 ;
52030   unsigned int temp3 ;
52031
52032   arg1 = (std::vector< unsigned int > *)jarg1;
52033   arg2 = (int)jarg2;
52034   temp3 = (unsigned int)jarg3;
52035   arg3 = &temp3;
52036   {
52037     try {
52038       try {
52039         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52040       }
52041       catch(std::out_of_range &_e) {
52042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52043         return ;
52044       }
52045
52046     } CALL_CATCH_EXCEPTION();
52047   }
52048
52049 }
52050
52051
52052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52053   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52054   int arg2 ;
52055   std::vector< unsigned int > *arg3 = 0 ;
52056
52057   arg1 = (std::vector< unsigned int > *)jarg1;
52058   arg2 = (int)jarg2;
52059   arg3 = (std::vector< unsigned int > *)jarg3;
52060   if (!arg3) {
52061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52062     return ;
52063   }
52064   {
52065     try {
52066       try {
52067         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52068       }
52069       catch(std::out_of_range &_e) {
52070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52071         return ;
52072       }
52073
52074     } CALL_CATCH_EXCEPTION();
52075   }
52076
52077 }
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52081   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52082   int arg2 ;
52083
52084   arg1 = (std::vector< unsigned int > *)jarg1;
52085   arg2 = (int)jarg2;
52086   {
52087     try {
52088       try {
52089         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52090       }
52091       catch(std::out_of_range &_e) {
52092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52093         return ;
52094       }
52095
52096     } CALL_CATCH_EXCEPTION();
52097   }
52098
52099 }
52100
52101
52102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52103   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52104   int arg2 ;
52105   int arg3 ;
52106
52107   arg1 = (std::vector< unsigned int > *)jarg1;
52108   arg2 = (int)jarg2;
52109   arg3 = (int)jarg3;
52110   {
52111     try {
52112       try {
52113         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52114       }
52115       catch(std::out_of_range &_e) {
52116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52117         return ;
52118       }
52119       catch(std::invalid_argument &_e) {
52120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52121         return ;
52122       }
52123
52124     } CALL_CATCH_EXCEPTION();
52125   }
52126
52127 }
52128
52129
52130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52131   void * jresult ;
52132   unsigned int *arg1 = 0 ;
52133   int arg2 ;
52134   unsigned int temp1 ;
52135   std::vector< unsigned int > *result = 0 ;
52136
52137   temp1 = (unsigned int)jarg1;
52138   arg1 = &temp1;
52139   arg2 = (int)jarg2;
52140   {
52141     try {
52142       try {
52143         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52144       }
52145       catch(std::out_of_range &_e) {
52146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52147         return 0;
52148       }
52149
52150     } CALL_CATCH_EXCEPTION(0);
52151   }
52152
52153   jresult = (void *)result;
52154   return jresult;
52155 }
52156
52157
52158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52159   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52160
52161   arg1 = (std::vector< unsigned int > *)jarg1;
52162   {
52163     try {
52164       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52165     } CALL_CATCH_EXCEPTION();
52166   }
52167
52168 }
52169
52170
52171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52173   int arg2 ;
52174   int arg3 ;
52175
52176   arg1 = (std::vector< unsigned int > *)jarg1;
52177   arg2 = (int)jarg2;
52178   arg3 = (int)jarg3;
52179   {
52180     try {
52181       try {
52182         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52183       }
52184       catch(std::out_of_range &_e) {
52185         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52186         return ;
52187       }
52188       catch(std::invalid_argument &_e) {
52189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52190         return ;
52191       }
52192
52193     } CALL_CATCH_EXCEPTION();
52194   }
52195
52196 }
52197
52198
52199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52200   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52201   int arg2 ;
52202   std::vector< unsigned int > *arg3 = 0 ;
52203
52204   arg1 = (std::vector< unsigned int > *)jarg1;
52205   arg2 = (int)jarg2;
52206   arg3 = (std::vector< unsigned int > *)jarg3;
52207   if (!arg3) {
52208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52209     return ;
52210   }
52211   {
52212     try {
52213       try {
52214         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52215       }
52216       catch(std::out_of_range &_e) {
52217         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52218         return ;
52219       }
52220
52221     } CALL_CATCH_EXCEPTION();
52222   }
52223
52224 }
52225
52226
52227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52228   unsigned int jresult ;
52229   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52230   unsigned int *arg2 = 0 ;
52231   unsigned int temp2 ;
52232   bool result;
52233
52234   arg1 = (std::vector< unsigned int > *)jarg1;
52235   temp2 = (unsigned int)jarg2;
52236   arg2 = &temp2;
52237   {
52238     try {
52239       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52240     } CALL_CATCH_EXCEPTION(0);
52241   }
52242
52243   jresult = result;
52244   return jresult;
52245 }
52246
52247
52248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52249   int jresult ;
52250   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52251   unsigned int *arg2 = 0 ;
52252   unsigned int temp2 ;
52253   int result;
52254
52255   arg1 = (std::vector< unsigned int > *)jarg1;
52256   temp2 = (unsigned int)jarg2;
52257   arg2 = &temp2;
52258   {
52259     try {
52260       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52261     } CALL_CATCH_EXCEPTION(0);
52262   }
52263
52264   jresult = result;
52265   return jresult;
52266 }
52267
52268
52269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52270   int jresult ;
52271   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52272   unsigned int *arg2 = 0 ;
52273   unsigned int temp2 ;
52274   int result;
52275
52276   arg1 = (std::vector< unsigned int > *)jarg1;
52277   temp2 = (unsigned int)jarg2;
52278   arg2 = &temp2;
52279   {
52280     try {
52281       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52282     } CALL_CATCH_EXCEPTION(0);
52283   }
52284
52285   jresult = result;
52286   return jresult;
52287 }
52288
52289
52290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52291   unsigned int jresult ;
52292   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52293   unsigned int *arg2 = 0 ;
52294   unsigned int temp2 ;
52295   bool result;
52296
52297   arg1 = (std::vector< unsigned int > *)jarg1;
52298   temp2 = (unsigned int)jarg2;
52299   arg2 = &temp2;
52300   {
52301     try {
52302       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52303     } CALL_CATCH_EXCEPTION(0);
52304   }
52305
52306   jresult = result;
52307   return jresult;
52308 }
52309
52310
52311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52312   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52313
52314   arg1 = (std::vector< unsigned int > *)jarg1;
52315   {
52316     try {
52317       delete arg1;
52318     } CALL_CATCH_EXCEPTION();
52319   }
52320
52321 }
52322
52323
52324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52325   void * jresult ;
52326   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52327
52328   {
52329     try {
52330       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52331     } CALL_CATCH_EXCEPTION(0);
52332   }
52333
52334   jresult = (void *)result;
52335   return jresult;
52336 }
52337
52338
52339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52340   void * jresult ;
52341   unsigned int arg1 ;
52342   Dali::Actor arg2 ;
52343   Dali::Actor *argp2 ;
52344   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52345
52346   arg1 = (unsigned int)jarg1;
52347   argp2 = (Dali::Actor *)jarg2;
52348   if (!argp2) {
52349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52350     return 0;
52351   }
52352   arg2 = *argp2;
52353   {
52354     try {
52355       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52356     } CALL_CATCH_EXCEPTION(0);
52357   }
52358
52359   jresult = (void *)result;
52360   return jresult;
52361 }
52362
52363
52364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52365   void * jresult ;
52366   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52367   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52368
52369   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52370   if (!arg1) {
52371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52372     return 0;
52373   }
52374   {
52375     try {
52376       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52377     } CALL_CATCH_EXCEPTION(0);
52378   }
52379
52380   jresult = (void *)result;
52381   return jresult;
52382 }
52383
52384
52385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52386   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52387   unsigned int arg2 ;
52388
52389   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52390   arg2 = (unsigned int)jarg2;
52391   if (arg1) (arg1)->first = arg2;
52392 }
52393
52394
52395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52396   unsigned int jresult ;
52397   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52398   unsigned int result;
52399
52400   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52401   result = (unsigned int) ((arg1)->first);
52402   jresult = result;
52403   return jresult;
52404 }
52405
52406
52407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52408   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52409   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52410
52411   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52412   arg2 = (Dali::Actor *)jarg2;
52413   if (arg1) (arg1)->second = *arg2;
52414 }
52415
52416
52417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52418   void * jresult ;
52419   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52420   Dali::Actor *result = 0 ;
52421
52422   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52423   result = (Dali::Actor *)& ((arg1)->second);
52424   jresult = (void *)result;
52425   return jresult;
52426 }
52427
52428
52429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52430   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52431
52432   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52433   {
52434     try {
52435       delete arg1;
52436     } CALL_CATCH_EXCEPTION();
52437   }
52438
52439 }
52440
52441
52442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52444
52445   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52446   {
52447     try {
52448       (arg1)->clear();
52449     } CALL_CATCH_EXCEPTION();
52450   }
52451
52452 }
52453
52454
52455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52456   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52457   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52458
52459   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52460   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52461   if (!arg2) {
52462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52463     return ;
52464   }
52465   {
52466     try {
52467       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52468     } CALL_CATCH_EXCEPTION();
52469   }
52470
52471 }
52472
52473
52474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52475   unsigned long jresult ;
52476   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52477   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52478
52479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52480   {
52481     try {
52482       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52483     } CALL_CATCH_EXCEPTION(0);
52484   }
52485
52486   jresult = (unsigned long)result;
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
52492   unsigned long jresult ;
52493   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52494   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52495
52496   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52497   {
52498     try {
52499       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
52500     } CALL_CATCH_EXCEPTION(0);
52501   }
52502
52503   jresult = (unsigned long)result;
52504   return jresult;
52505 }
52506
52507
52508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52509   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52510   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52511
52512   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52513   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52514   {
52515     try {
52516       (arg1)->reserve(arg2);
52517     } CALL_CATCH_EXCEPTION();
52518   }
52519
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52524   void * jresult ;
52525   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52526
52527   {
52528     try {
52529       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52530     } CALL_CATCH_EXCEPTION(0);
52531   }
52532
52533   jresult = (void *)result;
52534   return jresult;
52535 }
52536
52537
52538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52539   void * jresult ;
52540   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52541   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52542
52543   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52544   if (!arg1) {
52545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52546     return 0;
52547   }
52548   {
52549     try {
52550       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);
52551     } CALL_CATCH_EXCEPTION(0);
52552   }
52553
52554   jresult = (void *)result;
52555   return jresult;
52556 }
52557
52558
52559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52560   void * jresult ;
52561   int arg1 ;
52562   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52563
52564   arg1 = (int)jarg1;
52565   {
52566     try {
52567       try {
52568         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);
52569       }
52570       catch(std::out_of_range &_e) {
52571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52572         return 0;
52573       }
52574
52575     } CALL_CATCH_EXCEPTION(0);
52576   }
52577
52578   jresult = (void *)result;
52579   return jresult;
52580 }
52581
52582
52583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52584   void * jresult ;
52585   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52586   int arg2 ;
52587   std::pair< unsigned int,Dali::Actor > result;
52588
52589   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52590   arg2 = (int)jarg2;
52591   {
52592     try {
52593       try {
52594         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52595       }
52596       catch(std::out_of_range &_e) {
52597         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52598         return 0;
52599       }
52600
52601     } CALL_CATCH_EXCEPTION(0);
52602   }
52603
52604   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52605   return jresult;
52606 }
52607
52608
52609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52610   void * jresult ;
52611   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52612   int arg2 ;
52613   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52614
52615   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52616   arg2 = (int)jarg2;
52617   {
52618     try {
52619       try {
52620         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52621       }
52622       catch(std::out_of_range &_e) {
52623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52624         return 0;
52625       }
52626
52627     } CALL_CATCH_EXCEPTION(0);
52628   }
52629
52630   jresult = (void *)result;
52631   return jresult;
52632 }
52633
52634
52635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52636   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52637   int arg2 ;
52638   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52639
52640   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52641   arg2 = (int)jarg2;
52642   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52643   if (!arg3) {
52644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52645     return ;
52646   }
52647   {
52648     try {
52649       try {
52650         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);
52651       }
52652       catch(std::out_of_range &_e) {
52653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52654         return ;
52655       }
52656
52657     } CALL_CATCH_EXCEPTION();
52658   }
52659
52660 }
52661
52662
52663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52664   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52665   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52666
52667   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52668   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52669   if (!arg2) {
52670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52671     return ;
52672   }
52673   {
52674     try {
52675       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);
52676     } CALL_CATCH_EXCEPTION();
52677   }
52678
52679 }
52680
52681
52682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52683   void * jresult ;
52684   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52685   int arg2 ;
52686   int arg3 ;
52687   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52688
52689   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52690   arg2 = (int)jarg2;
52691   arg3 = (int)jarg3;
52692   {
52693     try {
52694       try {
52695         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);
52696       }
52697       catch(std::out_of_range &_e) {
52698         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52699         return 0;
52700       }
52701       catch(std::invalid_argument &_e) {
52702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52703         return 0;
52704       }
52705
52706     } CALL_CATCH_EXCEPTION(0);
52707   }
52708
52709   jresult = (void *)result;
52710   return jresult;
52711 }
52712
52713
52714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52715   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52716   int arg2 ;
52717   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52718
52719   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52720   arg2 = (int)jarg2;
52721   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52722   if (!arg3) {
52723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52724     return ;
52725   }
52726   {
52727     try {
52728       try {
52729         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);
52730       }
52731       catch(std::out_of_range &_e) {
52732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52733         return ;
52734       }
52735
52736     } CALL_CATCH_EXCEPTION();
52737   }
52738
52739 }
52740
52741
52742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52743   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52744   int arg2 ;
52745   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52746
52747   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52748   arg2 = (int)jarg2;
52749   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52750   if (!arg3) {
52751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52752     return ;
52753   }
52754   {
52755     try {
52756       try {
52757         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);
52758       }
52759       catch(std::out_of_range &_e) {
52760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52761         return ;
52762       }
52763
52764     } CALL_CATCH_EXCEPTION();
52765   }
52766
52767 }
52768
52769
52770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
52771   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52772   int arg2 ;
52773
52774   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52775   arg2 = (int)jarg2;
52776   {
52777     try {
52778       try {
52779         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
52780       }
52781       catch(std::out_of_range &_e) {
52782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52783         return ;
52784       }
52785
52786     } CALL_CATCH_EXCEPTION();
52787   }
52788
52789 }
52790
52791
52792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52793   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52794   int arg2 ;
52795   int arg3 ;
52796
52797   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52798   arg2 = (int)jarg2;
52799   arg3 = (int)jarg3;
52800   {
52801     try {
52802       try {
52803         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
52804       }
52805       catch(std::out_of_range &_e) {
52806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52807         return ;
52808       }
52809       catch(std::invalid_argument &_e) {
52810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52811         return ;
52812       }
52813
52814     } CALL_CATCH_EXCEPTION();
52815   }
52816
52817 }
52818
52819
52820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
52821   void * jresult ;
52822   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52823   int arg2 ;
52824   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52825
52826   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52827   if (!arg1) {
52828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52829     return 0;
52830   }
52831   arg2 = (int)jarg2;
52832   {
52833     try {
52834       try {
52835         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);
52836       }
52837       catch(std::out_of_range &_e) {
52838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52839         return 0;
52840       }
52841
52842     } CALL_CATCH_EXCEPTION(0);
52843   }
52844
52845   jresult = (void *)result;
52846   return jresult;
52847 }
52848
52849
52850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
52851   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52852
52853   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52854   {
52855     try {
52856       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
52857     } CALL_CATCH_EXCEPTION();
52858   }
52859
52860 }
52861
52862
52863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52864   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52865   int arg2 ;
52866   int arg3 ;
52867
52868   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52869   arg2 = (int)jarg2;
52870   arg3 = (int)jarg3;
52871   {
52872     try {
52873       try {
52874         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52875       }
52876       catch(std::out_of_range &_e) {
52877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52878         return ;
52879       }
52880       catch(std::invalid_argument &_e) {
52881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52882         return ;
52883       }
52884
52885     } CALL_CATCH_EXCEPTION();
52886   }
52887
52888 }
52889
52890
52891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52892   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52893   int arg2 ;
52894   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52895
52896   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52897   arg2 = (int)jarg2;
52898   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52899   if (!arg3) {
52900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52901     return ;
52902   }
52903   {
52904     try {
52905       try {
52906         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);
52907       }
52908       catch(std::out_of_range &_e) {
52909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52910         return ;
52911       }
52912
52913     } CALL_CATCH_EXCEPTION();
52914   }
52915
52916 }
52917
52918
52919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
52920   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52921
52922   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52923   {
52924     try {
52925       delete arg1;
52926     } CALL_CATCH_EXCEPTION();
52927   }
52928
52929 }
52930
52931
52932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
52933   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52934
52935   arg1 = (std::vector< Dali::Actor > *)jarg1;
52936   {
52937     try {
52938       (arg1)->clear();
52939     } CALL_CATCH_EXCEPTION();
52940   }
52941
52942 }
52943
52944
52945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
52946   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52947   Dali::Actor *arg2 = 0 ;
52948
52949   arg1 = (std::vector< Dali::Actor > *)jarg1;
52950   arg2 = (Dali::Actor *)jarg2;
52951   if (!arg2) {
52952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
52953     return ;
52954   }
52955   {
52956     try {
52957       (arg1)->push_back((Dali::Actor const &)*arg2);
52958     } CALL_CATCH_EXCEPTION();
52959   }
52960
52961 }
52962
52963
52964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
52965   unsigned long jresult ;
52966   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52967   std::vector< Dali::Actor >::size_type result;
52968
52969   arg1 = (std::vector< Dali::Actor > *)jarg1;
52970   {
52971     try {
52972       result = ((std::vector< Dali::Actor > const *)arg1)->size();
52973     } CALL_CATCH_EXCEPTION(0);
52974   }
52975
52976   jresult = (unsigned long)result;
52977   return jresult;
52978 }
52979
52980
52981 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
52982   unsigned long jresult ;
52983   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52984   std::vector< Dali::Actor >::size_type result;
52985
52986   arg1 = (std::vector< Dali::Actor > *)jarg1;
52987   {
52988     try {
52989       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
52990     } CALL_CATCH_EXCEPTION(0);
52991   }
52992
52993   jresult = (unsigned long)result;
52994   return jresult;
52995 }
52996
52997
52998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
52999   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53000   std::vector< Dali::Actor >::size_type arg2 ;
53001
53002   arg1 = (std::vector< Dali::Actor > *)jarg1;
53003   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53004   {
53005     try {
53006       (arg1)->reserve(arg2);
53007     } CALL_CATCH_EXCEPTION();
53008   }
53009
53010 }
53011
53012
53013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53014   void * jresult ;
53015   std::vector< Dali::Actor > *result = 0 ;
53016
53017   {
53018     try {
53019       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53020     } CALL_CATCH_EXCEPTION(0);
53021   }
53022
53023   jresult = (void *)result;
53024   return jresult;
53025 }
53026
53027
53028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53029   void * jresult ;
53030   std::vector< Dali::Actor > *arg1 = 0 ;
53031   std::vector< Dali::Actor > *result = 0 ;
53032
53033   arg1 = (std::vector< Dali::Actor > *)jarg1;
53034   if (!arg1) {
53035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53036     return 0;
53037   }
53038   {
53039     try {
53040       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53041     } CALL_CATCH_EXCEPTION(0);
53042   }
53043
53044   jresult = (void *)result;
53045   return jresult;
53046 }
53047
53048
53049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53050   void * jresult ;
53051   int arg1 ;
53052   std::vector< Dali::Actor > *result = 0 ;
53053
53054   arg1 = (int)jarg1;
53055   {
53056     try {
53057       try {
53058         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53059       }
53060       catch(std::out_of_range &_e) {
53061         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53062         return 0;
53063       }
53064
53065     } CALL_CATCH_EXCEPTION(0);
53066   }
53067
53068   jresult = (void *)result;
53069   return jresult;
53070 }
53071
53072
53073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53074   void * jresult ;
53075   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53076   int arg2 ;
53077   Dali::Actor result;
53078
53079   arg1 = (std::vector< Dali::Actor > *)jarg1;
53080   arg2 = (int)jarg2;
53081   {
53082     try {
53083       try {
53084         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53085       }
53086       catch(std::out_of_range &_e) {
53087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53088         return 0;
53089       }
53090
53091     } CALL_CATCH_EXCEPTION(0);
53092   }
53093
53094   jresult = new Dali::Actor((const Dali::Actor &)result);
53095   return jresult;
53096 }
53097
53098
53099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53100   void * jresult ;
53101   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53102   int arg2 ;
53103   Dali::Actor *result = 0 ;
53104
53105   arg1 = (std::vector< Dali::Actor > *)jarg1;
53106   arg2 = (int)jarg2;
53107   {
53108     try {
53109       try {
53110         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53111       }
53112       catch(std::out_of_range &_e) {
53113         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53114         return 0;
53115       }
53116
53117     } CALL_CATCH_EXCEPTION(0);
53118   }
53119
53120   jresult = (void *)result;
53121   return jresult;
53122 }
53123
53124
53125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53126   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53127   int arg2 ;
53128   Dali::Actor *arg3 = 0 ;
53129
53130   arg1 = (std::vector< Dali::Actor > *)jarg1;
53131   arg2 = (int)jarg2;
53132   arg3 = (Dali::Actor *)jarg3;
53133   if (!arg3) {
53134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53135     return ;
53136   }
53137   {
53138     try {
53139       try {
53140         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53141       }
53142       catch(std::out_of_range &_e) {
53143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53144         return ;
53145       }
53146
53147     } CALL_CATCH_EXCEPTION();
53148   }
53149
53150 }
53151
53152
53153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53154   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53155   std::vector< Dali::Actor > *arg2 = 0 ;
53156
53157   arg1 = (std::vector< Dali::Actor > *)jarg1;
53158   arg2 = (std::vector< Dali::Actor > *)jarg2;
53159   if (!arg2) {
53160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53161     return ;
53162   }
53163   {
53164     try {
53165       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53166     } CALL_CATCH_EXCEPTION();
53167   }
53168
53169 }
53170
53171
53172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53173   void * jresult ;
53174   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53175   int arg2 ;
53176   int arg3 ;
53177   std::vector< Dali::Actor > *result = 0 ;
53178
53179   arg1 = (std::vector< Dali::Actor > *)jarg1;
53180   arg2 = (int)jarg2;
53181   arg3 = (int)jarg3;
53182   {
53183     try {
53184       try {
53185         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53186       }
53187       catch(std::out_of_range &_e) {
53188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53189         return 0;
53190       }
53191       catch(std::invalid_argument &_e) {
53192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53193         return 0;
53194       }
53195
53196     } CALL_CATCH_EXCEPTION(0);
53197   }
53198
53199   jresult = (void *)result;
53200   return jresult;
53201 }
53202
53203
53204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53205   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53206   int arg2 ;
53207   Dali::Actor *arg3 = 0 ;
53208
53209   arg1 = (std::vector< Dali::Actor > *)jarg1;
53210   arg2 = (int)jarg2;
53211   arg3 = (Dali::Actor *)jarg3;
53212   if (!arg3) {
53213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53214     return ;
53215   }
53216   {
53217     try {
53218       try {
53219         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53220       }
53221       catch(std::out_of_range &_e) {
53222         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53223         return ;
53224       }
53225
53226     } CALL_CATCH_EXCEPTION();
53227   }
53228
53229 }
53230
53231
53232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53233   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53234   int arg2 ;
53235   std::vector< Dali::Actor > *arg3 = 0 ;
53236
53237   arg1 = (std::vector< Dali::Actor > *)jarg1;
53238   arg2 = (int)jarg2;
53239   arg3 = (std::vector< Dali::Actor > *)jarg3;
53240   if (!arg3) {
53241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53242     return ;
53243   }
53244   {
53245     try {
53246       try {
53247         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53248       }
53249       catch(std::out_of_range &_e) {
53250         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53251         return ;
53252       }
53253
53254     } CALL_CATCH_EXCEPTION();
53255   }
53256
53257 }
53258
53259
53260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53261   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53262   int arg2 ;
53263
53264   arg1 = (std::vector< Dali::Actor > *)jarg1;
53265   arg2 = (int)jarg2;
53266   {
53267     try {
53268       try {
53269         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53270       }
53271       catch(std::out_of_range &_e) {
53272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53273         return ;
53274       }
53275
53276     } CALL_CATCH_EXCEPTION();
53277   }
53278
53279 }
53280
53281
53282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53283   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53284   int arg2 ;
53285   int arg3 ;
53286
53287   arg1 = (std::vector< Dali::Actor > *)jarg1;
53288   arg2 = (int)jarg2;
53289   arg3 = (int)jarg3;
53290   {
53291     try {
53292       try {
53293         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53294       }
53295       catch(std::out_of_range &_e) {
53296         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53297         return ;
53298       }
53299       catch(std::invalid_argument &_e) {
53300         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53301         return ;
53302       }
53303
53304     } CALL_CATCH_EXCEPTION();
53305   }
53306
53307 }
53308
53309
53310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53311   void * jresult ;
53312   Dali::Actor *arg1 = 0 ;
53313   int arg2 ;
53314   std::vector< Dali::Actor > *result = 0 ;
53315
53316   arg1 = (Dali::Actor *)jarg1;
53317   if (!arg1) {
53318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53319     return 0;
53320   }
53321   arg2 = (int)jarg2;
53322   {
53323     try {
53324       try {
53325         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53326       }
53327       catch(std::out_of_range &_e) {
53328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53329         return 0;
53330       }
53331
53332     } CALL_CATCH_EXCEPTION(0);
53333   }
53334
53335   jresult = (void *)result;
53336   return jresult;
53337 }
53338
53339
53340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53341   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53342
53343   arg1 = (std::vector< Dali::Actor > *)jarg1;
53344   {
53345     try {
53346       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53347     } CALL_CATCH_EXCEPTION();
53348   }
53349
53350 }
53351
53352
53353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53354   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53355   int arg2 ;
53356   int arg3 ;
53357
53358   arg1 = (std::vector< Dali::Actor > *)jarg1;
53359   arg2 = (int)jarg2;
53360   arg3 = (int)jarg3;
53361   {
53362     try {
53363       try {
53364         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53365       }
53366       catch(std::out_of_range &_e) {
53367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53368         return ;
53369       }
53370       catch(std::invalid_argument &_e) {
53371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53372         return ;
53373       }
53374
53375     } CALL_CATCH_EXCEPTION();
53376   }
53377
53378 }
53379
53380
53381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53382   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53383   int arg2 ;
53384   std::vector< Dali::Actor > *arg3 = 0 ;
53385
53386   arg1 = (std::vector< Dali::Actor > *)jarg1;
53387   arg2 = (int)jarg2;
53388   arg3 = (std::vector< Dali::Actor > *)jarg3;
53389   if (!arg3) {
53390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53391     return ;
53392   }
53393   {
53394     try {
53395       try {
53396         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53397       }
53398       catch(std::out_of_range &_e) {
53399         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53400         return ;
53401       }
53402
53403     } CALL_CATCH_EXCEPTION();
53404   }
53405
53406 }
53407
53408
53409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53410   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53411
53412   arg1 = (std::vector< Dali::Actor > *)jarg1;
53413   {
53414     try {
53415       delete arg1;
53416     } CALL_CATCH_EXCEPTION();
53417   }
53418
53419 }
53420
53421
53422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53423   unsigned int jresult ;
53424   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53425   bool result;
53426
53427   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53428   {
53429     try {
53430       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53431     } CALL_CATCH_EXCEPTION(0);
53432   }
53433
53434   jresult = result;
53435   return jresult;
53436 }
53437
53438
53439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53440   unsigned long jresult ;
53441   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53442   std::size_t result;
53443
53444   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53445   {
53446     try {
53447       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53448     } CALL_CATCH_EXCEPTION(0);
53449   }
53450
53451   jresult = (unsigned long)result;
53452   return jresult;
53453 }
53454
53455
53456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53457   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53458   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53459
53460   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53461   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53462   {
53463     try {
53464       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53465     } CALL_CATCH_EXCEPTION();
53466   }
53467
53468 }
53469
53470
53471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53472   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53473   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53474
53475   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53476   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53477   {
53478     try {
53479       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53480     } CALL_CATCH_EXCEPTION();
53481   }
53482
53483 }
53484
53485
53486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53487   unsigned int jresult ;
53488   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53489   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53490   bool result;
53491
53492   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53493   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53494   if (!arg2) {
53495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53496     return 0;
53497   }
53498   {
53499     try {
53500       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53501     } CALL_CATCH_EXCEPTION(0);
53502   }
53503
53504   jresult = result;
53505   return jresult;
53506 }
53507
53508
53509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53510   void * jresult ;
53511   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53512
53513   {
53514     try {
53515       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53516     } CALL_CATCH_EXCEPTION(0);
53517   }
53518
53519   jresult = (void *)result;
53520   return jresult;
53521 }
53522
53523
53524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53525   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53526
53527   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53528   {
53529     try {
53530       delete arg1;
53531     } CALL_CATCH_EXCEPTION();
53532   }
53533
53534 }
53535
53536
53537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53538   unsigned int jresult ;
53539   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53540   bool result;
53541
53542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53543   {
53544     try {
53545       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);
53546     } CALL_CATCH_EXCEPTION(0);
53547   }
53548
53549   jresult = result;
53550   return jresult;
53551 }
53552
53553
53554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53555   unsigned long jresult ;
53556   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53557   std::size_t result;
53558
53559   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53560   {
53561     try {
53562       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);
53563     } CALL_CATCH_EXCEPTION(0);
53564   }
53565
53566   jresult = (unsigned long)result;
53567   return jresult;
53568 }
53569
53570
53571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53572   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53573   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53574
53575   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53576   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53577   {
53578     try {
53579       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53580     } CALL_CATCH_EXCEPTION();
53581   }
53582
53583 }
53584
53585
53586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53587   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53588   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53589
53590   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53591   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53592   {
53593     try {
53594       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53595     } CALL_CATCH_EXCEPTION();
53596   }
53597
53598 }
53599
53600
53601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53602   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53603   Dali::Actor arg2 ;
53604   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53605   Dali::Actor *argp2 ;
53606
53607   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53608   argp2 = (Dali::Actor *)jarg2;
53609   if (!argp2) {
53610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53611     return ;
53612   }
53613   arg2 = *argp2;
53614   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53615   {
53616     try {
53617       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53618     } CALL_CATCH_EXCEPTION();
53619   }
53620
53621 }
53622
53623
53624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53625   void * jresult ;
53626   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53627
53628   {
53629     try {
53630       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53631     } CALL_CATCH_EXCEPTION(0);
53632   }
53633
53634   jresult = (void *)result;
53635   return jresult;
53636 }
53637
53638
53639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53640   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53641
53642   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53643   {
53644     try {
53645       delete arg1;
53646     } CALL_CATCH_EXCEPTION();
53647   }
53648
53649 }
53650
53651
53652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53653   unsigned int jresult ;
53654   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53655   bool result;
53656
53657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53658   {
53659     try {
53660       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53661     } CALL_CATCH_EXCEPTION(0);
53662   }
53663
53664   jresult = result;
53665   return jresult;
53666 }
53667
53668
53669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53670   unsigned long jresult ;
53671   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53672   std::size_t result;
53673
53674   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53675   {
53676     try {
53677       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53678     } CALL_CATCH_EXCEPTION(0);
53679   }
53680
53681   jresult = (unsigned long)result;
53682   return jresult;
53683 }
53684
53685
53686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53687   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53688   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53689
53690   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53691   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53692   {
53693     try {
53694       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53695     } CALL_CATCH_EXCEPTION();
53696   }
53697
53698 }
53699
53700
53701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53702   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53703   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53704
53705   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53706   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53707   {
53708     try {
53709       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53710     } CALL_CATCH_EXCEPTION();
53711   }
53712
53713 }
53714
53715
53716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53717   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53718   Dali::Actor arg2 ;
53719   Dali::Actor arg3 ;
53720   Dali::Actor *argp2 ;
53721   Dali::Actor *argp3 ;
53722
53723   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53724   argp2 = (Dali::Actor *)jarg2;
53725   if (!argp2) {
53726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53727     return ;
53728   }
53729   arg2 = *argp2;
53730   argp3 = (Dali::Actor *)jarg3;
53731   if (!argp3) {
53732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53733     return ;
53734   }
53735   arg3 = *argp3;
53736   {
53737     try {
53738       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53739     } CALL_CATCH_EXCEPTION();
53740   }
53741
53742 }
53743
53744
53745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53746   void * jresult ;
53747   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53748
53749   {
53750     try {
53751       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53752     } CALL_CATCH_EXCEPTION(0);
53753   }
53754
53755   jresult = (void *)result;
53756   return jresult;
53757 }
53758
53759
53760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53761   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53762
53763   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53764   {
53765     try {
53766       delete arg1;
53767     } CALL_CATCH_EXCEPTION();
53768   }
53769
53770 }
53771
53772
53773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
53774   unsigned int jresult ;
53775   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53776   bool result;
53777
53778   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53779   {
53780     try {
53781       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53782     } CALL_CATCH_EXCEPTION(0);
53783   }
53784
53785   jresult = result;
53786   return jresult;
53787 }
53788
53789
53790 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
53791   unsigned long jresult ;
53792   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53793   std::size_t result;
53794
53795   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53796   {
53797     try {
53798       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53799     } CALL_CATCH_EXCEPTION(0);
53800   }
53801
53802   jresult = (unsigned long)result;
53803   return jresult;
53804 }
53805
53806
53807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
53808   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53809   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53810
53811   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53812   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53813   {
53814     try {
53815       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
53816     } CALL_CATCH_EXCEPTION();
53817   }
53818
53819 }
53820
53821
53822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53823   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53824   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53825
53826   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53827   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53828   {
53829     try {
53830       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
53831     } CALL_CATCH_EXCEPTION();
53832   }
53833
53834 }
53835
53836
53837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
53838   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53839   Dali::Actor arg2 ;
53840   bool arg3 ;
53841   Dali::Actor *argp2 ;
53842
53843   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53844   argp2 = (Dali::Actor *)jarg2;
53845   if (!argp2) {
53846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53847     return ;
53848   }
53849   arg2 = *argp2;
53850   arg3 = jarg3 ? true : false;
53851   {
53852     try {
53853       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
53854     } CALL_CATCH_EXCEPTION();
53855   }
53856
53857 }
53858
53859
53860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
53861   void * jresult ;
53862   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
53863
53864   {
53865     try {
53866       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
53867     } CALL_CATCH_EXCEPTION(0);
53868   }
53869
53870   jresult = (void *)result;
53871   return jresult;
53872 }
53873
53874
53875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
53876   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53877
53878   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53879   {
53880     try {
53881       delete arg1;
53882     } CALL_CATCH_EXCEPTION();
53883   }
53884
53885 }
53886
53887
53888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
53889   unsigned int jresult ;
53890   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53891   bool result;
53892
53893   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53894   {
53895     try {
53896       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);
53897     } CALL_CATCH_EXCEPTION(0);
53898   }
53899
53900   jresult = result;
53901   return jresult;
53902 }
53903
53904
53905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
53906   unsigned long jresult ;
53907   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53908   std::size_t result;
53909
53910   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53911   {
53912     try {
53913       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);
53914     } CALL_CATCH_EXCEPTION(0);
53915   }
53916
53917   jresult = (unsigned long)result;
53918   return jresult;
53919 }
53920
53921
53922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
53923   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53924   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
53925
53926   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53927   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
53928   {
53929     try {
53930       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
53931     } CALL_CATCH_EXCEPTION();
53932   }
53933
53934 }
53935
53936
53937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53938   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53939   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
53940
53941   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53942   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
53943   {
53944     try {
53945       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
53946     } CALL_CATCH_EXCEPTION();
53947   }
53948
53949 }
53950
53951
53952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53953   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53954   Dali::Toolkit::StyleManager arg2 ;
53955   Dali::StyleChange::Type arg3 ;
53956   Dali::Toolkit::StyleManager *argp2 ;
53957
53958   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53959   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
53960   if (!argp2) {
53961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
53962     return ;
53963   }
53964   arg2 = *argp2;
53965   arg3 = (Dali::StyleChange::Type)jarg3;
53966   {
53967     try {
53968       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
53969     } CALL_CATCH_EXCEPTION();
53970   }
53971
53972 }
53973
53974
53975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
53976   void * jresult ;
53977   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
53978
53979   {
53980     try {
53981       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
53982     } CALL_CATCH_EXCEPTION(0);
53983   }
53984
53985   jresult = (void *)result;
53986   return jresult;
53987 }
53988
53989
53990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
53991   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53992
53993   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53994   {
53995     try {
53996       delete arg1;
53997     } CALL_CATCH_EXCEPTION();
53998   }
53999
54000 }
54001
54002
54003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54004   unsigned int jresult ;
54005   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54006   bool result;
54007
54008   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54009   {
54010     try {
54011       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54012     } CALL_CATCH_EXCEPTION(0);
54013   }
54014
54015   jresult = result;
54016   return jresult;
54017 }
54018
54019
54020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54021   unsigned long jresult ;
54022   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54023   std::size_t result;
54024
54025   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54026   {
54027     try {
54028       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54029     } CALL_CATCH_EXCEPTION(0);
54030   }
54031
54032   jresult = (unsigned long)result;
54033   return jresult;
54034 }
54035
54036
54037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54038   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54039   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54040
54041   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54042   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54043   {
54044     try {
54045       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54046     } CALL_CATCH_EXCEPTION();
54047   }
54048
54049 }
54050
54051
54052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54053   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54054   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54055
54056   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54057   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54058   {
54059     try {
54060       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54061     } CALL_CATCH_EXCEPTION();
54062   }
54063
54064 }
54065
54066
54067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54068   unsigned int jresult ;
54069   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54070   Dali::Toolkit::Button arg2 ;
54071   Dali::Toolkit::Button *argp2 ;
54072   bool result;
54073
54074   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54075   argp2 = (Dali::Toolkit::Button *)jarg2;
54076   if (!argp2) {
54077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54078     return 0;
54079   }
54080   arg2 = *argp2;
54081   {
54082     try {
54083       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54084     } CALL_CATCH_EXCEPTION(0);
54085   }
54086
54087   jresult = result;
54088   return jresult;
54089 }
54090
54091
54092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54093   void * jresult ;
54094   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54095
54096   {
54097     try {
54098       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54099     } CALL_CATCH_EXCEPTION(0);
54100   }
54101
54102   jresult = (void *)result;
54103   return jresult;
54104 }
54105
54106
54107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54108   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54109
54110   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54111   {
54112     try {
54113       delete arg1;
54114     } CALL_CATCH_EXCEPTION();
54115   }
54116
54117 }
54118
54119
54120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54121   unsigned int jresult ;
54122   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54123   bool result;
54124
54125   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54126   {
54127     try {
54128       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54129     } CALL_CATCH_EXCEPTION(0);
54130   }
54131
54132   jresult = result;
54133   return jresult;
54134 }
54135
54136
54137 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54138   unsigned long jresult ;
54139   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54140   std::size_t result;
54141
54142   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54143   {
54144     try {
54145       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54146     } CALL_CATCH_EXCEPTION(0);
54147   }
54148
54149   jresult = (unsigned long)result;
54150   return jresult;
54151 }
54152
54153
54154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54155   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54156   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54157
54158   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54159   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54160   {
54161     try {
54162       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54163     } CALL_CATCH_EXCEPTION();
54164   }
54165
54166 }
54167
54168
54169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54170   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54171   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54172
54173   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54174   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54175   {
54176     try {
54177       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54178     } CALL_CATCH_EXCEPTION();
54179   }
54180
54181 }
54182
54183
54184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54185   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54186   Dali::Toolkit::GaussianBlurView arg2 ;
54187   Dali::Toolkit::GaussianBlurView *argp2 ;
54188
54189   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54190   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54191   if (!argp2) {
54192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54193     return ;
54194   }
54195   arg2 = *argp2;
54196   {
54197     try {
54198       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54199     } CALL_CATCH_EXCEPTION();
54200   }
54201
54202 }
54203
54204
54205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54206   void * jresult ;
54207   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54208
54209   {
54210     try {
54211       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54212     } CALL_CATCH_EXCEPTION(0);
54213   }
54214
54215   jresult = (void *)result;
54216   return jresult;
54217 }
54218
54219
54220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54221   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54222
54223   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54224   {
54225     try {
54226       delete arg1;
54227     } CALL_CATCH_EXCEPTION();
54228   }
54229
54230 }
54231
54232
54233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54234   unsigned int jresult ;
54235   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54236   bool result;
54237
54238   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54239   {
54240     try {
54241       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);
54242     } CALL_CATCH_EXCEPTION(0);
54243   }
54244
54245   jresult = result;
54246   return jresult;
54247 }
54248
54249
54250 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54251   unsigned long jresult ;
54252   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54253   std::size_t result;
54254
54255   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54256   {
54257     try {
54258       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);
54259     } CALL_CATCH_EXCEPTION(0);
54260   }
54261
54262   jresult = (unsigned long)result;
54263   return jresult;
54264 }
54265
54266
54267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54268   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54269   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54270
54271   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54272   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54273   {
54274     try {
54275       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54276     } CALL_CATCH_EXCEPTION();
54277   }
54278
54279 }
54280
54281
54282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54283   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54284   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54285
54286   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54287   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54288   {
54289     try {
54290       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54291     } CALL_CATCH_EXCEPTION();
54292   }
54293
54294 }
54295
54296
54297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54298   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54299   Dali::Toolkit::PageTurnView arg2 ;
54300   unsigned int arg3 ;
54301   bool arg4 ;
54302   Dali::Toolkit::PageTurnView *argp2 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54305   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54306   if (!argp2) {
54307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54308     return ;
54309   }
54310   arg2 = *argp2;
54311   arg3 = (unsigned int)jarg3;
54312   arg4 = jarg4 ? true : false;
54313   {
54314     try {
54315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54316     } CALL_CATCH_EXCEPTION();
54317   }
54318
54319 }
54320
54321
54322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54323   void * jresult ;
54324   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54325
54326   {
54327     try {
54328       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54329     } CALL_CATCH_EXCEPTION(0);
54330   }
54331
54332   jresult = (void *)result;
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54338   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54339
54340   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54341   {
54342     try {
54343       delete arg1;
54344     } CALL_CATCH_EXCEPTION();
54345   }
54346
54347 }
54348
54349
54350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54351   unsigned int jresult ;
54352   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54353   bool result;
54354
54355   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54356   {
54357     try {
54358       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54359     } CALL_CATCH_EXCEPTION(0);
54360   }
54361
54362   jresult = result;
54363   return jresult;
54364 }
54365
54366
54367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54368   unsigned long jresult ;
54369   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54370   std::size_t result;
54371
54372   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54373   {
54374     try {
54375       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54376     } CALL_CATCH_EXCEPTION(0);
54377   }
54378
54379   jresult = (unsigned long)result;
54380   return jresult;
54381 }
54382
54383
54384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54385   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54386   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54387
54388   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54389   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54390   {
54391     try {
54392       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54393     } CALL_CATCH_EXCEPTION();
54394   }
54395 }
54396
54397
54398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54399   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54400   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54401
54402   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54403   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54404   {
54405     try {
54406       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54407     } CALL_CATCH_EXCEPTION();
54408   }
54409 }
54410
54411
54412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54413   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54414   Dali::Toolkit::PageTurnView arg2 ;
54415   Dali::Toolkit::PageTurnView *argp2 ;
54416
54417   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54418   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54419   if (!argp2) {
54420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54421     return ;
54422   }
54423   arg2 = *argp2;
54424   {
54425     try {
54426       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54427     } CALL_CATCH_EXCEPTION();
54428   }
54429 }
54430
54431
54432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54433   void * jresult ;
54434   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54435
54436   {
54437     try {
54438       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54439     } CALL_CATCH_EXCEPTION(0);
54440   }
54441
54442   jresult = (void *)result;
54443   return jresult;
54444 }
54445
54446
54447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54448   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54449
54450   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54451   {
54452     try {
54453       delete arg1;
54454     } CALL_CATCH_EXCEPTION();
54455   }
54456
54457 }
54458
54459
54460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54461   unsigned int jresult ;
54462   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54463   bool result;
54464
54465   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54466   {
54467     try {
54468       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);
54469     } CALL_CATCH_EXCEPTION(0);
54470   }
54471
54472   jresult = result;
54473   return jresult;
54474 }
54475
54476
54477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54478   unsigned long jresult ;
54479   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54480   std::size_t result;
54481
54482   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54483   {
54484     try {
54485       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);
54486     } CALL_CATCH_EXCEPTION(0);
54487   }
54488
54489   jresult = (unsigned long)result;
54490   return jresult;
54491 }
54492
54493
54494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54495   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54496   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54497
54498   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54499   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54500   {
54501     try {
54502       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54503     } CALL_CATCH_EXCEPTION();
54504   }
54505
54506 }
54507
54508
54509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54510   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54511   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54512
54513   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54514   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54515   {
54516     try {
54517       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54518     } CALL_CATCH_EXCEPTION();
54519   }
54520
54521 }
54522
54523
54524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54525   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54526   Dali::Toolkit::ProgressBar arg2 ;
54527   float arg3 ;
54528   float arg4 ;
54529   Dali::Toolkit::ProgressBar *argp2 ;
54530
54531   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54532   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54533   if (!argp2) {
54534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54535     return ;
54536   }
54537   arg2 = *argp2;
54538   arg3 = (float)jarg3;
54539   arg4 = (float)jarg4;
54540   {
54541     try {
54542       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54543     } CALL_CATCH_EXCEPTION();
54544   }
54545
54546 }
54547
54548
54549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54550   void * jresult ;
54551   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54552
54553   {
54554     try {
54555       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54556     } CALL_CATCH_EXCEPTION(0);
54557   }
54558
54559   jresult = (void *)result;
54560   return jresult;
54561 }
54562
54563
54564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54565   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54566
54567   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54568   {
54569     try {
54570       delete arg1;
54571     } CALL_CATCH_EXCEPTION();
54572   }
54573
54574 }
54575
54576
54577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54578   unsigned int jresult ;
54579   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54580   bool result;
54581
54582   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54583   {
54584     try {
54585       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);
54586     } CALL_CATCH_EXCEPTION(0);
54587   }
54588
54589   jresult = result;
54590   return jresult;
54591 }
54592
54593
54594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54595   unsigned long jresult ;
54596   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54597   std::size_t result;
54598
54599   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54600   {
54601     try {
54602       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);
54603     } CALL_CATCH_EXCEPTION(0);
54604   }
54605
54606   jresult = (unsigned long)result;
54607   return jresult;
54608 }
54609
54610
54611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54612   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54613   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54614
54615   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54616   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54617   {
54618     try {
54619       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54620     } CALL_CATCH_EXCEPTION();
54621   }
54622
54623 }
54624
54625
54626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54627   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54628   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54629
54630   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54631   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54632   {
54633     try {
54634       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54635     } CALL_CATCH_EXCEPTION();
54636   }
54637
54638 }
54639
54640
54641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54642   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54643   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54644
54645   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54646   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54647   if (!arg2) {
54648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54649     return ;
54650   }
54651   {
54652     try {
54653       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54654     } CALL_CATCH_EXCEPTION();
54655   }
54656
54657 }
54658
54659
54660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54661   void * jresult ;
54662   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54663
54664   {
54665     try {
54666       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54667     } CALL_CATCH_EXCEPTION(0);
54668   }
54669
54670   jresult = (void *)result;
54671   return jresult;
54672 }
54673
54674
54675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54676   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54677
54678   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54679   {
54680     try {
54681       delete arg1;
54682     } CALL_CATCH_EXCEPTION();
54683   }
54684
54685 }
54686
54687
54688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54689   unsigned int jresult ;
54690   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54691   bool result;
54692
54693   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54694   {
54695     try {
54696       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54697     } CALL_CATCH_EXCEPTION(0);
54698   }
54699
54700   jresult = result;
54701   return jresult;
54702 }
54703
54704
54705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54706   unsigned long jresult ;
54707   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54708   std::size_t result;
54709
54710   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54711   {
54712     try {
54713       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54714     } CALL_CATCH_EXCEPTION(0);
54715   }
54716
54717   jresult = (unsigned long)result;
54718   return jresult;
54719 }
54720
54721
54722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54723   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54724   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54725
54726   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54727   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54728   {
54729     try {
54730       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54731     } CALL_CATCH_EXCEPTION();
54732   }
54733
54734 }
54735
54736
54737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54738   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54739   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54740
54741   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54742   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54743   {
54744     try {
54745       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54746     } CALL_CATCH_EXCEPTION();
54747   }
54748
54749 }
54750
54751
54752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54753   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54754   Dali::Vector2 *arg2 = 0 ;
54755
54756   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54757   arg2 = (Dali::Vector2 *)jarg2;
54758   if (!arg2) {
54759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54760     return ;
54761   }
54762   {
54763     try {
54764       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
54765     } CALL_CATCH_EXCEPTION();
54766   }
54767
54768 }
54769
54770
54771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
54772   void * jresult ;
54773   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
54774
54775   {
54776     try {
54777       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
54778     } CALL_CATCH_EXCEPTION(0);
54779   }
54780
54781   jresult = (void *)result;
54782   return jresult;
54783 }
54784
54785
54786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
54787   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54788
54789   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54790   {
54791     try {
54792       delete arg1;
54793     } CALL_CATCH_EXCEPTION();
54794   }
54795
54796 }
54797
54798
54799
54800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
54801   unsigned int jresult ;
54802   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54803   bool result;
54804
54805   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54806   {
54807     try {
54808       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);
54809     } CALL_CATCH_EXCEPTION(0);
54810   }
54811
54812   jresult = result;
54813   return jresult;
54814 }
54815
54816
54817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
54818   unsigned long jresult ;
54819   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54820   std::size_t result;
54821
54822   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54823   {
54824     try {
54825       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);
54826     } CALL_CATCH_EXCEPTION(0);
54827   }
54828
54829   jresult = (unsigned long)result;
54830   return jresult;
54831 }
54832
54833
54834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
54835   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54836   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
54837
54838   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54839   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
54840   {
54841     try {
54842       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54843     } CALL_CATCH_EXCEPTION();
54844   }
54845
54846 }
54847
54848
54849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
54850   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54851   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
54852
54853   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54854   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
54855   {
54856     try {
54857       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54858     } CALL_CATCH_EXCEPTION();
54859   }
54860
54861 }
54862
54863
54864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54865   unsigned int jresult ;
54866   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54867   Dali::Toolkit::Control arg2 ;
54868   Dali::KeyEvent *arg3 = 0 ;
54869   Dali::Toolkit::Control *argp2 ;
54870   bool result;
54871
54872   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54873   argp2 = (Dali::Toolkit::Control *)jarg2;
54874   if (!argp2) {
54875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
54876     return 0;
54877   }
54878   arg2 = *argp2;
54879   arg3 = (Dali::KeyEvent *)jarg3;
54880   if (!arg3) {
54881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
54882     return 0;
54883   }
54884   {
54885     try {
54886       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);
54887     } CALL_CATCH_EXCEPTION(0);
54888   }
54889
54890   jresult = result;
54891   return jresult;
54892 }
54893
54894
54895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
54896   void * jresult ;
54897   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
54898
54899   {
54900     try {
54901       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
54902     } CALL_CATCH_EXCEPTION(0);
54903   }
54904
54905   jresult = (void *)result;
54906   return jresult;
54907 }
54908
54909
54910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
54911   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54912
54913   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54914   {
54915     try {
54916       delete arg1;
54917     } CALL_CATCH_EXCEPTION();
54918   }
54919
54920 }
54921
54922
54923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
54924   unsigned int jresult ;
54925   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54926   bool result;
54927
54928   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54929   {
54930     try {
54931       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
54932     } CALL_CATCH_EXCEPTION(0);
54933   }
54934
54935   jresult = result;
54936   return jresult;
54937 }
54938
54939
54940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
54941   unsigned long jresult ;
54942   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54943   std::size_t result;
54944
54945   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54946   {
54947     try {
54948       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
54949     } CALL_CATCH_EXCEPTION(0);
54950   }
54951
54952   jresult = (unsigned long)result;
54953   return jresult;
54954 }
54955
54956
54957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
54958   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54959   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
54960
54961   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54962   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
54963   {
54964     try {
54965       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
54966     } CALL_CATCH_EXCEPTION();
54967   }
54968
54969 }
54970
54971
54972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
54973   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54974   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
54975
54976   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54977   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
54978   {
54979     try {
54980       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
54981     } CALL_CATCH_EXCEPTION();
54982   }
54983
54984 }
54985
54986
54987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
54988   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54989   Dali::Toolkit::Control arg2 ;
54990   Dali::Toolkit::Control *argp2 ;
54991
54992   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54993   argp2 = (Dali::Toolkit::Control *)jarg2;
54994   if (!argp2) {
54995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
54996     return ;
54997   }
54998   arg2 = *argp2;
54999   {
55000     try {
55001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55002     } CALL_CATCH_EXCEPTION();
55003   }
55004
55005 }
55006
55007
55008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55009   void * jresult ;
55010   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55011
55012   {
55013     try {
55014       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55015     } CALL_CATCH_EXCEPTION(0);
55016   }
55017
55018   jresult = (void *)result;
55019   return jresult;
55020 }
55021
55022
55023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55024   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55025
55026   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55027   {
55028     try {
55029       delete arg1;
55030     } CALL_CATCH_EXCEPTION();
55031   }
55032
55033 }
55034
55035
55036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55037   unsigned int jresult ;
55038   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55039   bool result;
55040
55041   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55042   {
55043     try {
55044       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55045     } CALL_CATCH_EXCEPTION(0);
55046   }
55047
55048   jresult = result;
55049   return jresult;
55050 }
55051
55052
55053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55054   unsigned long jresult ;
55055   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55056   std::size_t result;
55057
55058   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55059   {
55060     try {
55061       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55062     } CALL_CATCH_EXCEPTION(0);
55063   }
55064
55065   jresult = (unsigned long)result;
55066   return jresult;
55067 }
55068
55069
55070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55071   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55072   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55073
55074   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55075   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55076   {
55077     try {
55078       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55079     } CALL_CATCH_EXCEPTION();
55080   }
55081
55082 }
55083
55084
55085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55086   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55087   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55088
55089   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55090   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55091   {
55092     try {
55093       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55094     } CALL_CATCH_EXCEPTION();
55095   }
55096
55097 }
55098
55099
55100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55101   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55102   Dali::Toolkit::VideoView *arg2 = 0 ;
55103
55104   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55105   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55106   if (!arg2) {
55107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55108     return ;
55109   }
55110   {
55111     try {
55112       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55113     } CALL_CATCH_EXCEPTION();
55114   }
55115
55116 }
55117
55118
55119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55120   void * jresult ;
55121   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55122
55123   {
55124     try {
55125       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55126     } CALL_CATCH_EXCEPTION(0);
55127   }
55128
55129   jresult = (void *)result;
55130   return jresult;
55131 }
55132
55133
55134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55135   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55136
55137   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55138   {
55139     try {
55140       delete arg1;
55141     } CALL_CATCH_EXCEPTION();
55142   }
55143
55144 }
55145
55146
55147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55148   unsigned int jresult ;
55149   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55150   bool result;
55151
55152   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55153   {
55154     try {
55155       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55156     } CALL_CATCH_EXCEPTION(0);
55157   }
55158
55159   jresult = result;
55160   return jresult;
55161 }
55162
55163
55164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55165   unsigned long jresult ;
55166   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55167   std::size_t result;
55168
55169   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55170   {
55171     try {
55172       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55173     } CALL_CATCH_EXCEPTION(0);
55174   }
55175
55176   jresult = (unsigned long)result;
55177   return jresult;
55178 }
55179
55180
55181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55182   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55183   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55184
55185   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55186   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55187   {
55188     try {
55189       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55190     } CALL_CATCH_EXCEPTION();
55191   }
55192
55193 }
55194
55195
55196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55197   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55198   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55199
55200   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55201   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55202   {
55203     try {
55204       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55205     } CALL_CATCH_EXCEPTION();
55206   }
55207
55208 }
55209
55210
55211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55212   unsigned int jresult ;
55213   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55214   Dali::Toolkit::Slider arg2 ;
55215   float arg3 ;
55216   Dali::Toolkit::Slider *argp2 ;
55217   bool result;
55218
55219   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55220   argp2 = (Dali::Toolkit::Slider *)jarg2;
55221   if (!argp2) {
55222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55223     return 0;
55224   }
55225   arg2 = *argp2;
55226   arg3 = (float)jarg3;
55227   {
55228     try {
55229       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55230     } CALL_CATCH_EXCEPTION(0);
55231   }
55232
55233   jresult = result;
55234   return jresult;
55235 }
55236
55237
55238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55239   void * jresult ;
55240   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55241
55242   {
55243     try {
55244       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55245     } CALL_CATCH_EXCEPTION(0);
55246   }
55247
55248   jresult = (void *)result;
55249   return jresult;
55250 }
55251
55252
55253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55254   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55255
55256   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55257   {
55258     try {
55259       delete arg1;
55260     } CALL_CATCH_EXCEPTION();
55261   }
55262
55263 }
55264
55265
55266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55267   unsigned int jresult ;
55268   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55269   bool result;
55270
55271   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55272   {
55273     try {
55274       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55275     } CALL_CATCH_EXCEPTION(0);
55276   }
55277
55278   jresult = result;
55279   return jresult;
55280 }
55281
55282
55283 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55284   unsigned long jresult ;
55285   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55286   std::size_t result;
55287
55288   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55289   {
55290     try {
55291       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55292     } CALL_CATCH_EXCEPTION(0);
55293   }
55294
55295   jresult = (unsigned long)result;
55296   return jresult;
55297 }
55298
55299
55300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55301   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55302   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55303
55304   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55305   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55306   {
55307     try {
55308       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55309     } CALL_CATCH_EXCEPTION();
55310   }
55311
55312 }
55313
55314
55315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55316   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55317   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55318
55319   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55320   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55321   {
55322     try {
55323       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55324     } CALL_CATCH_EXCEPTION();
55325   }
55326
55327 }
55328
55329
55330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55331   unsigned int jresult ;
55332   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55333   Dali::Toolkit::Slider arg2 ;
55334   int arg3 ;
55335   Dali::Toolkit::Slider *argp2 ;
55336   bool result;
55337
55338   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55339   argp2 = (Dali::Toolkit::Slider *)jarg2;
55340   if (!argp2) {
55341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55342     return 0;
55343   }
55344   arg2 = *argp2;
55345   arg3 = (int)jarg3;
55346   {
55347     try {
55348       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55349     } CALL_CATCH_EXCEPTION(0);
55350   }
55351
55352   jresult = result;
55353   return jresult;
55354 }
55355
55356
55357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55358   void * jresult ;
55359   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55360
55361   {
55362     try {
55363       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55364     } CALL_CATCH_EXCEPTION(0);
55365   }
55366
55367   jresult = (void *)result;
55368   return jresult;
55369 }
55370
55371
55372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55373   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55374
55375   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55376   {
55377     try {
55378       delete arg1;
55379     } CALL_CATCH_EXCEPTION();
55380   }
55381
55382 }
55383
55384
55385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55386   void * jresult ;
55387   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55388
55389   {
55390     try {
55391       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55392     } CALL_CATCH_EXCEPTION(0);
55393   }
55394
55395   jresult = (void *)result;
55396   return jresult;
55397 }
55398
55399
55400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55401   void * jresult ;
55402   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55404
55405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55406   {
55407     try {
55408       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
55409     } CALL_CATCH_EXCEPTION(0);
55410   }
55411
55412   jresult = (void *)result;
55413   return jresult;
55414 }
55415
55416
55417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
55418   void * jresult ;
55419   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55420   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55421
55422   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55423   if (!arg1) {
55424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55425     return 0;
55426   }
55427   {
55428     try {
55429       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55430     } CALL_CATCH_EXCEPTION(0);
55431   }
55432
55433   jresult = (void *)result;
55434   return jresult;
55435 }
55436
55437
55438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55439   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55440
55441   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55442   {
55443     try {
55444       delete arg1;
55445     } CALL_CATCH_EXCEPTION();
55446   }
55447
55448 }
55449
55450
55451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55452   void * jresult ;
55453   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55454   Dali::Toolkit::Ruler *result = 0 ;
55455
55456   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55457   {
55458     try {
55459       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55460     } CALL_CATCH_EXCEPTION(0);
55461   }
55462
55463   jresult = (void *)result;
55464   return jresult;
55465 }
55466
55467
55468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
55469   void * jresult ;
55470   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55471   Dali::Toolkit::Ruler *result = 0 ;
55472
55473   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55474   {
55475     try {
55476       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
55477     } CALL_CATCH_EXCEPTION(0);
55478   }
55479
55480   jresult = (void *)result;
55481   return jresult;
55482 }
55483
55484
55485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
55486   void * jresult ;
55487   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55488   Dali::Toolkit::Ruler *result = 0 ;
55489
55490   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55491   {
55492     try {
55493       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
55494     } CALL_CATCH_EXCEPTION(0);
55495   }
55496
55497   jresult = (void *)result;
55498   return jresult;
55499 }
55500
55501
55502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
55503   void * jresult ;
55504   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55505   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55506   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55507
55508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55509   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55510   if (!arg2) {
55511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55512     return 0;
55513   }
55514   {
55515     try {
55516       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55517     } CALL_CATCH_EXCEPTION(0);
55518   }
55519
55520   jresult = (void *)result;
55521   return jresult;
55522 }
55523
55524
55525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55526   void * jresult ;
55527   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55528   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55529   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55530
55531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55532   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55533   {
55534     try {
55535       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55536     } CALL_CATCH_EXCEPTION(0);
55537   }
55538
55539   jresult = (void *)result;
55540   return jresult;
55541 }
55542
55543
55544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55546
55547   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55548   {
55549     try {
55550       (arg1)->Reset();
55551     } CALL_CATCH_EXCEPTION();
55552   }
55553
55554 }
55555
55556
55557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55559   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55560
55561   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55562   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55563   {
55564     try {
55565       (arg1)->Reset(arg2);
55566     } CALL_CATCH_EXCEPTION();
55567   }
55568
55569 }
55570
55571
55572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55573   void * jresult ;
55574   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55575   Dali::Toolkit::Ruler *result = 0 ;
55576
55577   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55578   {
55579     try {
55580       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55581     } CALL_CATCH_EXCEPTION(0);
55582   }
55583
55584   jresult = (void *)result;
55585   return jresult;
55586 }
55587
55588
55589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55590   float jresult ;
55591   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55592   float arg2 ;
55593   float arg3 ;
55594   float result;
55595
55596   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55597   arg2 = (float)jarg2;
55598   arg3 = (float)jarg3;
55599   {
55600     try {
55601       result = (float)(*arg1)->Snap(arg2,arg3);
55602     } CALL_CATCH_EXCEPTION(0);
55603   }
55604
55605   jresult = result;
55606   return jresult;
55607 }
55608
55609
55610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55611   float jresult ;
55612   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55613   float arg2 ;
55614   float result;
55615
55616   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55617   arg2 = (float)jarg2;
55618   {
55619     try {
55620       result = (float)(*arg1)->Snap(arg2);
55621     } CALL_CATCH_EXCEPTION(0);
55622   }
55623
55624   jresult = result;
55625   return jresult;
55626 }
55627
55628
55629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55630   float jresult ;
55631   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55632   unsigned int arg2 ;
55633   unsigned int *arg3 = 0 ;
55634   bool arg4 ;
55635   float result;
55636
55637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55638   arg2 = (unsigned int)jarg2;
55639   arg3 = (unsigned int *)jarg3;
55640   arg4 = jarg4 ? true : false;
55641   {
55642     try {
55643       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55644     } CALL_CATCH_EXCEPTION(0);
55645   }
55646
55647   jresult = result;
55648   return jresult;
55649 }
55650
55651
55652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55653   unsigned int jresult ;
55654   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55655   float arg2 ;
55656   bool arg3 ;
55657   unsigned int result;
55658
55659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55660   arg2 = (float)jarg2;
55661   arg3 = jarg3 ? true : false;
55662   {
55663     try {
55664       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55665     } CALL_CATCH_EXCEPTION(0);
55666   }
55667
55668   jresult = result;
55669   return jresult;
55670 }
55671
55672
55673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55674   unsigned int jresult ;
55675   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55676   unsigned int result;
55677
55678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55679   {
55680     try {
55681       result = (unsigned int)(*arg1)->GetTotalPages();
55682     } CALL_CATCH_EXCEPTION(0);
55683   }
55684
55685   jresult = result;
55686   return jresult;
55687 }
55688
55689
55690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55691   int jresult ;
55692   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55693   Dali::Toolkit::Ruler::RulerType result;
55694
55695   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55696   {
55697     try {
55698       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55699     } CALL_CATCH_EXCEPTION(0);
55700   }
55701
55702   jresult = (int)result;
55703   return jresult;
55704 }
55705
55706
55707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55708   unsigned int jresult ;
55709   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55710   bool result;
55711
55712   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55713   {
55714     try {
55715       result = (bool)(*arg1)->IsEnabled();
55716     } CALL_CATCH_EXCEPTION(0);
55717   }
55718
55719   jresult = result;
55720   return jresult;
55721 }
55722
55723
55724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55725   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55726
55727   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55728   {
55729     try {
55730       (*arg1)->Enable();
55731     } CALL_CATCH_EXCEPTION();
55732   }
55733
55734 }
55735
55736
55737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55738   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55739
55740   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55741   {
55742     try {
55743       (*arg1)->Disable();
55744     } CALL_CATCH_EXCEPTION();
55745   }
55746
55747 }
55748
55749
55750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55751   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55752   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55753   Dali::Toolkit::RulerDomain *argp2 ;
55754
55755   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55756   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55757   if (!argp2) {
55758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55759     return ;
55760   }
55761   arg2 = *argp2;
55762   {
55763     try {
55764       (*arg1)->SetDomain(arg2);
55765     } CALL_CATCH_EXCEPTION();
55766   }
55767
55768 }
55769
55770
55771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
55772   void * jresult ;
55773   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55774   Dali::Toolkit::RulerDomain *result = 0 ;
55775
55776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55777   {
55778     try {
55779       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
55780     } CALL_CATCH_EXCEPTION(0);
55781   }
55782
55783   jresult = (void *)result;
55784   return jresult;
55785 }
55786
55787
55788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
55789   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55790
55791   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55792   {
55793     try {
55794       (*arg1)->DisableDomain();
55795     } CALL_CATCH_EXCEPTION();
55796   }
55797
55798 }
55799
55800
55801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
55802   float jresult ;
55803   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55804   float arg2 ;
55805   float arg3 ;
55806   float arg4 ;
55807   float result;
55808
55809   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55810   arg2 = (float)jarg2;
55811   arg3 = (float)jarg3;
55812   arg4 = (float)jarg4;
55813   {
55814     try {
55815       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
55816     } CALL_CATCH_EXCEPTION(0);
55817   }
55818
55819   jresult = result;
55820   return jresult;
55821 }
55822
55823
55824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
55825   float jresult ;
55826   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55827   float arg2 ;
55828   float arg3 ;
55829   float result;
55830
55831   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55832   arg2 = (float)jarg2;
55833   arg3 = (float)jarg3;
55834   {
55835     try {
55836       result = (float)(*arg1)->Clamp(arg2,arg3);
55837     } CALL_CATCH_EXCEPTION(0);
55838   }
55839
55840   jresult = result;
55841   return jresult;
55842 }
55843
55844
55845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
55846   float jresult ;
55847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55848   float arg2 ;
55849   float result;
55850
55851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55852   arg2 = (float)jarg2;
55853   {
55854     try {
55855       result = (float)(*arg1)->Clamp(arg2);
55856     } CALL_CATCH_EXCEPTION(0);
55857   }
55858
55859   jresult = result;
55860   return jresult;
55861 }
55862
55863
55864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
55865   float jresult ;
55866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55867   float arg2 ;
55868   float arg3 ;
55869   float arg4 ;
55870   Dali::Toolkit::ClampState *arg5 = 0 ;
55871   float result;
55872
55873   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55874   arg2 = (float)jarg2;
55875   arg3 = (float)jarg3;
55876   arg4 = (float)jarg4;
55877   arg5 = (Dali::Toolkit::ClampState *)jarg5;
55878   if (!arg5) {
55879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
55880     return 0;
55881   }
55882   {
55883     try {
55884       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
55885     } CALL_CATCH_EXCEPTION(0);
55886   }
55887
55888   jresult = result;
55889   return jresult;
55890 }
55891
55892
55893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
55894   float jresult ;
55895   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55896   float arg2 ;
55897   float arg3 ;
55898   float arg4 ;
55899   float arg5 ;
55900   float result;
55901
55902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55903   arg2 = (float)jarg2;
55904   arg3 = (float)jarg3;
55905   arg4 = (float)jarg4;
55906   arg5 = (float)jarg5;
55907   {
55908     try {
55909       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
55910     } CALL_CATCH_EXCEPTION(0);
55911   }
55912
55913   jresult = result;
55914   return jresult;
55915 }
55916
55917
55918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
55919   float jresult ;
55920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55921   float arg2 ;
55922   float arg3 ;
55923   float arg4 ;
55924   float result;
55925
55926   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55927   arg2 = (float)jarg2;
55928   arg3 = (float)jarg3;
55929   arg4 = (float)jarg4;
55930   {
55931     try {
55932       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
55933     } CALL_CATCH_EXCEPTION(0);
55934   }
55935
55936   jresult = result;
55937   return jresult;
55938 }
55939
55940
55941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
55942   float jresult ;
55943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55944   float arg2 ;
55945   float arg3 ;
55946   float result;
55947
55948   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55949   arg2 = (float)jarg2;
55950   arg3 = (float)jarg3;
55951   {
55952     try {
55953       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
55954     } CALL_CATCH_EXCEPTION(0);
55955   }
55956
55957   jresult = result;
55958   return jresult;
55959 }
55960
55961
55962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
55963   float jresult ;
55964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55965   float arg2 ;
55966   float result;
55967
55968   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55969   arg2 = (float)jarg2;
55970   {
55971     try {
55972       result = (float)(*arg1)->SnapAndClamp(arg2);
55973     } CALL_CATCH_EXCEPTION(0);
55974   }
55975
55976   jresult = result;
55977   return jresult;
55978 }
55979
55980
55981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
55982   float jresult ;
55983   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55984   float arg2 ;
55985   float arg3 ;
55986   float arg4 ;
55987   float arg5 ;
55988   Dali::Toolkit::ClampState *arg6 = 0 ;
55989   float result;
55990
55991   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55992   arg2 = (float)jarg2;
55993   arg3 = (float)jarg3;
55994   arg4 = (float)jarg4;
55995   arg5 = (float)jarg5;
55996   arg6 = (Dali::Toolkit::ClampState *)jarg6;
55997   if (!arg6) {
55998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
55999     return 0;
56000   }
56001   {
56002     try {
56003       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56004     } CALL_CATCH_EXCEPTION(0);
56005   }
56006
56007   jresult = result;
56008   return jresult;
56009 }
56010
56011
56012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56014
56015   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56016   {
56017     try {
56018       (*arg1)->Reference();
56019     } CALL_CATCH_EXCEPTION();
56020   }
56021
56022 }
56023
56024
56025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56026   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56027
56028   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56029   {
56030     try {
56031       (*arg1)->Unreference();
56032     } CALL_CATCH_EXCEPTION();
56033   }
56034
56035 }
56036
56037
56038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56039   int jresult ;
56040   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56041   int result;
56042
56043   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56044   {
56045     try {
56046       result = (int)(*arg1)->ReferenceCount();
56047     } CALL_CATCH_EXCEPTION(0);
56048   }
56049
56050   jresult = result;
56051   return jresult;
56052 }
56053
56054
56055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56056   unsigned int jresult ;
56057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56058   bool result;
56059
56060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56061   {
56062     try {
56063       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56064     } CALL_CATCH_EXCEPTION(0);
56065   }
56066
56067   jresult = result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56073   unsigned long jresult ;
56074   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56075   std::size_t result;
56076
56077   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56078   {
56079     try {
56080       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56081     } CALL_CATCH_EXCEPTION(0);
56082   }
56083
56084   jresult = (unsigned long)result;
56085   return jresult;
56086 }
56087
56088
56089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56090   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56091   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56092
56093   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56094   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56095   {
56096     try {
56097       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56098     } CALL_CATCH_EXCEPTION();
56099   }
56100
56101 }
56102
56103
56104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56106   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56107
56108   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56109   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56110   {
56111     try {
56112       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56113     } CALL_CATCH_EXCEPTION();
56114   }
56115
56116 }
56117
56118
56119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56120   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56121   Dali::Toolkit::Control arg2 ;
56122   Dali::Toolkit::Control *argp2 ;
56123
56124   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56125   argp2 = (Dali::Toolkit::Control *)jarg2;
56126   if (!argp2) {
56127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56128     return ;
56129   }
56130   arg2 = *argp2;
56131   {
56132     try {
56133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56134     } CALL_CATCH_EXCEPTION();
56135   }
56136
56137 }
56138
56139
56140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56141   void * jresult ;
56142   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56143
56144   {
56145     try {
56146       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56147     } CALL_CATCH_EXCEPTION(0);
56148   }
56149
56150   jresult = (void *)result;
56151   return jresult;
56152 }
56153
56154
56155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56156   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56157
56158   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56159   {
56160     try {
56161       delete arg1;
56162     } CALL_CATCH_EXCEPTION();
56163   }
56164
56165 }
56166
56167 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56168   Dali::RefObject *result = NULL;
56169
56170   if (arg1)
56171   {
56172     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56173   }
56174   return result;
56175 }
56176
56177 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56178     return (Dali::RefObject *)jarg1;
56179 }
56180
56181 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56182     return (Dali::SignalObserver *)jarg1;
56183 }
56184
56185 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56186     return (Dali::ConnectionTrackerInterface *)jarg1;
56187 }
56188
56189 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56190     return (Dali::BaseHandle *)jarg1;
56191 }
56192
56193 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56194     return (Dali::BaseHandle *)jarg1;
56195 }
56196
56197 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56198     return (Dali::BaseHandle *)jarg1;
56199 }
56200
56201 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56202     return (Dali::BaseHandle *)jarg1;
56203 }
56204
56205 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56206     return (Dali::BaseHandle *)jarg1;
56207 }
56208
56209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56210     return (Dali::BaseHandle *)jarg1;
56211 }
56212
56213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56214     return (Dali::BaseHandle *)jarg1;
56215 }
56216
56217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56218     return (Dali::BaseHandle *)jarg1;
56219 }
56220
56221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56222     return (Dali::BaseHandle *)jarg1;
56223 }
56224
56225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56226     return (Dali::BaseHandle *)jarg1;
56227 }
56228
56229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56230     return (Dali::BaseHandle *)jarg1;
56231 }
56232
56233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56234     return (Dali::BaseHandle *)jarg1;
56235 }
56236
56237 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56238     return (Dali::Handle *)jarg1;
56239 }
56240
56241 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56242     return (Dali::Handle *)jarg1;
56243 }
56244
56245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56246     return (Dali::BaseHandle *)jarg1;
56247 }
56248
56249 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56250     return (Dali::BaseHandle *)jarg1;
56251 }
56252
56253 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56254     return (Dali::Handle *)jarg1;
56255 }
56256
56257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56258     return (Dali::BaseHandle *)jarg1;
56259 }
56260
56261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56262     return (Dali::BaseHandle *)jarg1;
56263 }
56264
56265 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56266     return (Dali::BaseHandle *)jarg1;
56267 }
56268
56269 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56270     return (Dali::BaseHandle *)jarg1;
56271 }
56272
56273 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56274     return (Dali::Handle *)jarg1;
56275 }
56276
56277 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56278     return (Dali::GestureDetector *)jarg1;
56279 }
56280
56281 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56282     return (Dali::Gesture *)jarg1;
56283 }
56284
56285 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56286     return (Dali::Handle *)jarg1;
56287 }
56288
56289 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56290     return (Dali::Actor *)jarg1;
56291 }
56292
56293 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56294     return (Dali::RefObject *)jarg1;
56295 }
56296
56297 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56298     return (Dali::Actor *)jarg1;
56299 }
56300
56301 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56302     return (Dali::GestureDetector *)jarg1;
56303 }
56304
56305 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56306     return (Dali::Gesture *)jarg1;
56307 }
56308
56309 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56310     return (Dali::GestureDetector *)jarg1;
56311 }
56312
56313 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56314     return (Dali::Gesture *)jarg1;
56315 }
56316
56317 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56318     return (Dali::GestureDetector *)jarg1;
56319 }
56320
56321 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56322     return (Dali::Gesture *)jarg1;
56323 }
56324
56325 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56326     return (Dali::BaseHandle *)jarg1;
56327 }
56328
56329 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56330     return (Dali::Handle *)jarg1;
56331 }
56332
56333 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56334     return (Dali::Handle *)jarg1;
56335 }
56336
56337 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56338     return (Dali::Handle *)jarg1;
56339 }
56340
56341 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56342     return (Dali::RefObject *)jarg1;
56343 }
56344
56345 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56346     return (Dali::Actor *)jarg1;
56347 }
56348
56349 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56350     return (Dali::BaseHandle *)jarg1;
56351 }
56352
56353 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56354     return (Dali::BaseHandle *)jarg1;
56355 }
56356
56357 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56358     return (Dali::BaseHandle *)jarg1;
56359 }
56360
56361 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56362     return (Dali::CustomActorImpl *)jarg1;
56363 }
56364
56365 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56366     return (Dali::CustomActor *)jarg1;
56367 }
56368
56369 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56370     return (Dali::BaseHandle *)jarg1;
56371 }
56372
56373 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56374     return (Dali::Toolkit::Control *)jarg1;
56375 }
56376
56377 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56378     return (Dali::Toolkit::Control *)jarg1;
56379 }
56380
56381 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56382     return (Dali::Toolkit::Button *)jarg1;
56383 }
56384
56385 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56386     return (Dali::Toolkit::Button *)jarg1;
56387 }
56388
56389 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56390     return (Dali::Toolkit::Button *)jarg1;
56391 }
56392
56393 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56394     return (Dali::Toolkit::Control *)jarg1;
56395 }
56396
56397 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56398     return (Dali::Toolkit::Control *)jarg1;
56399 }
56400
56401 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56402     return (Dali::Toolkit::Control *)jarg1;
56403 }
56404
56405 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56406     return (Dali::Toolkit::Control *)jarg1;
56407 }
56408
56409 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56410     return (Dali::Toolkit::Control *)jarg1;
56411 }
56412
56413 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56414     return (Dali::RefObject *)jarg1;
56415 }
56416
56417 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56418     return (Dali::Toolkit::Scrollable *)jarg1;
56419 }
56420
56421 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56422     return (Dali::BaseHandle *)jarg1;
56423 }
56424
56425 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56426     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56427 }
56428
56429 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56430     return (Dali::RefObject *)jarg1;
56431 }
56432
56433 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56434     return (Dali::Toolkit::Ruler *)jarg1;
56435 }
56436
56437 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56438     return (Dali::Toolkit::Ruler *)jarg1;
56439 }
56440
56441 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56442     return (Dali::Toolkit::Scrollable *)jarg1;
56443 }
56444
56445 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56446     return (Dali::Toolkit::Control *)jarg1;
56447 }
56448
56449
56450 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56451     return (Dali::Toolkit::Control *)jarg1;
56452 }
56453
56454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56455     return (Dali::BaseHandle *)jarg1;
56456 }
56457
56458 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56459     return (Dali::BaseHandle *)jarg1;
56460 }
56461
56462 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56463     return (Dali::Toolkit::Control *)jarg1;
56464 }
56465
56466 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56467     return (Dali::Toolkit::Control *)jarg1;
56468 }
56469
56470 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56471     return (Dali::Toolkit::Control *)jarg1;
56472 }
56473
56474 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56475     return (Dali::Toolkit::Control *)jarg1;
56476 }
56477
56478 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56479     return (Dali::Toolkit::Control *)jarg1;
56480 }
56481
56482 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56483     return (Dali::Toolkit::Control *)jarg1;
56484 }
56485
56486 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56487     return (Dali::Toolkit::PageTurnView *)jarg1;
56488 }
56489
56490 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56491     return (Dali::Toolkit::PageTurnView *)jarg1;
56492 }
56493
56494 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56495     return (Dali::Toolkit::Button *)jarg1;
56496 }
56497
56498 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56499     return (Dali::BaseHandle *)jarg1;
56500 }
56501
56502 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56503     return (Dali::BaseHandle *)jarg1;
56504 }
56505
56506 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56507     return (Dali::BaseHandle *)jarg1;
56508 }
56509
56510 /*
56511  * Widget binding
56512  */
56513 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56514     return (Dali::BaseHandle *)jarg1;
56515 }
56516
56517 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56518     return (Dali::BaseObject *)jarg1;
56519 }
56520
56521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56522   void * jresult ;
56523   Dali::Widget result;
56524
56525   {
56526     try {
56527       result = Dali::Widget::New();
56528     } CALL_CATCH_EXCEPTION(0);
56529   }
56530
56531   jresult = new Dali::Widget((const Dali::Widget &)result);
56532   return jresult;
56533 }
56534
56535
56536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56537   void * jresult ;
56538   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56539   Dali::Widget result;
56540
56541   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56542
56543   if (!arg1) {
56544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56545     return 0;
56546   }
56547   {
56548     try {
56549       jresult = new Dali::Widget(arg1);
56550     } CALL_CATCH_EXCEPTION(0);
56551   }
56552   return jresult;
56553 }
56554
56555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56556   void * jresult ;
56557   Dali::Widget *result = 0 ;
56558
56559   {
56560     try {
56561       result = (Dali::Widget *)new Dali::Widget();
56562     } CALL_CATCH_EXCEPTION(0);
56563   }
56564   jresult = (void *)result;
56565   return jresult;
56566 }
56567
56568
56569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56570   void * jresult ;
56571   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56572   Dali::Widget *arg2 = 0 ;
56573   Dali::Widget *result = 0 ;
56574
56575   arg1 = (Dali::Widget *)jarg1;
56576   arg2 = (Dali::Widget *)jarg2;
56577   if (!arg2) {
56578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56579     return 0;
56580   }
56581   {
56582     try {
56583       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56584     } CALL_CATCH_EXCEPTION(0);
56585   }
56586   jresult = (void *)result;
56587   return jresult;
56588 }
56589
56590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56591   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56592
56593   arg1 = (Dali::Widget *)jarg1;
56594   {
56595     try {
56596       delete arg1;
56597     } CALL_CATCH_EXCEPTION();
56598   }
56599 }
56600
56601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56602   void * jresult ;
56603   SwigDirector_WidgetImpl* result;
56604   {
56605     try {
56606       result = new SwigDirector_WidgetImpl();
56607     } CALL_CATCH_EXCEPTION(0);
56608   }
56609   jresult = result;
56610   return jresult;
56611 }
56612
56613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56614   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56615   std::string *arg2 = 0 ;
56616   Dali::Window arg3 ;
56617   Dali::Window *argp3 ;
56618
56619   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56620   if (!jarg2) {
56621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56622     return ;
56623   }
56624   std::string arg2_str(jarg2);
56625   arg2 = &arg2_str;
56626   argp3 = (Dali::Window *)jarg3;
56627   if (!argp3) {
56628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56629     return ;
56630   }
56631   arg3 = *argp3;
56632   {
56633     try {
56634       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56635     } CALL_CATCH_EXCEPTION();
56636   }
56637 }
56638
56639
56640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56641   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56642   std::string *arg2 = 0 ;
56643   Dali::Window arg3 ;
56644   Dali::Window *argp3 ;
56645
56646   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56647   if (!jarg2) {
56648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56649     return ;
56650   }
56651   std::string arg2_str(jarg2);
56652   arg2 = &arg2_str;
56653   argp3 = (Dali::Window *)jarg3;
56654   if (!argp3) {
56655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56656     return ;
56657   }
56658   arg3 = *argp3;
56659   {
56660     try {
56661       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56662     } CALL_CATCH_EXCEPTION();
56663   }
56664 }
56665
56666
56667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56668   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56669   std::string *arg2 = 0 ;
56670   Dali::Widget::Termination arg3 ;
56671
56672   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56673   if (!jarg2) {
56674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56675     return ;
56676   }
56677   std::string arg2_str(jarg2);
56678   arg2 = &arg2_str;
56679   arg3 = (Dali::Widget::Termination)jarg3;
56680   {
56681     try {
56682       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56683     } CALL_CATCH_EXCEPTION();
56684   }
56685 }
56686
56687
56688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56689   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56690   std::string *arg2 = 0 ;
56691   Dali::Widget::Termination arg3 ;
56692
56693   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56694   if (!jarg2) {
56695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56696     return ;
56697   }
56698   std::string arg2_str(jarg2);
56699   arg2 = &arg2_str;
56700   arg3 = (Dali::Widget::Termination)jarg3;
56701   {
56702     try {
56703       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56704     } CALL_CATCH_EXCEPTION();
56705   }
56706 }
56707
56708
56709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56710   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56711
56712   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56713   {
56714     try {
56715       (arg1)->OnPause();
56716     } CALL_CATCH_EXCEPTION();
56717   }
56718 }
56719
56720
56721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56722   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56723
56724   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56725   {
56726     try {
56727       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56728     } CALL_CATCH_EXCEPTION();
56729   }
56730 }
56731
56732
56733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56734   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56735
56736   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56737   {
56738     try {
56739       (arg1)->OnResume();
56740     } CALL_CATCH_EXCEPTION();
56741   }
56742 }
56743
56744
56745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
56746   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56747
56748   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56749   {
56750     try {
56751       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
56752     } CALL_CATCH_EXCEPTION();
56753   }
56754 }
56755
56756
56757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56758   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56759   Dali::Window arg2 ;
56760   Dali::Window *argp2 ;
56761
56762   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56763   argp2 = (Dali::Window *)jarg2;
56764   if (!argp2) {
56765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56766     return ;
56767   }
56768   arg2 = *argp2;
56769   {
56770     try {
56771       (arg1)->OnResize(arg2);
56772     } CALL_CATCH_EXCEPTION();
56773   }
56774 }
56775
56776
56777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
56778   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56779   Dali::Window arg2 ;
56780   Dali::Window *argp2 ;
56781
56782   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56783   argp2 = (Dali::Window *)jarg2;
56784   if (!argp2) {
56785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56786     return ;
56787   }
56788   arg2 = *argp2;
56789   {
56790     try {
56791       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
56792     } CALL_CATCH_EXCEPTION();
56793   }
56794 }
56795
56796
56797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
56798   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56799   std::string *arg2 = 0 ;
56800   int arg3 ;
56801
56802   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56803   if (!jarg2) {
56804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56805     return ;
56806   }
56807   std::string arg2_str(jarg2);
56808   arg2 = &arg2_str;
56809   arg3 = (int)jarg3;
56810   {
56811     try {
56812       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
56813     } CALL_CATCH_EXCEPTION();
56814   }
56815 }
56816
56817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56818   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56819   std::string *arg2 = 0 ;
56820   int arg3 ;
56821
56822   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56823   if (!jarg2) {
56824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56825     return ;
56826   }
56827   std::string arg2_str(jarg2);
56828   arg2 = &arg2_str;
56829   arg3 = (int)jarg3;
56830   {
56831     try {
56832       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
56833     } CALL_CATCH_EXCEPTION();
56834   }
56835 }
56836
56837
56838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
56839   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56840   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56841   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56842
56843   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56844   arg2 = (Dali::SlotObserver *)jarg2;
56845   arg3 = (Dali::CallbackBase *)jarg3;
56846   {
56847     try {
56848       (arg1)->SignalConnected(arg2,arg3);
56849     } CALL_CATCH_EXCEPTION();
56850   }
56851 }
56852
56853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
56854   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56855   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56856   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56857
56858   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56859   arg2 = (Dali::SlotObserver *)jarg2;
56860   arg3 = (Dali::CallbackBase *)jarg3;
56861   {
56862     try {
56863       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
56864     } CALL_CATCH_EXCEPTION();
56865   }
56866 }
56867
56868
56869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
56870   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56871   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56872   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56873
56874   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56875   arg2 = (Dali::SlotObserver *)jarg2;
56876   arg3 = (Dali::CallbackBase *)jarg3;
56877   {
56878     try {
56879       (arg1)->SignalDisconnected(arg2,arg3);
56880     } CALL_CATCH_EXCEPTION();
56881   }
56882 }
56883
56884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
56885   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56886   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56887   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56888
56889   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56890   arg2 = (Dali::SlotObserver *)jarg2;
56891   arg3 = (Dali::CallbackBase *)jarg3;
56892   {
56893     try {
56894       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
56895     } CALL_CATCH_EXCEPTION();
56896   }
56897 }
56898
56899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
56900   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56901   std::string *arg2 = 0 ;
56902
56903   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56904   if (!jarg2) {
56905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56906     return ;
56907   }
56908   std::string arg2_str(jarg2);
56909   arg2 = &arg2_str;
56910   {
56911     try {
56912       (arg1)->SetContentInfo((std::string const &)*arg2);
56913     } CALL_CATCH_EXCEPTION();
56914   }
56915 }
56916
56917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
56918   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56919   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
56920
56921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56922   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
56923   {
56924     try {
56925       (arg1)->SetImpl(arg2);
56926     } CALL_CATCH_EXCEPTION();
56927   }
56928 }
56929
56930
56931 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) {
56932   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
56933   if (director) {
56934     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
56935   }
56936 }
56937
56938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
56939   void * jresult ;
56940   Dali::Widget *arg1 = 0 ;
56941   SwigDirector_WidgetImpl *result = 0 ;
56942
56943   arg1 = (Dali::Widget *)jarg1;
56944   if (!arg1) {
56945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
56946     return 0;
56947   }
56948   {
56949     try {
56950       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
56951     } CALL_CATCH_EXCEPTION(0);
56952   }
56953   jresult = (void*) result;
56954   return jresult;
56955 }
56956
56957
56958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
56959   void * jresult ;
56960   int *arg1 = (int *) 0 ;
56961   char ***arg2 ;
56962   std::string *arg3 = 0 ;
56963   Dali::WidgetApplication result;
56964   {
56965     int index = 0;
56966     int length = 0;
56967     char *retPtr;
56968     char *nextPtr;
56969     argWidgetC = jarg1;
56970     argWidgetV = new char*[jarg1 + 1];
56971
56972     retPtr = strtok_r( jarg2, " ", &nextPtr);
56973     if( retPtr )
56974     {
56975       length = strlen(retPtr);
56976     }
56977     argWidgetV[index] = new char[length + 1];
56978     if( retPtr )
56979     {
56980       strncpy(argWidgetV[index], retPtr, length);
56981     }
56982     argWidgetV[index][length] = '\0';
56983     index++;
56984
56985     while (index < jarg1)
56986     {
56987       length = 0;
56988       retPtr = strtok_r(NULL, " ", &nextPtr);
56989       if( retPtr )
56990       {
56991         length = strlen(retPtr);
56992       }
56993       argWidgetV[index] = new char[length + 1];
56994       if( retPtr )
56995       {
56996         strncpy(argWidgetV[index], retPtr, length);
56997       }
56998       argWidgetV[index][length] = '\0';
56999       index++;
57000     }
57001
57002     argWidgetV[jarg1] = NULL;
57003     argWidgetC = jarg1;
57004
57005     arg1 = &argWidgetC;
57006     arg2 = &argWidgetV;
57007   }
57008
57009   if (!jarg3) {
57010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57011     return 0;
57012   }
57013   std::string arg3_str(jarg3);
57014   arg3 = &arg3_str;
57015   {
57016     try {
57017       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
57018     } CALL_CATCH_EXCEPTION(0);
57019   }
57020   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
57026   void * jresult ;
57027   Dali::WidgetApplication *result = 0 ;
57028
57029   {
57030     try {
57031       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
57032     } CALL_CATCH_EXCEPTION(0);
57033   }
57034   jresult = (void *)result;
57035   return jresult;
57036 }
57037
57038
57039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57040   void * jresult ;
57041   Dali::WidgetApplication *arg1 = 0 ;
57042   Dali::WidgetApplication *result = 0 ;
57043
57044   arg1 = (Dali::WidgetApplication *)jarg1;
57045   if (!arg1) {
57046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57047     return 0;
57048   }
57049   {
57050     try {
57051       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57052     } CALL_CATCH_EXCEPTION(0);
57053   }
57054   jresult = (void *)result;
57055   return jresult;
57056 }
57057
57058
57059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57060   void * jresult ;
57061   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57062   Dali::WidgetApplication *arg2 = 0 ;
57063   Dali::WidgetApplication *result = 0 ;
57064
57065   arg1 = (Dali::WidgetApplication *)jarg1;
57066   arg2 = (Dali::WidgetApplication *)jarg2;
57067   if (!arg2) {
57068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57069     return 0;
57070   }
57071   {
57072     try {
57073       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57074     } CALL_CATCH_EXCEPTION(0);
57075   }
57076   jresult = (void *)result;
57077   return jresult;
57078 }
57079
57080
57081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57082   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57083
57084   arg1 = (Dali::WidgetApplication *)jarg1;
57085   {
57086     try {
57087       delete arg1;
57088       if( argWidgetV )
57089       {
57090         // free string data
57091         for( int i=0; i < argWidgetC+1; i++)
57092         {
57093           delete [] argWidgetV[i];
57094         }
57095         delete [] argWidgetV;
57096       }
57097     } CALL_CATCH_EXCEPTION();
57098   }
57099 }
57100
57101
57102 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57103 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57104
57105 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57106 {
57107   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57108   return *widget;
57109 }
57110
57111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57112   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57113   std::string *arg2 = 0 ;
57114
57115   arg1 = (Dali::WidgetApplication *)jarg1;
57116   if (!jarg2) {
57117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57118     return ;
57119   }
57120   std::string arg2_str(*jarg2);
57121   arg2 = &arg2_str;
57122
57123   if(!_CSharpCreateWidgetFunction)
57124   {
57125     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57126   }
57127
57128   {
57129     try {
57130       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57131     } CALL_CATCH_EXCEPTION();
57132   }
57133   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57134 }
57135
57136
57137 //for PixelBuffer and ImageLoading
57138
57139 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57140     return (Dali::BaseHandle *)jarg1;
57141 }
57142
57143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57144   void * jresult ;
57145   unsigned int arg1 ;
57146   unsigned int arg2 ;
57147   Dali::Pixel::Format arg3 ;
57148   Dali::Devel::PixelBuffer result;
57149
57150   arg1 = (unsigned int)jarg1;
57151   arg2 = (unsigned int)jarg2;
57152   arg3 = (Dali::Pixel::Format)jarg3;
57153   {
57154     try {
57155       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57156     } CALL_CATCH_EXCEPTION(0);
57157   }
57158   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57159   return jresult;
57160 }
57161
57162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57163   void * jresult ;
57164   Dali::Devel::PixelBuffer *result = 0 ;
57165
57166   {
57167     try {
57168       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57169     } CALL_CATCH_EXCEPTION(0);
57170   }
57171   jresult = (void *)result;
57172   return jresult;
57173 }
57174
57175
57176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57177   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57178
57179   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57180   {
57181     try {
57182       delete arg1;
57183     } CALL_CATCH_EXCEPTION();
57184   }
57185 }
57186
57187
57188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57189   void * jresult ;
57190   Dali::Devel::PixelBuffer *arg1 = 0 ;
57191   Dali::Devel::PixelBuffer *result = 0 ;
57192
57193   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57194   if (!arg1) {
57195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57196     return 0;
57197   }
57198   {
57199     try {
57200       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57201     } CALL_CATCH_EXCEPTION(0);
57202   }
57203   jresult = (void *)result;
57204   return jresult;
57205 }
57206
57207
57208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57209   void * jresult ;
57210   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57211   Dali::Devel::PixelBuffer *arg2 = 0 ;
57212   Dali::Devel::PixelBuffer *result = 0 ;
57213
57214   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57215   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57216   if (!arg2) {
57217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57218     return 0;
57219   }
57220   {
57221     try {
57222       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57223     } CALL_CATCH_EXCEPTION(0);
57224   }
57225   jresult = (void *)result;
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57231   void * jresult ;
57232   Dali::Devel::PixelBuffer *arg1 = 0 ;
57233   Dali::PixelData result;
57234
57235   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57236   if (!arg1) {
57237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57238     return 0;
57239   }
57240   {
57241     try {
57242       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57243     } CALL_CATCH_EXCEPTION(0);
57244   }
57245   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57246   return jresult;
57247 }
57248
57249
57250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57251   void * jresult ;
57252   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57253   Dali::PixelData result;
57254
57255   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57256   {
57257     try {
57258       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57259     } CALL_CATCH_EXCEPTION(0);
57260   }
57261   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57262   return jresult;
57263 }
57264
57265
57266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57267   void * jresult ;
57268   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57269   unsigned char *result = 0 ;
57270
57271   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57272   {
57273     try {
57274       result = (unsigned char *)(arg1)->GetBuffer();
57275     } CALL_CATCH_EXCEPTION(0);
57276   }
57277    jresult = (void *)result;
57278    return jresult;
57279 }
57280
57281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57282   unsigned int jresult ;
57283   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57284   unsigned int result;
57285
57286   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57287   {
57288     try {
57289       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57290     } CALL_CATCH_EXCEPTION(0);
57291   }
57292   jresult = result;
57293   return jresult;
57294 }
57295
57296
57297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57298   unsigned int jresult ;
57299   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57300   unsigned int result;
57301
57302   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57303   {
57304     try {
57305       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57306     } CALL_CATCH_EXCEPTION(0);
57307   }
57308   jresult = result;
57309   return jresult;
57310 }
57311
57312
57313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57314   int jresult ;
57315   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57316   Dali::Pixel::Format result;
57317
57318   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57319   {
57320     try {
57321       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57322     } CALL_CATCH_EXCEPTION(0);
57323   }
57324   jresult = (int)result;
57325   return jresult;
57326 }
57327
57328
57329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57330   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57331   Dali::Devel::PixelBuffer arg2 ;
57332   float arg3 ;
57333   bool arg4 ;
57334   Dali::Devel::PixelBuffer *argp2 ;
57335
57336   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57337   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57338   if (!argp2) {
57339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57340     return ;
57341   }
57342   arg2 = *argp2;
57343   arg3 = (float)jarg3;
57344   arg4 = jarg4 ? true : false;
57345   {
57346     try {
57347       (arg1)->ApplyMask(arg2,arg3,arg4);
57348     } CALL_CATCH_EXCEPTION();
57349   }
57350 }
57351
57352
57353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57354   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57355   Dali::Devel::PixelBuffer arg2 ;
57356   float arg3 ;
57357   Dali::Devel::PixelBuffer *argp2 ;
57358
57359   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57360   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57361   if (!argp2) {
57362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57363     return ;
57364   }
57365   arg2 = *argp2;
57366   arg3 = (float)jarg3;
57367   {
57368     try {
57369       (arg1)->ApplyMask(arg2,arg3);
57370     } CALL_CATCH_EXCEPTION();
57371   }
57372 }
57373
57374
57375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57376   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57377   Dali::Devel::PixelBuffer arg2 ;
57378   Dali::Devel::PixelBuffer *argp2 ;
57379
57380   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57381   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57382   if (!argp2) {
57383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57384     return ;
57385   }
57386   arg2 = *argp2;
57387   {
57388     try {
57389       (arg1)->ApplyMask(arg2);
57390     } CALL_CATCH_EXCEPTION();
57391   }
57392 }
57393
57394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57395   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57396   float arg2 ;
57397
57398   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57399   arg2 = (float)jarg2;
57400   {
57401     try {
57402       (arg1)->ApplyGaussianBlur(arg2);
57403     } CALL_CATCH_EXCEPTION();
57404   }
57405 }
57406
57407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57408   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57409   uint16_t arg2 ;
57410   uint16_t arg3 ;
57411   uint16_t arg4 ;
57412   uint16_t arg5 ;
57413
57414   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57415   arg2 = (uint16_t)jarg2;
57416   arg3 = (uint16_t)jarg3;
57417   arg4 = (uint16_t)jarg4;
57418   arg5 = (uint16_t)jarg5;
57419   {
57420     try {
57421       (arg1)->Crop(arg2,arg3,arg4,arg5);
57422     } CALL_CATCH_EXCEPTION();
57423   }
57424 }
57425
57426
57427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57428   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57429   uint16_t arg2 ;
57430   uint16_t arg3 ;
57431
57432   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57433   arg2 = (uint16_t)jarg2;
57434   arg3 = (uint16_t)jarg3;
57435   {
57436     try {
57437       (arg1)->Resize(arg2,arg3);
57438     } CALL_CATCH_EXCEPTION();
57439   }
57440 }
57441
57442 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57443   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57444   Dali::Degree * arg2 ;
57445
57446   bool result = false;
57447
57448   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57449   arg2 = (Dali::Degree *)jarg2;
57450   {
57451     try {
57452       result = (arg1)->Rotate(*arg2);
57453     } CALL_CATCH_EXCEPTION(false);
57454   }
57455   return result;
57456 }
57457
57458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57459   void * jresult ;
57460   std::string *arg1 = 0 ;
57461   Dali::ImageDimensions arg2 ;
57462   Dali::FittingMode::Type arg3 ;
57463   Dali::SamplingMode::Type arg4 ;
57464   bool arg5 ;
57465   Dali::ImageDimensions *argp2 ;
57466   Dali::Devel::PixelBuffer result;
57467
57468   if (!jarg1) {
57469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57470     return 0;
57471   }
57472   std::string arg1_str(jarg1);
57473   arg1 = &arg1_str;
57474   argp2 = (Dali::ImageDimensions *)jarg2;
57475   if (!argp2) {
57476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57477     return 0;
57478   }
57479   arg2 = *argp2;
57480   arg3 = (Dali::FittingMode::Type)jarg3;
57481   arg4 = (Dali::SamplingMode::Type)jarg4;
57482   arg5 = jarg5 ? true : false;
57483   {
57484     try {
57485       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57486     } CALL_CATCH_EXCEPTION(0);
57487   }
57488   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57489   return jresult;
57490 }
57491
57492
57493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57494   void * jresult ;
57495   std::string *arg1 = 0 ;
57496   Dali::ImageDimensions arg2 ;
57497   Dali::FittingMode::Type arg3 ;
57498   Dali::SamplingMode::Type arg4 ;
57499   Dali::ImageDimensions *argp2 ;
57500   Dali::Devel::PixelBuffer result;
57501
57502   if (!jarg1) {
57503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57504     return 0;
57505   }
57506   std::string arg1_str(jarg1);
57507   arg1 = &arg1_str;
57508   argp2 = (Dali::ImageDimensions *)jarg2;
57509   if (!argp2) {
57510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57511     return 0;
57512   }
57513   arg2 = *argp2;
57514   arg3 = (Dali::FittingMode::Type)jarg3;
57515   arg4 = (Dali::SamplingMode::Type)jarg4;
57516   {
57517     try {
57518       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57519     } CALL_CATCH_EXCEPTION(0);
57520   }
57521   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57522   return jresult;
57523 }
57524
57525
57526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57527   void * jresult ;
57528   std::string *arg1 = 0 ;
57529   Dali::ImageDimensions arg2 ;
57530   Dali::FittingMode::Type arg3 ;
57531   Dali::ImageDimensions *argp2 ;
57532   Dali::Devel::PixelBuffer result;
57533
57534   if (!jarg1) {
57535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57536     return 0;
57537   }
57538   std::string arg1_str(jarg1);
57539   arg1 = &arg1_str;
57540   argp2 = (Dali::ImageDimensions *)jarg2;
57541   if (!argp2) {
57542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57543     return 0;
57544   }
57545   arg2 = *argp2;
57546   arg3 = (Dali::FittingMode::Type)jarg3;
57547   {
57548     try {
57549       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57550     } CALL_CATCH_EXCEPTION(0);
57551   }
57552   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57553   return jresult;
57554 }
57555
57556
57557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57558   void * jresult ;
57559   std::string *arg1 = 0 ;
57560   Dali::ImageDimensions arg2 ;
57561   Dali::ImageDimensions *argp2 ;
57562   Dali::Devel::PixelBuffer result;
57563
57564   if (!jarg1) {
57565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57566     return 0;
57567   }
57568   std::string arg1_str(jarg1);
57569   arg1 = &arg1_str;
57570   argp2 = (Dali::ImageDimensions *)jarg2;
57571   if (!argp2) {
57572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57573     return 0;
57574   }
57575   arg2 = *argp2;
57576   {
57577     try {
57578       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57579     } CALL_CATCH_EXCEPTION(0);
57580   }
57581   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57582   return jresult;
57583 }
57584
57585
57586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57587   void * jresult ;
57588   std::string *arg1 = 0 ;
57589   Dali::Devel::PixelBuffer result;
57590
57591   if (!jarg1) {
57592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57593     return 0;
57594   }
57595   std::string arg1_str(jarg1);
57596   arg1 = &arg1_str;
57597   {
57598     try {
57599       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57600     } CALL_CATCH_EXCEPTION(0);
57601   }
57602   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57603   return jresult;
57604 }
57605
57606
57607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57608   void * jresult ;
57609   std::string *arg1 = 0 ;
57610   Dali::ImageDimensions arg2 ;
57611   Dali::FittingMode::Type arg3 ;
57612   Dali::SamplingMode::Type arg4 ;
57613   bool arg5 ;
57614   Dali::ImageDimensions *argp2 ;
57615   Dali::ImageDimensions result;
57616
57617   if (!jarg1) {
57618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57619     return 0;
57620   }
57621   std::string arg1_str(jarg1);
57622   arg1 = &arg1_str;
57623   argp2 = (Dali::ImageDimensions *)jarg2;
57624   if (!argp2) {
57625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57626     return 0;
57627   }
57628   arg2 = *argp2;
57629   arg3 = (Dali::FittingMode::Type)jarg3;
57630   arg4 = (Dali::SamplingMode::Type)jarg4;
57631   arg5 = jarg5 ? true : false;
57632   {
57633     try {
57634       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57635     } CALL_CATCH_EXCEPTION(0);
57636   }
57637   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57638   return jresult;
57639 }
57640
57641
57642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57643   void * jresult ;
57644   std::string *arg1 = 0 ;
57645   Dali::ImageDimensions arg2 ;
57646   Dali::FittingMode::Type arg3 ;
57647   Dali::SamplingMode::Type arg4 ;
57648   Dali::ImageDimensions *argp2 ;
57649   Dali::ImageDimensions result;
57650
57651   if (!jarg1) {
57652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57653     return 0;
57654   }
57655   std::string arg1_str(jarg1);
57656   arg1 = &arg1_str;
57657   argp2 = (Dali::ImageDimensions *)jarg2;
57658   if (!argp2) {
57659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57660     return 0;
57661   }
57662   arg2 = *argp2;
57663   arg3 = (Dali::FittingMode::Type)jarg3;
57664   arg4 = (Dali::SamplingMode::Type)jarg4;
57665   {
57666     try {
57667       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57668     } CALL_CATCH_EXCEPTION(0);
57669   }
57670   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57671   return jresult;
57672 }
57673
57674
57675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57676   void * jresult ;
57677   std::string *arg1 = 0 ;
57678   Dali::ImageDimensions arg2 ;
57679   Dali::FittingMode::Type arg3 ;
57680   Dali::ImageDimensions *argp2 ;
57681   Dali::ImageDimensions result;
57682
57683   if (!jarg1) {
57684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57685     return 0;
57686   }
57687   std::string arg1_str(jarg1);
57688   arg1 = &arg1_str;
57689   argp2 = (Dali::ImageDimensions *)jarg2;
57690   if (!argp2) {
57691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57692     return 0;
57693   }
57694   arg2 = *argp2;
57695   arg3 = (Dali::FittingMode::Type)jarg3;
57696   {
57697     try {
57698       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57699     } CALL_CATCH_EXCEPTION(0);
57700   }
57701   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57702   return jresult;
57703 }
57704
57705
57706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57707   void * jresult ;
57708   std::string *arg1 = 0 ;
57709   Dali::ImageDimensions arg2 ;
57710   Dali::ImageDimensions *argp2 ;
57711   Dali::ImageDimensions result;
57712
57713   if (!jarg1) {
57714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57715     return 0;
57716   }
57717   std::string arg1_str(jarg1);
57718   arg1 = &arg1_str;
57719   argp2 = (Dali::ImageDimensions *)jarg2;
57720   if (!argp2) {
57721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57722     return 0;
57723   }
57724   arg2 = *argp2;
57725   {
57726     try {
57727       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57728     } CALL_CATCH_EXCEPTION(0);
57729   }
57730   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57731   return jresult;
57732 }
57733
57734
57735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57736   void * jresult ;
57737   std::string *arg1 = 0 ;
57738   Dali::ImageDimensions result;
57739
57740   if (!jarg1) {
57741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57742     return 0;
57743   }
57744   std::string arg1_str(jarg1);
57745   arg1 = &arg1_str;
57746   {
57747     try {
57748       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57749     } CALL_CATCH_EXCEPTION(0);
57750   }
57751   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57752   return jresult;
57753 }
57754
57755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57756   void * jresult ;
57757   std::string *arg1 = 0 ;
57758   Dali::ImageDimensions result;
57759
57760   if (!jarg1) {
57761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57762     return 0;
57763   }
57764   std::string arg1_str(jarg1);
57765   arg1 = &arg1_str;
57766   {
57767     try {
57768       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
57769     } CALL_CATCH_EXCEPTION(0);
57770   }
57771   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57772   return jresult;
57773 }
57774
57775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57776   void * jresult ;
57777   std::string *arg1 = 0 ;
57778   Dali::ImageDimensions arg2 ;
57779   Dali::FittingMode::Type arg3 ;
57780   Dali::SamplingMode::Type arg4 ;
57781   bool arg5 ;
57782   Dali::ImageDimensions *argp2 ;
57783   Dali::Devel::PixelBuffer result;
57784
57785   if (!jarg1) {
57786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57787     return 0;
57788   }
57789   std::string arg1_str(jarg1);
57790   arg1 = &arg1_str;
57791   argp2 = (Dali::ImageDimensions *)jarg2;
57792   if (!argp2) {
57793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57794     return 0;
57795   }
57796   arg2 = *argp2;
57797   arg3 = (Dali::FittingMode::Type)jarg3;
57798   arg4 = (Dali::SamplingMode::Type)jarg4;
57799   arg5 = jarg5 ? true : false;
57800   {
57801     try {
57802       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57803     } CALL_CATCH_EXCEPTION(0);
57804   }
57805   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57806   return jresult;
57807 }
57808
57809
57810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57811   void * jresult ;
57812   std::string *arg1 = 0 ;
57813   Dali::ImageDimensions arg2 ;
57814   Dali::FittingMode::Type arg3 ;
57815   Dali::SamplingMode::Type arg4 ;
57816   Dali::ImageDimensions *argp2 ;
57817   Dali::Devel::PixelBuffer result;
57818
57819   if (!jarg1) {
57820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57821     return 0;
57822   }
57823   std::string arg1_str(jarg1);
57824   arg1 = &arg1_str;
57825   argp2 = (Dali::ImageDimensions *)jarg2;
57826   if (!argp2) {
57827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57828     return 0;
57829   }
57830   arg2 = *argp2;
57831   arg3 = (Dali::FittingMode::Type)jarg3;
57832   arg4 = (Dali::SamplingMode::Type)jarg4;
57833   {
57834     try {
57835       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
57836     } CALL_CATCH_EXCEPTION(0);
57837   }
57838   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57839   return jresult;
57840 }
57841
57842
57843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57844   void * jresult ;
57845   std::string *arg1 = 0 ;
57846   Dali::ImageDimensions arg2 ;
57847   Dali::FittingMode::Type arg3 ;
57848   Dali::ImageDimensions *argp2 ;
57849   Dali::Devel::PixelBuffer result;
57850
57851   if (!jarg1) {
57852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57853     return 0;
57854   }
57855   std::string arg1_str(jarg1);
57856   arg1 = &arg1_str;
57857   argp2 = (Dali::ImageDimensions *)jarg2;
57858   if (!argp2) {
57859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57860     return 0;
57861   }
57862   arg2 = *argp2;
57863   arg3 = (Dali::FittingMode::Type)jarg3;
57864   {
57865     try {
57866       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
57867     } CALL_CATCH_EXCEPTION(0);
57868   }
57869   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57870   return jresult;
57871 }
57872
57873
57874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
57875   void * jresult ;
57876   std::string *arg1 = 0 ;
57877   Dali::ImageDimensions arg2 ;
57878   Dali::ImageDimensions *argp2 ;
57879   Dali::Devel::PixelBuffer result;
57880
57881   if (!jarg1) {
57882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57883     return 0;
57884   }
57885   std::string arg1_str(jarg1);
57886   arg1 = &arg1_str;
57887   argp2 = (Dali::ImageDimensions *)jarg2;
57888   if (!argp2) {
57889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57890     return 0;
57891   }
57892   arg2 = *argp2;
57893   {
57894     try {
57895       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
57896     } CALL_CATCH_EXCEPTION(0);
57897   }
57898   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57899   return jresult;
57900 }
57901
57902
57903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
57904   void * jresult ;
57905   std::string *arg1 = 0 ;
57906   Dali::Devel::PixelBuffer result;
57907
57908   if (!jarg1) {
57909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57910     return 0;
57911   }
57912   std::string arg1_str(jarg1);
57913   arg1 = &arg1_str;
57914   {
57915     try {
57916       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
57917     } CALL_CATCH_EXCEPTION(0);
57918   }
57919   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57920   return jresult;
57921 }
57922
57923
57924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
57925   void * jresult ;
57926   Dali::Toolkit::WebView result;
57927
57928   {
57929     try {
57930       result = Dali::Toolkit::WebView::New();
57931     } CALL_CATCH_EXCEPTION(0);
57932   }
57933   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
57934   return jresult;
57935 }
57936
57937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
57938   void * jresult ;
57939   Dali::Toolkit::WebView result;
57940
57941   std::string *arg1;
57942   std::string *arg2;
57943
57944   if (!jarg1) {
57945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
57946     return 0;
57947   }
57948   if (!jarg2) {
57949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
57950     return 0;
57951   }
57952
57953   std::string jarg1_str = std::string(jarg1);
57954   std::string jarg2_str = std::string(jarg2);
57955
57956   arg1 = &jarg1_str;
57957   arg2 = &jarg2_str;
57958
57959   {
57960     try {
57961       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
57962     } CALL_CATCH_EXCEPTION(0);
57963   }
57964   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
57965   return jresult;
57966 }
57967
57968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
57969   void * jresult ;
57970   Dali::Toolkit::WebView *arg1 = 0 ;
57971   Dali::Toolkit::WebView *result = 0 ;
57972
57973   arg1 = (Dali::Toolkit::WebView *)jarg1;
57974   if (!arg1) {
57975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
57976     return 0;
57977   }
57978   {
57979     try {
57980       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
57981     } CALL_CATCH_EXCEPTION(0);
57982   }
57983   jresult = (void *)result;
57984   return jresult;
57985 }
57986
57987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
57988   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
57989   arg1 = (Dali::Toolkit::WebView *)jarg1;
57990   {
57991     try {
57992       delete arg1;
57993     } CALL_CATCH_EXCEPTION();
57994   }
57995 }
57996
57997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
57998   void * jresult ;
57999   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58000   Dali::Toolkit::WebView *arg2 = 0 ;
58001   Dali::Toolkit::WebView *result = 0 ;
58002
58003   arg1 = (Dali::Toolkit::WebView *)jarg1;
58004   arg2 = (Dali::Toolkit::WebView *)jarg2;
58005   if (!arg2) {
58006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58007     return 0;
58008   }
58009   {
58010     try {
58011       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
58012     } CALL_CATCH_EXCEPTION(0);
58013   }
58014   jresult = (void *)result;
58015   return jresult;
58016 }
58017
58018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
58019   void * jresult ;
58020   Dali::BaseHandle arg1 ;
58021   Dali::BaseHandle *argp1 ;
58022   Dali::Toolkit::WebView result;
58023
58024   argp1 = (Dali::BaseHandle *)jarg1;
58025   if (!argp1) {
58026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58027     return 0;
58028   }
58029   arg1 = *argp1;
58030   {
58031     try {
58032       result = Dali::Toolkit::WebView::DownCast(arg1);
58033     } CALL_CATCH_EXCEPTION(0);
58034   }
58035   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58036   return jresult;
58037 }
58038
58039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58040   return (int) Dali::Toolkit::WebView::Property::URL;
58041 }
58042
58043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58044   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58045 }
58046
58047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58048   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58049 }
58050
58051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58052   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58053 }
58054
58055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58056   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58057 }
58058
58059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58060   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58061 }
58062
58063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58064   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58065 }
58066
58067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58068   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58069 }
58070
58071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58072   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58073   std::string *arg2;
58074
58075   arg1 = (Dali::Toolkit::WebView *)jarg1;
58076
58077   if (!jarg2) {
58078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58079     return;
58080   }
58081
58082   std::string jarg2str = std::string(jarg2);
58083   arg2 = &jarg2str;
58084   {
58085     try {
58086       (arg1)->LoadUrl((std::string const &)*arg2);
58087     } CALL_CATCH_EXCEPTION();
58088   }
58089 }
58090
58091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58092   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58093   std::string *arg2;
58094
58095   arg1 = (Dali::Toolkit::WebView *)jarg1;
58096   if (!jarg2) {
58097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58098     return;
58099   }
58100   std::string jarg2str = std::string(jarg2);
58101   arg2 = &jarg2str;
58102   {
58103     try {
58104       (arg1)->LoadHTMLString((std::string const &)*arg2);
58105     } CALL_CATCH_EXCEPTION();
58106   }
58107 }
58108
58109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58110   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58111
58112   arg1 = (Dali::Toolkit::WebView *)jarg1;
58113   {
58114     try {
58115       (arg1)->Reload();
58116     } CALL_CATCH_EXCEPTION();
58117   }
58118 }
58119
58120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58121   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58122
58123   arg1 = (Dali::Toolkit::WebView *)jarg1;
58124   {
58125     try {
58126       (arg1)->StopLoading();
58127     } CALL_CATCH_EXCEPTION();
58128   }
58129 }
58130
58131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58132   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58133
58134   arg1 = (Dali::Toolkit::WebView *)jarg1;
58135   {
58136     try {
58137       (arg1)->Suspend();
58138     } CALL_CATCH_EXCEPTION();
58139   }
58140 }
58141
58142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58143   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58144
58145   arg1 = (Dali::Toolkit::WebView *)jarg1;
58146   {
58147     try {
58148       (arg1)->Resume();
58149     } CALL_CATCH_EXCEPTION();
58150   }
58151 }
58152
58153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58154   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58155
58156   arg1 = (Dali::Toolkit::WebView *)jarg1;
58157   {
58158     try {
58159       (arg1)->GoBack();
58160     } CALL_CATCH_EXCEPTION();
58161   }
58162 }
58163
58164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58165   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58166
58167   arg1 = (Dali::Toolkit::WebView *)jarg1;
58168   {
58169     try {
58170       (arg1)->GoForward();
58171     } CALL_CATCH_EXCEPTION();
58172   }
58173 }
58174
58175 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58176   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58177   bool ret;
58178
58179   arg1 = (Dali::Toolkit::WebView *)jarg1;
58180   {
58181     try {
58182       ret = (arg1)->CanGoBack();
58183     } CALL_CATCH_EXCEPTION(0);
58184   }
58185   return ret;
58186 }
58187
58188 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58189   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58190   bool ret;
58191
58192   arg1 = (Dali::Toolkit::WebView *)jarg1;
58193   {
58194     try {
58195       ret = (arg1)->CanGoForward();
58196     } CALL_CATCH_EXCEPTION(0);
58197   }
58198   return ret;
58199 }
58200
58201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58202   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58203   std::string *arg2;
58204
58205   arg1 = (Dali::Toolkit::WebView *)jarg1;
58206   if (!jarg2) {
58207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58208     return;
58209   }
58210   std::string jarg2_str = std::string(jarg2);
58211   arg2 = &jarg2_str;
58212
58213   {
58214     try {
58215       if (jarg3) {
58216         void (*handler)(char*) = (void (*)(char*)) jarg3;
58217         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58218           handler(SWIG_csharp_string_callback(result.c_str()));
58219         });
58220       } else {
58221         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58222       }
58223     } CALL_CATCH_EXCEPTION();
58224   }
58225 }
58226
58227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58228 {
58229   if (!jarg2) {
58230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58231     return;
58232   }
58233
58234   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58235   std::string exposedObjectName = jarg2;
58236   void (*handler)(char*) = (void (*)(char*)) jarg3;
58237
58238   {
58239     try {
58240       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58241         handler(SWIG_csharp_string_callback(message.c_str()));
58242       });
58243     } CALL_CATCH_EXCEPTION();
58244   }
58245 }
58246
58247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58248   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58249
58250   arg1 = (Dali::Toolkit::WebView *)jarg1;
58251   {
58252     try {
58253       (arg1)->ClearHistory();
58254     } CALL_CATCH_EXCEPTION();
58255   }
58256 }
58257
58258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58259   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58260
58261   arg1 = (Dali::Toolkit::WebView *)jarg1;
58262   {
58263     try {
58264       (arg1)->ClearCache();
58265     } CALL_CATCH_EXCEPTION();
58266   }
58267 }
58268
58269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58270   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58271
58272   arg1 = (Dali::Toolkit::WebView *)jarg1;
58273   {
58274     try {
58275       (arg1)->ClearCookies();
58276     } CALL_CATCH_EXCEPTION();
58277   }
58278 }
58279
58280 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58281     return (Dali::Toolkit::Control *)jarg1;
58282 }
58283
58284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58285   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58286   SignalConverter::WebViewPageLoadSignal* result = NULL;
58287   {
58288     try {
58289       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58290     } CALL_CATCH_EXCEPTION(0);
58291   }
58292   return (void*) result;
58293 }
58294
58295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58296   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58297   SignalConverter::WebViewPageLoadSignal* result = NULL;
58298   {
58299     try {
58300       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58301     } CALL_CATCH_EXCEPTION(0);
58302   }
58303   return (void*) result;
58304 }
58305
58306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58307 {
58308   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58309   {
58310     try {
58311       delete object;
58312     } CALL_CATCH_EXCEPTION();
58313   }
58314 }
58315
58316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58317 {
58318   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58319   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58320   {
58321     try {
58322       proxy->Connect(callback);
58323     } CALL_CATCH_EXCEPTION();
58324   }
58325 }
58326
58327
58328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58329   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58330   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58331   {
58332     try {
58333       proxy->Disconnect(callback);
58334     } CALL_CATCH_EXCEPTION();
58335   }
58336 }
58337
58338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58339   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58340   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58341   {
58342     try {
58343       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58344     } CALL_CATCH_EXCEPTION(0);
58345   }
58346   return (void*) result;
58347 }
58348
58349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58350 {
58351   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58352   {
58353     try {
58354       delete object;
58355     } CALL_CATCH_EXCEPTION();
58356   }
58357 }
58358
58359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58360 {
58361   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58362   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58363   {
58364     try {
58365       proxy->Connect(callback);
58366     } CALL_CATCH_EXCEPTION();
58367   }
58368 }
58369
58370
58371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58372   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58373   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58374   {
58375     try {
58376       proxy->Disconnect(callback);
58377     } CALL_CATCH_EXCEPTION();
58378   }
58379 }
58380
58381 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58382   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58383   char * jresult = SWIG_csharp_string_callback((const char *)result);
58384   return jresult;
58385 }
58386
58387 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58388   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58389   return result;
58390 }
58391
58392
58393 struct NativeImageSourcePtrHandle
58394 {
58395   NativeImageSourcePtr Ptr;
58396 };
58397
58398 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58399 {
58400   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58401   return (NativeImageInterface*)(arg1);
58402 }
58403
58404 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58405 {
58406   void* jresult;
58407   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58408   {
58409     try {
58410       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58411     }
58412     catch (std::out_of_range & e) {
58413       {
58414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58415       };
58416     }
58417     catch (std::exception & e) {
58418       {
58419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58420       };
58421     }
58422     catch (Dali::DaliException e) {
58423       {
58424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58425       };
58426     }
58427     catch (...) {
58428       {
58429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58430       };
58431     }
58432   }
58433   jresult = (void *)handle;
58434   return jresult;
58435 }
58436
58437 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58438 {
58439   void* jresult;
58440   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58441   jresult = (void*)( handle->Ptr.Get() );
58442   return jresult;
58443 }
58444
58445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58446   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58447   {
58448     try {
58449       delete arg1;
58450     }
58451     catch (std::out_of_range & e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58454       };
58455     }
58456     catch (std::exception & e) {
58457       {
58458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58459       };
58460     }
58461     catch (Dali::DaliException e) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58464       };
58465     }
58466     catch (...) {
58467       {
58468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58469       };
58470     }
58471   }
58472 }
58473
58474 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58475 {
58476   void* jresult;
58477   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58478   uint16_t* arg2 = (uint16_t*)(jarg2);
58479   uint16_t* arg3 = (uint16_t*)(jarg3);
58480   uint16_t* arg4 = (uint16_t*)(jarg4);
58481   {
58482     try {
58483       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58484     }
58485     catch (std::out_of_range & e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58488       };
58489     }
58490     catch (std::exception & e) {
58491       {
58492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58493       };
58494     }
58495     catch (Dali::DaliException e) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58498       };
58499     }
58500     catch (...) {
58501       {
58502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58503       };
58504     }
58505   }
58506   return jresult;
58507 }
58508
58509 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58510 {
58511   bool jresult;
58512   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58513
58514   {
58515     try {
58516       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58517     }
58518     catch (std::out_of_range & e) {
58519       {
58520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58521       };
58522     }
58523     catch (std::exception & e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58526       };
58527     }
58528     catch (Dali::DaliException e) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58531       };
58532     }
58533     catch (...) {
58534       {
58535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58536       };
58537     }
58538   }
58539   return jresult;
58540 }
58541
58542
58543 #ifdef __cplusplus
58544 }
58545 #endif