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   Dali::KeyEvent arg1 = *argp1;
19537   if (!jarg2) {
19538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19539     return ;
19540   }
19541   std::string arg2_str(jarg2);
19542   arg2 = &arg2_str;
19543
19544   {
19545     try {
19546       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19547     } catch (std::out_of_range& e) {
19548       {
19549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19550       };
19551     } catch (std::exception& e) {
19552       {
19553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19554       };
19555     } catch (Dali::DaliException e) {
19556       {
19557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19558       };
19559     } catch (...) {
19560       {
19561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19562       };
19563     }
19564   }
19565 }
19566
19567
19568 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19569   char * jresult ;
19570
19571   if( jarg1 == NULL )
19572   {
19573     jresult = SWIG_csharp_string_callback( "" );
19574   }
19575   else
19576   {
19577     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19578     std::string *result = 0;
19579
19580     arg1 = ( Dali::KeyEvent * )jarg1;
19581     {
19582       try {
19583         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19584         result = (std::string *) &str;
19585       } catch (std::out_of_range& e) {
19586         {
19587           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19588         };
19589       } catch (std::exception& e) {
19590         {
19591           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19592         };
19593       } catch (Dali::DaliException e) {
19594         {
19595           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19596         };
19597       } catch (...) {
19598         {
19599           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19600         };
19601       }
19602     }
19603
19604     jresult = SWIG_csharp_string_callback(result->c_str());
19605   }
19606
19607   return jresult;
19608 }
19609
19610
19611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19612   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19613   std::string *arg2 = 0 ;
19614
19615   Dali::KeyEvent arg1 = *argp1;
19616   if (!jarg2) {
19617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19618     return ;
19619   }
19620   std::string arg2_str(jarg2);
19621   arg2 = &arg2_str;
19622
19623   {
19624     try {
19625       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19626     } catch (std::out_of_range& e) {
19627       {
19628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19629       };
19630     } catch (std::exception& e) {
19631       {
19632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19633       };
19634     } catch (Dali::DaliException e) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19637       };
19638     } catch (...) {
19639       {
19640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19641       };
19642     }
19643   }
19644 }
19645
19646
19647 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19648   char * jresult ;
19649
19650   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19651   std::string *result = 0;
19652
19653   arg1 = ( Dali::KeyEvent * )jarg1;
19654   {
19655     try {
19656       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19657       result = (std::string *) &str;
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675
19676     jresult = SWIG_csharp_string_callback(result->c_str());
19677   }
19678
19679   return jresult;
19680 }
19681
19682
19683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19684   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19685   int arg2 ;
19686
19687   Dali::KeyEvent arg1 = *argp1;
19688   arg2 = (int)jarg2;
19689   {
19690     try {
19691       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19707       };
19708     }
19709   }
19710 }
19711
19712
19713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19714   int jresult ;
19715   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19716   int result;
19717
19718   arg1 = (Dali::KeyEvent *)jarg1;
19719   {
19720     try {
19721       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19722     } catch (std::out_of_range& e) {
19723       {
19724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19725       };
19726     } catch (std::exception& e) {
19727       {
19728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19729       };
19730     } catch (Dali::DaliException e) {
19731       {
19732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19733       };
19734     } catch (...) {
19735       {
19736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19737       };
19738     }
19739   }
19740
19741   jresult = result;
19742   return jresult;
19743 }
19744
19745
19746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19747   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19748   int arg2 ;
19749
19750   Dali::KeyEvent arg1 = *argp1;
19751   arg2 = (int)jarg2;
19752   {
19753     try {
19754       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19755     } catch (std::out_of_range& e) {
19756       {
19757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19758       };
19759     } catch (std::exception& e) {
19760       {
19761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19762       };
19763     } catch (Dali::DaliException e) {
19764       {
19765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19766       };
19767     } catch (...) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19770       };
19771     }
19772   }
19773 }
19774
19775
19776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19777   int jresult ;
19778   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19779   int result;
19780
19781   arg1 = (Dali::KeyEvent *)jarg1;
19782   {
19783     try {
19784       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19785     } catch (std::out_of_range& e) {
19786       {
19787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19788       };
19789     } catch (std::exception& e) {
19790       {
19791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19792       };
19793     } catch (Dali::DaliException e) {
19794       {
19795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19796       };
19797     } catch (...) {
19798       {
19799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19800       };
19801     }
19802   }
19803
19804   jresult = result;
19805   return jresult;
19806 }
19807
19808
19809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19810   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19811   unsigned long arg2 ;
19812
19813   Dali::KeyEvent arg1 = *argp1;
19814   arg2 = (int)jarg2;
19815   {
19816     try {
19817       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19818     } catch (std::out_of_range& e) {
19819       {
19820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19821       };
19822     } catch (std::exception& e) {
19823       {
19824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19825       };
19826     } catch (Dali::DaliException e) {
19827       {
19828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19829       };
19830     } catch (...) {
19831       {
19832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19833       };
19834     }
19835   }
19836 }
19837
19838
19839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19840   unsigned long jresult ;
19841   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19842   unsigned long result;
19843
19844   arg1 = (Dali::KeyEvent *)jarg1;
19845   {
19846     try {
19847       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19848     } catch (std::out_of_range& e) {
19849       {
19850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19851       };
19852     } catch (std::exception& e) {
19853       {
19854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19855       };
19856     } catch (Dali::DaliException e) {
19857       {
19858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19859       };
19860     } catch (...) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19863       };
19864     }
19865   }
19866
19867   jresult = result;
19868   return jresult;
19869 }
19870
19871
19872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19873   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19874   Dali::KeyEvent::State arg2;
19875
19876   Dali::KeyEvent arg1 = *argp1;
19877   arg2 = (Dali::KeyEvent::State)jarg2;
19878   {
19879     try {
19880       Dali::DevelKeyEvent::SetState(arg1, arg2);
19881     } catch (std::out_of_range& e) {
19882       {
19883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19884       };
19885     } catch (std::exception& e) {
19886       {
19887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19888       };
19889     } catch (Dali::DaliException e) {
19890       {
19891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19892       };
19893     } catch (...) {
19894       {
19895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19896       };
19897     }
19898   }
19899 }
19900
19901
19902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19903   int jresult ;
19904   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19905   Dali::KeyEvent::State result;
19906
19907   arg1 = (Dali::KeyEvent *)jarg1;
19908   {
19909     try {
19910       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19911     } catch (std::out_of_range& e) {
19912       {
19913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19914       };
19915     } catch (std::exception& e) {
19916       {
19917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19918       };
19919     } catch (Dali::DaliException e) {
19920       {
19921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19922       };
19923     } catch (...) {
19924       {
19925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19926       };
19927     }
19928   }
19929
19930   jresult = (int)result;
19931   return jresult;
19932
19933 }
19934
19935 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19936   char * jresult ;
19937
19938   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19939   std::string *result = 0;
19940
19941   arg1 = ( Dali::KeyEvent * )jarg1;
19942   {
19943     try {
19944       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19945       result = (std::string *) &str;
19946     } CALL_CATCH_EXCEPTION(0);
19947
19948   }
19949
19950   jresult = SWIG_csharp_string_callback(result->c_str());
19951   return jresult;
19952 }
19953
19954
19955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
19956   void * jresult ;
19957   Dali::LongPressGestureDetector *result = 0 ;
19958
19959   {
19960     try {
19961       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
19962     } CALL_CATCH_EXCEPTION(0);
19963   }
19964
19965   jresult = (void *)result;
19966   return jresult;
19967 }
19968
19969
19970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
19971   void * jresult ;
19972   Dali::LongPressGestureDetector result;
19973
19974   {
19975     try {
19976       result = Dali::LongPressGestureDetector::New();
19977     } CALL_CATCH_EXCEPTION(0);
19978   }
19979
19980   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
19981   return jresult;
19982 }
19983
19984
19985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
19986   void * jresult ;
19987   unsigned int arg1 ;
19988   Dali::LongPressGestureDetector result;
19989
19990   arg1 = (unsigned int)jarg1;
19991   {
19992     try {
19993       result = Dali::LongPressGestureDetector::New(arg1);
19994     } CALL_CATCH_EXCEPTION(0);
19995   }
19996
19997   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
19998   return jresult;
19999 }
20000
20001
20002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20003   void * jresult ;
20004   unsigned int arg1 ;
20005   unsigned int arg2 ;
20006   Dali::LongPressGestureDetector result;
20007
20008   arg1 = (unsigned int)jarg1;
20009   arg2 = (unsigned int)jarg2;
20010   {
20011     try {
20012       result = Dali::LongPressGestureDetector::New(arg1,arg2);
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_DownCast(void * jarg1) {
20022   void * jresult ;
20023   Dali::BaseHandle arg1 ;
20024   Dali::BaseHandle *argp1 ;
20025   Dali::LongPressGestureDetector result;
20026
20027   argp1 = (Dali::BaseHandle *)jarg1;
20028   if (!argp1) {
20029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20030     return 0;
20031   }
20032   arg1 = *argp1;
20033   {
20034     try {
20035       result = Dali::LongPressGestureDetector::DownCast(arg1);
20036     } CALL_CATCH_EXCEPTION(0);
20037   }
20038
20039   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20040   return jresult;
20041 }
20042
20043
20044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20045   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20046
20047   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20048   {
20049     try {
20050       delete arg1;
20051     } CALL_CATCH_EXCEPTION();
20052   }
20053
20054 }
20055
20056
20057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20058   void * jresult ;
20059   Dali::LongPressGestureDetector *arg1 = 0 ;
20060   Dali::LongPressGestureDetector *result = 0 ;
20061
20062   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20063   if (!arg1) {
20064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20065     return 0;
20066   }
20067   {
20068     try {
20069       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20070     } CALL_CATCH_EXCEPTION(0);
20071   }
20072
20073   jresult = (void *)result;
20074   return jresult;
20075 }
20076
20077
20078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20079   void * jresult ;
20080   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20081   Dali::LongPressGestureDetector *arg2 = 0 ;
20082   Dali::LongPressGestureDetector *result = 0 ;
20083
20084   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20085   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20086   if (!arg2) {
20087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20088     return 0;
20089   }
20090   {
20091     try {
20092       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20093     } CALL_CATCH_EXCEPTION(0);
20094   }
20095
20096   jresult = (void *)result;
20097   return jresult;
20098 }
20099
20100
20101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20102   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20103   unsigned int arg2 ;
20104
20105   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20106   arg2 = (unsigned int)jarg2;
20107   {
20108     try {
20109       (arg1)->SetTouchesRequired(arg2);
20110     } CALL_CATCH_EXCEPTION();
20111   }
20112
20113 }
20114
20115
20116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20117   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20118   unsigned int arg2 ;
20119   unsigned int arg3 ;
20120
20121   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20122   arg2 = (unsigned int)jarg2;
20123   arg3 = (unsigned int)jarg3;
20124   {
20125     try {
20126       (arg1)->SetTouchesRequired(arg2,arg3);
20127     } CALL_CATCH_EXCEPTION();
20128   }
20129
20130 }
20131
20132
20133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20134   unsigned int jresult ;
20135   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20136   unsigned int result;
20137
20138   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20139   {
20140     try {
20141       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20142     } CALL_CATCH_EXCEPTION(0);
20143   }
20144
20145   jresult = result;
20146   return jresult;
20147 }
20148
20149
20150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20151   unsigned int jresult ;
20152   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20153   unsigned int result;
20154
20155   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20156   {
20157     try {
20158       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20159     } CALL_CATCH_EXCEPTION(0);
20160   }
20161
20162   jresult = result;
20163   return jresult;
20164 }
20165
20166
20167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20168   void * jresult ;
20169   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20170   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20171
20172   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20173   {
20174     try {
20175       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20176     } CALL_CATCH_EXCEPTION(0);
20177   }
20178
20179   jresult = (void *)result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
20185   void * jresult ;
20186   Dali::LongPressGesture *result = 0 ;
20187
20188   {
20189     try {
20190       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
20191     } CALL_CATCH_EXCEPTION(0);
20192   }
20193
20194   jresult = (void *)result;
20195   return jresult;
20196 }
20197
20198
20199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20200   void * jresult ;
20201   Dali::LongPressGesture *arg1 = 0 ;
20202   Dali::LongPressGesture *result = 0 ;
20203
20204   arg1 = (Dali::LongPressGesture *)jarg1;
20205   if (!arg1) {
20206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20207     return 0;
20208   }
20209   {
20210     try {
20211       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20212     } CALL_CATCH_EXCEPTION(0);
20213   }
20214
20215   jresult = (void *)result;
20216   return jresult;
20217 }
20218
20219
20220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20221   void * jresult ;
20222   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20223   Dali::LongPressGesture *arg2 = 0 ;
20224   Dali::LongPressGesture *result = 0 ;
20225
20226   arg1 = (Dali::LongPressGesture *)jarg1;
20227   arg2 = (Dali::LongPressGesture *)jarg2;
20228   if (!arg2) {
20229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20230     return 0;
20231   }
20232   {
20233     try {
20234       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20235     } CALL_CATCH_EXCEPTION(0);
20236   }
20237
20238   jresult = (void *)result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20244   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20245
20246   arg1 = (Dali::LongPressGesture *)jarg1;
20247   {
20248     try {
20249       delete arg1;
20250     } CALL_CATCH_EXCEPTION();
20251   }
20252
20253 }
20254
20255
20256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20257   unsigned int jresult ;
20258   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20259   unsigned int result;
20260
20261   arg1 = (Dali::LongPressGesture *)jarg1;
20262   result = (unsigned int) ((arg1)->GetNumberOfTouches());
20263   jresult = result;
20264   return jresult;
20265 }
20266
20267
20268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20269   void * jresult ;
20270   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20271   Dali::Vector2 result;
20272
20273   arg1 = (Dali::LongPressGesture *)jarg1;
20274   {
20275     try {
20276       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
20277     } catch (std::out_of_range& e) {
20278       {
20279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20280       };
20281     } catch (std::exception& e) {
20282       {
20283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20284       };
20285     } catch (Dali::DaliException e) {
20286       {
20287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20288       };
20289     } catch (...) {
20290       {
20291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20292       };
20293     }
20294   }
20295   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20296   return jresult;
20297 }
20298
20299
20300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20301   void * jresult ;
20302   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20303   Dali::Vector2 result;
20304
20305   arg1 = (Dali::LongPressGesture *)jarg1;
20306   {
20307     try {
20308       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
20309     } catch (std::out_of_range& e) {
20310       {
20311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20312       };
20313     } catch (std::exception& e) {
20314       {
20315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20316       };
20317     } catch (Dali::DaliException e) {
20318       {
20319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20320       };
20321     } catch (...) {
20322       {
20323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20324       };
20325     }
20326   }
20327   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20328   return jresult;
20329 }
20330
20331
20332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20333   void * jresult ;
20334   Dali::WheelEvent *result = 0 ;
20335
20336   {
20337     try {
20338       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20339     } CALL_CATCH_EXCEPTION(0);
20340   }
20341
20342   jresult = (void *)result;
20343   return jresult;
20344 }
20345
20346
20347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20348   void * jresult ;
20349   Dali::WheelEvent *arg1 = 0 ;
20350   Dali::WheelEvent *result = 0 ;
20351
20352   arg1 = (Dali::WheelEvent *)jarg1;
20353   if (!arg1) {
20354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20355     return 0;
20356   }
20357   {
20358     try {
20359       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20360     } catch (std::out_of_range& e) {
20361       {
20362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20363       };
20364     } catch (std::exception& e) {
20365       {
20366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20367       };
20368     } catch (Dali::DaliException e) {
20369       {
20370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20371       };
20372     } catch (...) {
20373       {
20374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20375       };
20376     }
20377   }
20378
20379   jresult = (void *)result;
20380   return jresult;
20381 }
20382
20383
20384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20385   void * jresult ;
20386   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20387   Dali::WheelEvent *arg2 = 0 ;
20388   Dali::WheelEvent *result = 0 ;
20389
20390   arg1 = (Dali::WheelEvent *)jarg1;
20391   arg2 = (Dali::WheelEvent *)jarg2;
20392   if (!arg2) {
20393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20394     return 0;
20395   }
20396   {
20397     try {
20398       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20399     } catch (std::out_of_range& e) {
20400       {
20401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20402       };
20403     } catch (std::exception& e) {
20404       {
20405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20406       };
20407     } catch (Dali::DaliException e) {
20408       {
20409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20410       };
20411     } catch (...) {
20412       {
20413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20414       };
20415     }
20416   }
20417
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20423   void * jresult ;
20424   Dali::WheelEvent::Type arg1 ;
20425   int arg2 ;
20426   unsigned int arg3 ;
20427   Dali::Vector2 arg4 ;
20428   int arg5 ;
20429   unsigned int arg6 ;
20430   Dali::Vector2 *argp4 ;
20431   Dali::WheelEvent result;
20432
20433   arg1 = (Dali::WheelEvent::Type)jarg1;
20434   arg2 = (int)jarg2;
20435   arg3 = (unsigned int)jarg3;
20436   argp4 = (Dali::Vector2 *)jarg4;
20437   if (!argp4) {
20438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20439     return 0;
20440   }
20441   arg4 = *argp4;
20442   arg5 = (int)jarg5;
20443   arg6 = (unsigned int)jarg6;
20444   {
20445     try {
20446       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20447     } CALL_CATCH_EXCEPTION(0);
20448   }
20449
20450   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20451   return jresult;
20452 }
20453
20454
20455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20456   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20457
20458   arg1 = (Dali::WheelEvent *)jarg1;
20459   {
20460     try {
20461       delete arg1;
20462     } CALL_CATCH_EXCEPTION();
20463   }
20464
20465 }
20466
20467
20468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20469   unsigned int jresult ;
20470   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20471   bool result;
20472
20473   arg1 = (Dali::WheelEvent *)jarg1;
20474   {
20475     try {
20476       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20477     } CALL_CATCH_EXCEPTION(0);
20478   }
20479
20480   jresult = result;
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
20486   unsigned int jresult ;
20487   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20488   bool result;
20489
20490   arg1 = (Dali::WheelEvent *)jarg1;
20491   {
20492     try {
20493       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
20494     } catch (std::out_of_range& e) {
20495       {
20496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20497       };
20498     } catch (std::exception& e) {
20499       {
20500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20501       };
20502     } catch (Dali::DaliException e) {
20503       {
20504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20505       };
20506     } catch (...) {
20507       {
20508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20509       };
20510     }
20511   }
20512
20513   jresult = result;
20514   return jresult;
20515 }
20516
20517
20518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20519   unsigned int jresult ;
20520   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20521   bool result;
20522
20523   arg1 = (Dali::WheelEvent *)jarg1;
20524   {
20525     try {
20526       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20527     } catch (std::out_of_range& e) {
20528       {
20529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20530       };
20531     } catch (std::exception& e) {
20532       {
20533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20534       };
20535     } catch (Dali::DaliException e) {
20536       {
20537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20538       };
20539     } catch (...) {
20540       {
20541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20542       };
20543     }
20544   }
20545
20546   jresult = result;
20547   return jresult;
20548 }
20549
20550
20551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20552   int jresult ;
20553   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20554   Dali::WheelEvent::Type result;
20555
20556   arg1 = (Dali::WheelEvent *)jarg1;
20557   {
20558     try {
20559       result = ((Dali::WheelEvent const *)arg1)->GetType();
20560     } catch (std::out_of_range& e) {
20561       {
20562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20563       };
20564     } catch (std::exception& e) {
20565       {
20566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20567       };
20568     } catch (Dali::DaliException e) {
20569       {
20570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20571       };
20572     } catch (...) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20575       };
20576     }
20577   }
20578
20579   jresult = (int)result;
20580   return jresult;
20581 }
20582
20583
20584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20585   int jresult ;
20586   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20587   int result;
20588
20589   arg1 = (Dali::WheelEvent *)jarg1;
20590   {
20591     try {
20592       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20593     } catch (std::out_of_range& e) {
20594       {
20595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (std::exception& e) {
20598       {
20599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20600       };
20601     } catch (Dali::DaliException e) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20604       };
20605     } catch (...) {
20606       {
20607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20608       };
20609     }
20610   }
20611
20612   jresult = result;
20613   return jresult;
20614 }
20615
20616
20617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20618   unsigned int jresult ;
20619   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20620   unsigned int result;
20621
20622   arg1 = (Dali::WheelEvent *)jarg1;
20623   {
20624     try {
20625       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20626     } CALL_CATCH_EXCEPTION(0);
20627   }
20628
20629   jresult = result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20635   void * jresult ;
20636   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20637   Dali::Vector2 *result = 0 ;
20638
20639   arg1 = (Dali::WheelEvent *)jarg1;
20640   {
20641     try {
20642       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20643     } CALL_CATCH_EXCEPTION(0);
20644   }
20645
20646   jresult = (void *)result;
20647   return jresult;
20648 }
20649
20650
20651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20652   int jresult ;
20653   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20654   int result;
20655
20656   arg1 = (Dali::WheelEvent *)jarg1;
20657   {
20658     try {
20659       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (Dali::DaliException e) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678
20679   jresult = result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20685   unsigned int jresult ;
20686   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20687   unsigned int result;
20688
20689   arg1 = (Dali::WheelEvent *)jarg1;
20690   {
20691     try {
20692       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = result;
20713   return jresult;
20714 }
20715
20716 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20717   char * jresult ;
20718   Dali::KeyEvent *arg1 = 0 ;
20719   std::string result;
20720
20721   arg1 = (Dali::KeyEvent *)jarg1;
20722   if (!arg1) {
20723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20724     return 0;
20725   }
20726   {
20727     try {
20728       result = arg1->GetDeviceName();
20729     } CALL_CATCH_EXCEPTION(0);
20730   }
20731
20732   jresult = SWIG_csharp_string_callback((&result)->c_str());
20733   return jresult;
20734 }
20735
20736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20737   int jresult ;
20738   Dali::KeyEvent *arg1 = 0 ;
20739   Dali::Device::Class::Type result;
20740
20741   arg1 = (Dali::KeyEvent *)jarg1;
20742   if (!arg1) {
20743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20744     return 0;
20745   }
20746   {
20747     try {
20748       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20749     } CALL_CATCH_EXCEPTION(0);
20750   }
20751
20752   jresult = (int)result;
20753   return jresult;
20754 }
20755
20756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20757   int jresult ;
20758   Dali::KeyEvent *arg1 = 0 ;
20759   Dali::Device::Subclass::Type result;
20760
20761   arg1 = (Dali::KeyEvent *)jarg1;
20762   if (!arg1) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20764     return 0;
20765   }
20766   {
20767     try {
20768       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20769     } CALL_CATCH_EXCEPTION(0);
20770   }
20771
20772   jresult = (int)result;
20773   return jresult;
20774 }
20775
20776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
20777   Dali::Actor arg1 ;
20778   Dali::Actor *argp1 ;
20779
20780   argp1 = (Dali::Actor *)jarg1;
20781   if (!argp1) {
20782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20783     return ;
20784   }
20785   arg1 = *argp1;
20786   {
20787     try {
20788       arg1.Raise();
20789     } CALL_CATCH_EXCEPTION();
20790   }
20791
20792 }
20793
20794
20795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
20796   Dali::Actor arg1 ;
20797   Dali::Actor *argp1 ;
20798
20799   argp1 = (Dali::Actor *)jarg1;
20800   if (!argp1) {
20801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20802     return ;
20803   }
20804   arg1 = *argp1;
20805   {
20806     try {
20807       arg1.Lower();
20808     } CALL_CATCH_EXCEPTION();
20809   }
20810
20811 }
20812
20813
20814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
20815   Dali::Actor arg1 ;
20816   Dali::Actor *argp1 ;
20817
20818   argp1 = (Dali::Actor *)jarg1;
20819   if (!argp1) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20821     return ;
20822   }
20823   arg1 = *argp1;
20824   {
20825     try {
20826       arg1.RaiseToTop();
20827     } CALL_CATCH_EXCEPTION();
20828   }
20829
20830 }
20831
20832
20833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20834   Dali::Actor arg1 ;
20835   Dali::Actor *argp1 ;
20836
20837   argp1 = (Dali::Actor *)jarg1;
20838   if (!argp1) {
20839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20840     return ;
20841   }
20842   arg1 = *argp1;
20843   {
20844     try {
20845       arg1.LowerToBottom();
20846     } CALL_CATCH_EXCEPTION();
20847   }
20848
20849 }
20850
20851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20852   Dali::Actor arg1 ;
20853   Dali::Actor arg2 ;
20854   Dali::Actor *argp1 ;
20855   Dali::Actor *argp2 ;
20856
20857   argp1 = (Dali::Actor *)jarg1;
20858   if (!argp1) {
20859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20860     return ;
20861   }
20862   arg1 = *argp1;
20863   argp2 = (Dali::Actor *)jarg2;
20864   if (!argp2) {
20865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20866     return ;
20867   }
20868   arg2 = *argp2;
20869   {
20870     try {
20871       arg1.RaiseAbove(arg2);
20872     } CALL_CATCH_EXCEPTION();
20873   }
20874
20875 }
20876
20877
20878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20879   Dali::Actor arg1 ;
20880   Dali::Actor arg2 ;
20881   Dali::Actor *argp1 ;
20882   Dali::Actor *argp2 ;
20883
20884   argp1 = (Dali::Actor *)jarg1;
20885   if (!argp1) {
20886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20887     return ;
20888   }
20889   arg1 = *argp1;
20890   argp2 = (Dali::Actor *)jarg2;
20891   if (!argp2) {
20892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20893     return ;
20894   }
20895   arg2 = *argp2;
20896   {
20897     try {
20898       arg1.LowerBelow(arg2);
20899     } CALL_CATCH_EXCEPTION();
20900   }
20901
20902 }
20903
20904
20905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20906   void * jresult ;
20907   Dali::Actor arg1 ;
20908   Dali::Actor *argp1 ;
20909   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20910
20911   argp1 = (Dali::Actor *)jarg1;
20912   if (!argp1) {
20913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20914     return 0;
20915   }
20916   arg1 = *argp1;
20917   {
20918     try {
20919       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20920     } CALL_CATCH_EXCEPTION(0);
20921   }
20922
20923   jresult = (void *)result;
20924   return jresult;
20925 }
20926
20927
20928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20929   void * jresult ;
20930   Dali::Actor *arg1 ;
20931   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20932
20933   arg1 = (Dali::Actor *)jarg1;
20934   {
20935     try {
20936       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20937     } CALL_CATCH_EXCEPTION(0);
20938   }
20939
20940   jresult = (void *)result;
20941   return jresult;
20942 }
20943
20944
20945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20946   int jresult ;
20947   int result;
20948
20949   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20950   jresult = (int)result;
20951   return jresult;
20952 }
20953
20954
20955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20956   int jresult ;
20957   int result;
20958
20959   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
20960   jresult = (int)result;
20961   return jresult;
20962 }
20963
20964
20965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
20966   int jresult ;
20967   int result;
20968
20969   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
20970   jresult = (int)result;
20971   return jresult;
20972 }
20973
20974
20975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
20976   int jresult ;
20977   int result;
20978
20979   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
20980   jresult = (int)result;
20981   return jresult;
20982 }
20983
20984
20985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
20986   int jresult ;
20987   int result;
20988
20989   result = (int)Dali::Actor::Property::ANCHOR_POINT;
20990   jresult = (int)result;
20991   return jresult;
20992 }
20993
20994
20995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
20996   int jresult ;
20997   int result;
20998
20999   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21000   jresult = (int)result;
21001   return jresult;
21002 }
21003
21004
21005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21006   int jresult ;
21007   int result;
21008
21009   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21010   jresult = (int)result;
21011   return jresult;
21012 }
21013
21014
21015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21016   int jresult ;
21017   int result;
21018
21019   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21020   jresult = (int)result;
21021   return jresult;
21022 }
21023
21024
21025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21026   int jresult ;
21027   int result;
21028
21029   result = (int)Dali::Actor::Property::SIZE;
21030   jresult = (int)result;
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21036   int jresult ;
21037   int result;
21038
21039   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21040   jresult = (int)result;
21041   return jresult;
21042 }
21043
21044
21045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21046   int jresult ;
21047   int result;
21048
21049   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21050   jresult = (int)result;
21051   return jresult;
21052 }
21053
21054
21055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21056   int jresult ;
21057   int result;
21058
21059   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21060   jresult = (int)result;
21061   return jresult;
21062 }
21063
21064
21065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21066   int jresult ;
21067   int result;
21068
21069   result = (int)Dali::Actor::Property::POSITION;
21070   jresult = (int)result;
21071   return jresult;
21072 }
21073
21074
21075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21076   int jresult ;
21077   int result;
21078
21079   result = (int)Dali::Actor::Property::POSITION_X;
21080   jresult = (int)result;
21081   return jresult;
21082 }
21083
21084
21085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21086   int jresult ;
21087   int result;
21088
21089   result = (int)Dali::Actor::Property::POSITION_Y;
21090   jresult = (int)result;
21091   return jresult;
21092 }
21093
21094
21095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21096   int jresult ;
21097   int result;
21098
21099   result = (int)Dali::Actor::Property::POSITION_Z;
21100   jresult = (int)result;
21101   return jresult;
21102 }
21103
21104
21105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21106   int jresult ;
21107   int result;
21108
21109   result = (int)Dali::Actor::Property::WORLD_POSITION;
21110   jresult = (int)result;
21111   return jresult;
21112 }
21113
21114
21115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21116   int jresult ;
21117   int result;
21118
21119   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21120   jresult = (int)result;
21121   return jresult;
21122 }
21123
21124
21125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21126   int jresult ;
21127   int result;
21128
21129   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21130   jresult = (int)result;
21131   return jresult;
21132 }
21133
21134
21135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21136   int jresult ;
21137   int result;
21138
21139   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21140   jresult = (int)result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21146   int jresult ;
21147   int result;
21148
21149   result = (int)Dali::Actor::Property::ORIENTATION;
21150   jresult = (int)result;
21151   return jresult;
21152 }
21153
21154
21155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21156   int jresult ;
21157   int result;
21158
21159   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21160   jresult = (int)result;
21161   return jresult;
21162 }
21163
21164
21165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21166   int jresult ;
21167   int result;
21168
21169   result = (int)Dali::Actor::Property::SCALE;
21170   jresult = (int)result;
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21176   int jresult ;
21177   int result;
21178
21179   result = (int)Dali::Actor::Property::SCALE_X;
21180   jresult = (int)result;
21181   return jresult;
21182 }
21183
21184
21185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21186   int jresult ;
21187   int result;
21188
21189   result = (int)Dali::Actor::Property::SCALE_Y;
21190   jresult = (int)result;
21191   return jresult;
21192 }
21193
21194
21195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21196   int jresult ;
21197   int result;
21198
21199   result = (int)Dali::Actor::Property::SCALE_Z;
21200   jresult = (int)result;
21201   return jresult;
21202 }
21203
21204
21205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21206   int jresult ;
21207   int result;
21208
21209   result = (int)Dali::Actor::Property::WORLD_SCALE;
21210   jresult = (int)result;
21211   return jresult;
21212 }
21213
21214
21215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21216   int jresult ;
21217   int result;
21218
21219   result = (int)Dali::Actor::Property::VISIBLE;
21220   jresult = (int)result;
21221   return jresult;
21222 }
21223
21224
21225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21226   int jresult ;
21227   int result;
21228
21229   result = (int)Dali::Actor::Property::COLOR;
21230   jresult = (int)result;
21231   return jresult;
21232 }
21233
21234
21235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21236   int jresult ;
21237   int result;
21238
21239   result = (int)Dali::Actor::Property::COLOR_RED;
21240   jresult = (int)result;
21241   return jresult;
21242 }
21243
21244
21245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21246   int jresult ;
21247   int result;
21248
21249   result = (int)Dali::Actor::Property::COLOR_GREEN;
21250   jresult = (int)result;
21251   return jresult;
21252 }
21253
21254
21255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21256   int jresult ;
21257   int result;
21258
21259   result = (int)Dali::Actor::Property::COLOR_BLUE;
21260   jresult = (int)result;
21261   return jresult;
21262 }
21263
21264
21265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21266   int jresult ;
21267   int result;
21268
21269   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21270   jresult = (int)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21276   int jresult ;
21277   int result;
21278
21279   result = (int)Dali::Actor::Property::WORLD_COLOR;
21280   jresult = (int)result;
21281   return jresult;
21282 }
21283
21284
21285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21286   int jresult ;
21287   int result;
21288
21289   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21290   jresult = (int)result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21296   int jresult ;
21297   int result;
21298
21299   result = (int)Dali::Actor::Property::NAME;
21300   jresult = (int)result;
21301   return jresult;
21302 }
21303
21304
21305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21306   int jresult ;
21307   int result;
21308
21309   result = (int)Dali::Actor::Property::SENSITIVE;
21310   jresult = (int)result;
21311   return jresult;
21312 }
21313
21314
21315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21316   int jresult ;
21317   int result;
21318
21319   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21320   jresult = (int)result;
21321   return jresult;
21322 }
21323
21324
21325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21326   int jresult ;
21327   int result;
21328
21329   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21330   jresult = (int)result;
21331   return jresult;
21332 }
21333
21334
21335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21336   int jresult ;
21337   int result;
21338
21339   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21340   jresult = (int)result;
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21346   int jresult ;
21347   int result;
21348
21349   result = (int)Dali::Actor::Property::COLOR_MODE;
21350   jresult = (int)result;
21351   return jresult;
21352 }
21353
21354
21355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21356   int jresult ;
21357   int result;
21358
21359   result = (int)Dali::Actor::Property::DRAW_MODE;
21360   jresult = (int)result;
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21366   int jresult ;
21367   int result;
21368
21369   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21370   jresult = (int)result;
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21376   int jresult ;
21377   int result;
21378
21379   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21380   jresult = (int)result;
21381   return jresult;
21382 }
21383
21384
21385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21386   int jresult ;
21387   int result;
21388
21389   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21390   jresult = (int)result;
21391   return jresult;
21392 }
21393
21394
21395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21396   int jresult ;
21397   int result;
21398
21399   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21400   jresult = (int)result;
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21406   int jresult ;
21407   int result;
21408
21409   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21410   jresult = (int)result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21416   int jresult ;
21417   int result;
21418
21419   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21420   jresult = (int)result;
21421   return jresult;
21422 }
21423
21424
21425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21426   int jresult ;
21427   int result;
21428
21429   result = (int)Dali::Actor::Property::PADDING;
21430   jresult = (int)result;
21431   return jresult;
21432 }
21433
21434
21435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21436   int jresult ;
21437   int result;
21438
21439   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21440   jresult = (int)result;
21441   return jresult;
21442 }
21443
21444
21445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21446   int jresult ;
21447   int result;
21448
21449   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21450   jresult = (int)result;
21451   return jresult;
21452 }
21453
21454
21455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21456   int jresult ;
21457   int result;
21458
21459   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21460   jresult = (int)result;
21461   return jresult;
21462 }
21463
21464
21465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21466   int jresult ;
21467   int result;
21468
21469   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21470   jresult = (int)result;
21471   return jresult;
21472 }
21473
21474 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21475
21476   return Dali::Actor::Property::OPACITY;
21477 }
21478
21479 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21480
21481   return Dali::Actor::Property::SCREEN_POSITION;
21482 }
21483
21484 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21485
21486   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21487 }
21488
21489 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21490   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21491 }
21492
21493 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21494   return Dali::Actor::Property::LAYOUT_DIRECTION;
21495 }
21496
21497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21498   void * jresult ;
21499   Dali::Actor::Property *result = 0 ;
21500
21501   {
21502     try {
21503       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21504     } CALL_CATCH_EXCEPTION(0);
21505   }
21506
21507   jresult = (void *)result;
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21513   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21514
21515   arg1 = (Dali::Actor::Property *)jarg1;
21516   {
21517     try {
21518       delete arg1;
21519     } CALL_CATCH_EXCEPTION();
21520   }
21521
21522 }
21523
21524
21525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21526   void * jresult ;
21527   Dali::Actor *result = 0 ;
21528
21529   {
21530     try {
21531       result = (Dali::Actor *)new Dali::Actor();
21532     } CALL_CATCH_EXCEPTION(0);
21533   }
21534
21535   jresult = (void *)result;
21536   return jresult;
21537 }
21538
21539
21540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21541   void * jresult ;
21542   Dali::Actor result;
21543
21544   {
21545     try {
21546       result = Dali::Actor::New();
21547     } CALL_CATCH_EXCEPTION(0);
21548   }
21549
21550   jresult = new Dali::Actor((const Dali::Actor &)result);
21551   return jresult;
21552 }
21553
21554
21555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21556   void * jresult ;
21557   Dali::BaseHandle arg1 ;
21558   Dali::BaseHandle *argp1 ;
21559   Dali::Actor result;
21560
21561   argp1 = (Dali::BaseHandle *)jarg1;
21562   if (!argp1) {
21563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21564     return 0;
21565   }
21566   arg1 = *argp1;
21567   {
21568     try {
21569       result = Dali::Actor::DownCast(arg1);
21570     } CALL_CATCH_EXCEPTION(0);
21571   }
21572
21573   jresult = new Dali::Actor((const Dali::Actor &)result);
21574   return jresult;
21575 }
21576
21577
21578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21580
21581   arg1 = (Dali::Actor *)jarg1;
21582   {
21583     try {
21584       delete arg1;
21585     } CALL_CATCH_EXCEPTION();
21586   }
21587
21588 }
21589
21590
21591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21592   void * jresult ;
21593   Dali::Actor *arg1 = 0 ;
21594   Dali::Actor *result = 0 ;
21595
21596   arg1 = (Dali::Actor *)jarg1;
21597   if (!arg1) {
21598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21599     return 0;
21600   }
21601   {
21602     try {
21603       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21604     } CALL_CATCH_EXCEPTION(0);
21605   }
21606
21607   jresult = (void *)result;
21608   return jresult;
21609 }
21610
21611
21612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21613   void * jresult ;
21614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21615   Dali::Actor *arg2 = 0 ;
21616   Dali::Actor *result = 0 ;
21617
21618   arg1 = (Dali::Actor *)jarg1;
21619   arg2 = (Dali::Actor *)jarg2;
21620   if (!arg2) {
21621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21622     return 0;
21623   }
21624   {
21625     try {
21626       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21627     } CALL_CATCH_EXCEPTION(0);
21628   }
21629
21630   jresult = (void *)result;
21631   return jresult;
21632 }
21633
21634
21635 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21636   char * jresult ;
21637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21638   std::string *result = 0 ;
21639   std::string name = "";
21640
21641   arg1 = (Dali::Actor *)jarg1;
21642   {
21643     try {
21644       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21645       result = (std::string *) &name;
21646       jresult = SWIG_csharp_string_callback(result->c_str());
21647     } CALL_CATCH_EXCEPTION(0);
21648   }
21649   return jresult;
21650 }
21651
21652
21653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21655   std::string *arg2 = 0 ;
21656
21657   arg1 = (Dali::Actor *)jarg1;
21658   if (!jarg2) {
21659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21660     return ;
21661   }
21662   std::string arg2_str(jarg2);
21663   arg2 = &arg2_str;
21664   {
21665     try {
21666       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21667     } CALL_CATCH_EXCEPTION();
21668   }
21669
21670
21671   //argout typemap for const std::string&
21672
21673 }
21674
21675
21676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21677   unsigned int jresult ;
21678   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21679   unsigned int result;
21680
21681   arg1 = (Dali::Actor *)jarg1;
21682
21683   if(!arg1) {
21684     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21685     return -1;
21686   }
21687
21688   {
21689     try {
21690       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21691     } CALL_CATCH_EXCEPTION(0);
21692   }
21693
21694   jresult = result;
21695   return jresult;
21696 }
21697
21698
21699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21700   unsigned int jresult ;
21701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21702   bool result;
21703
21704   arg1 = (Dali::Actor *)jarg1;
21705   {
21706     try {
21707       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21708     } CALL_CATCH_EXCEPTION(0);
21709   }
21710
21711   jresult = result;
21712   return jresult;
21713 }
21714
21715
21716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
21717   unsigned int jresult ;
21718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21719   bool result;
21720
21721   arg1 = (Dali::Actor *)jarg1;
21722   {
21723     try {
21724       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
21725     } CALL_CATCH_EXCEPTION(0);
21726   }
21727
21728   jresult = result;
21729   return jresult;
21730 }
21731
21732
21733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
21734   unsigned int jresult ;
21735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21736   bool result;
21737
21738   arg1 = (Dali::Actor *)jarg1;
21739   {
21740     try {
21741       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
21742     } CALL_CATCH_EXCEPTION(0);
21743   }
21744
21745   jresult = result;
21746   return jresult;
21747 }
21748
21749
21750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21751   void * jresult ;
21752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21753   Dali::Layer result;
21754
21755   arg1 = (Dali::Actor *)jarg1;
21756   {
21757     try {
21758       result = (arg1)->GetLayer();
21759     } CALL_CATCH_EXCEPTION(0);
21760   }
21761
21762   jresult = new Dali::Layer((const Dali::Layer &)result);
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21769   Dali::Actor arg2 ;
21770   Dali::Actor *argp2 ;
21771
21772   arg1 = (Dali::Actor *)jarg1;
21773   argp2 = (Dali::Actor *)jarg2;
21774   if (!argp2) {
21775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21776     return ;
21777   }
21778   arg2 = *argp2;
21779   {
21780     try {
21781       (arg1)->Add(arg2);
21782     } CALL_CATCH_EXCEPTION();
21783   }
21784
21785 }
21786
21787
21788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21790   Dali::Actor arg2 ;
21791   Dali::Actor *argp2 ;
21792
21793   arg1 = (Dali::Actor *)jarg1;
21794   argp2 = (Dali::Actor *)jarg2;
21795   if (!argp2) {
21796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21797     return ;
21798   }
21799   arg2 = *argp2;
21800   {
21801     try {
21802       (arg1)->Remove(arg2);
21803     } CALL_CATCH_EXCEPTION();
21804   }
21805
21806 }
21807
21808
21809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21811
21812   arg1 = (Dali::Actor *)jarg1;
21813   {
21814     try {
21815       (arg1)->Unparent();
21816     } CALL_CATCH_EXCEPTION();
21817   }
21818
21819 }
21820
21821
21822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21823   unsigned int jresult ;
21824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21825   unsigned int result;
21826
21827   arg1 = (Dali::Actor *)jarg1;
21828   {
21829     try {
21830       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21831     } CALL_CATCH_EXCEPTION(0);
21832   }
21833
21834   jresult = result;
21835   return jresult;
21836 }
21837
21838
21839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21840   void * jresult ;
21841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21842   unsigned int arg2 ;
21843   Dali::Actor result;
21844
21845   arg1 = (Dali::Actor *)jarg1;
21846   arg2 = (unsigned int)jarg2;
21847   {
21848     try {
21849       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21850     } CALL_CATCH_EXCEPTION(0);
21851   }
21852
21853   jresult = new Dali::Actor((const Dali::Actor &)result);
21854   return jresult;
21855 }
21856
21857
21858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21859   void * jresult ;
21860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21861   std::string *arg2 = 0 ;
21862   Dali::Actor result;
21863
21864   arg1 = (Dali::Actor *)jarg1;
21865   if (!jarg2) {
21866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21867     return 0;
21868   }
21869   std::string arg2_str(jarg2);
21870   arg2 = &arg2_str;
21871   {
21872     try {
21873       result = (arg1)->FindChildByName((std::string const &)*arg2);
21874     } CALL_CATCH_EXCEPTION(0);
21875   }
21876
21877   jresult = new Dali::Actor((const Dali::Actor &)result);
21878
21879   //argout typemap for const std::string&
21880
21881   return jresult;
21882 }
21883
21884
21885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21886   void * jresult ;
21887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21888   unsigned int arg2 ;
21889   Dali::Actor result;
21890
21891   arg1 = (Dali::Actor *)jarg1;
21892   arg2 = (unsigned int)jarg2;
21893   {
21894     try {
21895       result = (arg1)->FindChildById(arg2);
21896     } CALL_CATCH_EXCEPTION(0);
21897   }
21898
21899   jresult = new Dali::Actor((const Dali::Actor &)result);
21900   return jresult;
21901 }
21902
21903
21904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21905   void * jresult ;
21906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21907   Dali::Actor result;
21908
21909   arg1 = (Dali::Actor *)jarg1;
21910   {
21911     try {
21912       result = ((Dali::Actor const *)arg1)->GetParent();
21913     } CALL_CATCH_EXCEPTION(0);
21914   }
21915
21916   jresult = new Dali::Actor((const Dali::Actor &)result);
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
21922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21923   Dali::Vector3 *arg2 = 0 ;
21924
21925   arg1 = (Dali::Actor *)jarg1;
21926   arg2 = (Dali::Vector3 *)jarg2;
21927   if (!arg2) {
21928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21929     return ;
21930   }
21931   {
21932     try {
21933       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21934     } CALL_CATCH_EXCEPTION();
21935   }
21936
21937 }
21938
21939
21940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21941   void * jresult ;
21942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21943   Dali::Vector3 result;
21944
21945   arg1 = (Dali::Actor *)jarg1;
21946   {
21947     try {
21948       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21949     } CALL_CATCH_EXCEPTION(0);
21950   }
21951
21952   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21953   return jresult;
21954 }
21955
21956
21957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(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::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
21970     } CALL_CATCH_EXCEPTION();
21971   }
21972
21973 }
21974
21975
21976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(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::ANCHOR_POINT );
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_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
21994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21995   float arg2 ;
21996   float arg3 ;
21997
21998   arg1 = (Dali::Actor *)jarg1;
21999   arg2 = (float)jarg2;
22000   arg3 = (float)jarg3;
22001   {
22002     try {
22003       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22004     } CALL_CATCH_EXCEPTION();
22005   }
22006
22007 }
22008
22009
22010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22012   float arg2 ;
22013   float arg3 ;
22014   float arg4 ;
22015
22016   arg1 = (Dali::Actor *)jarg1;
22017   arg2 = (float)jarg2;
22018   arg3 = (float)jarg3;
22019   arg4 = (float)jarg4;
22020   {
22021     try {
22022       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22023     } CALL_CATCH_EXCEPTION();
22024   }
22025
22026 }
22027
22028
22029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22031   Dali::Vector2 *arg2 = 0 ;
22032
22033   arg1 = (Dali::Actor *)jarg1;
22034   arg2 = (Dali::Vector2 *)jarg2;
22035   if (!arg2) {
22036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22037     return ;
22038   }
22039   {
22040     try {
22041       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22042     } CALL_CATCH_EXCEPTION();
22043   }
22044
22045 }
22046
22047
22048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22050   Dali::Vector3 *arg2 = 0 ;
22051
22052   arg1 = (Dali::Actor *)jarg1;
22053   arg2 = (Dali::Vector3 *)jarg2;
22054   if (!arg2) {
22055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22056     return ;
22057   }
22058   {
22059     try {
22060       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22061     } CALL_CATCH_EXCEPTION();
22062   }
22063
22064 }
22065
22066
22067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22068   void * jresult ;
22069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22070   Dali::Vector3 result;
22071
22072   arg1 = (Dali::Actor *)jarg1;
22073   {
22074     try {
22075       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22076     } CALL_CATCH_EXCEPTION(0);
22077   }
22078
22079   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22080   return jresult;
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22085   void * jresult ;
22086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22087   Dali::Vector3 result;
22088
22089   arg1 = (Dali::Actor *)jarg1;
22090   {
22091     try {
22092       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22093     } CALL_CATCH_EXCEPTION(0);
22094   }
22095
22096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22097   return jresult;
22098 }
22099
22100
22101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22102   void * jresult ;
22103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22104   Dali::Vector3 result;
22105
22106   arg1 = (Dali::Actor *)jarg1;
22107   {
22108     try {
22109       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22110     } CALL_CATCH_EXCEPTION(0);
22111   }
22112
22113   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22114   return jresult;
22115 }
22116
22117
22118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22120   float arg2 ;
22121   float arg3 ;
22122
22123   arg1 = (Dali::Actor *)jarg1;
22124   arg2 = (float)jarg2;
22125   arg3 = (float)jarg3;
22126   {
22127     try {
22128       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22129     } CALL_CATCH_EXCEPTION();
22130   }
22131
22132 }
22133
22134
22135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22137   float arg2 ;
22138   float arg3 ;
22139   float arg4 ;
22140
22141   arg1 = (Dali::Actor *)jarg1;
22142   arg2 = (float)jarg2;
22143   arg3 = (float)jarg3;
22144   arg4 = (float)jarg4;
22145   {
22146     try {
22147       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22148     } CALL_CATCH_EXCEPTION();
22149   }
22150
22151 }
22152
22153
22154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22156   Dali::Vector3 *arg2 = 0 ;
22157
22158   arg1 = (Dali::Actor *)jarg1;
22159   arg2 = (Dali::Vector3 *)jarg2;
22160   if (!arg2) {
22161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22162     return ;
22163   }
22164   {
22165     try {
22166       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22167     } CALL_CATCH_EXCEPTION();
22168   }
22169
22170 }
22171
22172
22173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22175   float arg2 ;
22176
22177   arg1 = (Dali::Actor *)jarg1;
22178   arg2 = (float)jarg2;
22179   {
22180     try {
22181       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22182     } CALL_CATCH_EXCEPTION();
22183   }
22184
22185 }
22186
22187
22188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22190   float arg2 ;
22191
22192   arg1 = (Dali::Actor *)jarg1;
22193   arg2 = (float)jarg2;
22194   {
22195     try {
22196       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22197     } CALL_CATCH_EXCEPTION();
22198   }
22199
22200 }
22201
22202
22203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22204   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22205   float arg2 ;
22206
22207   arg1 = (Dali::Actor *)jarg1;
22208   arg2 = (float)jarg2;
22209   {
22210     try {
22211       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22212     } CALL_CATCH_EXCEPTION();
22213   }
22214
22215 }
22216
22217
22218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22219   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22220   Dali::Vector3 *arg2 = 0 ;
22221
22222   arg1 = (Dali::Actor *)jarg1;
22223   arg2 = (Dali::Vector3 *)jarg2;
22224   if (!arg2) {
22225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22226     return ;
22227   }
22228   {
22229     try {
22230       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22231     } CALL_CATCH_EXCEPTION();
22232   }
22233
22234 }
22235
22236
22237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22238   void * jresult ;
22239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22240   Dali::Vector3 result;
22241
22242   arg1 = (Dali::Actor *)jarg1;
22243   {
22244     try {
22245       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22246     } CALL_CATCH_EXCEPTION(0);
22247   }
22248
22249   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22250   return jresult;
22251 }
22252
22253
22254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22255   void * jresult ;
22256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22257   Dali::Vector3 result;
22258
22259   arg1 = (Dali::Actor *)jarg1;
22260   {
22261     try {
22262       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22263     } CALL_CATCH_EXCEPTION(0);
22264   }
22265
22266   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22267   return jresult;
22268 }
22269
22270
22271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22272   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22273   bool arg2 ;
22274
22275   arg1 = (Dali::Actor *)jarg1;
22276   arg2 = jarg2 ? true : false;
22277   {
22278     try {
22279       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22280     } CALL_CATCH_EXCEPTION();
22281   }
22282
22283 }
22284
22285
22286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22287   unsigned int jresult ;
22288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22289   bool result;
22290
22291   arg1 = (Dali::Actor *)jarg1;
22292   {
22293     try {
22294       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22295     } CALL_CATCH_EXCEPTION(0);
22296   }
22297
22298   jresult = result;
22299   return jresult;
22300 }
22301
22302
22303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22304   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22305   Dali::Degree *arg2 = 0 ;
22306   Dali::Vector3 *arg3 = 0 ;
22307
22308   arg1 = (Dali::Actor *)jarg1;
22309   arg2 = (Dali::Degree *)jarg2;
22310   if (!arg2) {
22311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22312     return ;
22313   }
22314   arg3 = (Dali::Vector3 *)jarg3;
22315   if (!arg3) {
22316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22317     return ;
22318   }
22319   {
22320     try {
22321       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22322     } CALL_CATCH_EXCEPTION();
22323   }
22324
22325 }
22326
22327
22328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22330   Dali::Radian *arg2 = 0 ;
22331   Dali::Vector3 *arg3 = 0 ;
22332
22333   arg1 = (Dali::Actor *)jarg1;
22334   arg2 = (Dali::Radian *)jarg2;
22335   if (!arg2) {
22336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22337     return ;
22338   }
22339   arg3 = (Dali::Vector3 *)jarg3;
22340   if (!arg3) {
22341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22342     return ;
22343   }
22344   {
22345     try {
22346       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22347     } CALL_CATCH_EXCEPTION();
22348   }
22349
22350 }
22351
22352
22353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22355   Dali::Quaternion *arg2 = 0 ;
22356
22357   arg1 = (Dali::Actor *)jarg1;
22358   arg2 = (Dali::Quaternion *)jarg2;
22359   if (!arg2) {
22360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22361     return ;
22362   }
22363   {
22364     try {
22365       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22366     } CALL_CATCH_EXCEPTION();
22367   }
22368
22369 }
22370
22371
22372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22374   Dali::Degree *arg2 = 0 ;
22375   Dali::Vector3 *arg3 = 0 ;
22376
22377   arg1 = (Dali::Actor *)jarg1;
22378   arg2 = (Dali::Degree *)jarg2;
22379   if (!arg2) {
22380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22381     return ;
22382   }
22383   arg3 = (Dali::Vector3 *)jarg3;
22384   if (!arg3) {
22385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22386     return ;
22387   }
22388   {
22389     try {
22390       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22391     } CALL_CATCH_EXCEPTION();
22392   }
22393
22394 }
22395
22396
22397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22399   Dali::Radian *arg2 = 0 ;
22400   Dali::Vector3 *arg3 = 0 ;
22401
22402   arg1 = (Dali::Actor *)jarg1;
22403   arg2 = (Dali::Radian *)jarg2;
22404   if (!arg2) {
22405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22406     return ;
22407   }
22408   arg3 = (Dali::Vector3 *)jarg3;
22409   if (!arg3) {
22410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22411     return ;
22412   }
22413   {
22414     try {
22415       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22416     } CALL_CATCH_EXCEPTION();
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22424   Dali::Quaternion *arg2 = 0 ;
22425
22426   arg1 = (Dali::Actor *)jarg1;
22427   arg2 = (Dali::Quaternion *)jarg2;
22428   if (!arg2) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22430     return ;
22431   }
22432   {
22433     try {
22434       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22435     } CALL_CATCH_EXCEPTION();
22436   }
22437
22438 }
22439
22440
22441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22442   void * jresult ;
22443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22444   Dali::Quaternion result;
22445
22446   arg1 = (Dali::Actor *)jarg1;
22447   {
22448     try {
22449       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22450     } CALL_CATCH_EXCEPTION(0);
22451   }
22452
22453   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22454   return jresult;
22455 }
22456
22457
22458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22460   bool arg2 ;
22461
22462   arg1 = (Dali::Actor *)jarg1;
22463   arg2 = jarg2 ? true : false;
22464   {
22465     try {
22466       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22467     } CALL_CATCH_EXCEPTION();
22468   }
22469
22470 }
22471
22472
22473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22474   unsigned int jresult ;
22475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22476   bool result;
22477
22478   arg1 = (Dali::Actor *)jarg1;
22479   {
22480     try {
22481       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22482     } CALL_CATCH_EXCEPTION(0);
22483   }
22484
22485   jresult = result;
22486   return jresult;
22487 }
22488
22489
22490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22491   void * jresult ;
22492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22493   Dali::Quaternion result;
22494
22495   arg1 = (Dali::Actor *)jarg1;
22496   {
22497     try {
22498       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22499     } CALL_CATCH_EXCEPTION(0);
22500   }
22501
22502   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22503   return jresult;
22504 }
22505
22506
22507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22509   float arg2 ;
22510
22511   arg1 = (Dali::Actor *)jarg1;
22512   arg2 = (float)jarg2;
22513   {
22514     try {
22515       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22516     } CALL_CATCH_EXCEPTION();
22517   }
22518
22519 }
22520
22521
22522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22524   float arg2 ;
22525   float arg3 ;
22526   float arg4 ;
22527
22528   arg1 = (Dali::Actor *)jarg1;
22529   arg2 = (float)jarg2;
22530   arg3 = (float)jarg3;
22531   arg4 = (float)jarg4;
22532   {
22533     try {
22534       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22535     } CALL_CATCH_EXCEPTION();
22536   }
22537
22538 }
22539
22540
22541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
22542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22543   Dali::Vector3 *arg2 = 0 ;
22544
22545   arg1 = (Dali::Actor *)jarg1;
22546   arg2 = (Dali::Vector3 *)jarg2;
22547   if (!arg2) {
22548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22549     return ;
22550   }
22551   {
22552     try {
22553       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22554     } CALL_CATCH_EXCEPTION();
22555   }
22556
22557 }
22558
22559
22560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22562   Dali::Vector3 *arg2 = 0 ;
22563
22564   arg1 = (Dali::Actor *)jarg1;
22565   arg2 = (Dali::Vector3 *)jarg2;
22566   if (!arg2) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22568     return ;
22569   }
22570   {
22571     try {
22572       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22573     } CALL_CATCH_EXCEPTION();
22574   }
22575
22576 }
22577
22578
22579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22580   void * jresult ;
22581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22582   Dali::Vector3 result;
22583
22584   arg1 = (Dali::Actor *)jarg1;
22585   {
22586     try {
22587       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22588     } CALL_CATCH_EXCEPTION(0);
22589   }
22590
22591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22592   return jresult;
22593 }
22594
22595
22596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
22597   void * jresult ;
22598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22599   Dali::Vector3 result;
22600
22601   arg1 = (Dali::Actor *)jarg1;
22602   {
22603     try {
22604       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
22605     } CALL_CATCH_EXCEPTION(0);
22606   }
22607
22608   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22609   return jresult;
22610 }
22611
22612
22613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
22614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22615   bool arg2 ;
22616
22617   arg1 = (Dali::Actor *)jarg1;
22618   arg2 = jarg2 ? true : false;
22619   {
22620     try {
22621       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22622     } CALL_CATCH_EXCEPTION();
22623   }
22624
22625 }
22626
22627
22628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22629   unsigned int jresult ;
22630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22631   bool result;
22632
22633   arg1 = (Dali::Actor *)jarg1;
22634   {
22635     try {
22636       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22637     } CALL_CATCH_EXCEPTION(0);
22638   }
22639
22640   jresult = result;
22641   return jresult;
22642 }
22643
22644
22645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22646   void * jresult ;
22647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22648   Dali::Matrix result;
22649
22650   arg1 = (Dali::Actor *)jarg1;
22651   {
22652     try {
22653       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22654     } CALL_CATCH_EXCEPTION(0);
22655   }
22656
22657   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22658   return jresult;
22659 }
22660
22661
22662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22664   bool arg2 ;
22665
22666   arg1 = (Dali::Actor *)jarg1;
22667   arg2 = jarg2 ? true : false;
22668   {
22669     try {
22670       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22671     } CALL_CATCH_EXCEPTION();
22672   }
22673
22674 }
22675
22676
22677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22678   unsigned int jresult ;
22679   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22680   bool result;
22681
22682   arg1 = (Dali::Actor *)jarg1;
22683   {
22684     try {
22685       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22686     } CALL_CATCH_EXCEPTION(0);
22687   }
22688
22689   jresult = result;
22690   return jresult;
22691 }
22692
22693
22694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22696   float arg2 ;
22697
22698   arg1 = (Dali::Actor *)jarg1;
22699   arg2 = (float)jarg2;
22700   {
22701     try {
22702       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22703     } CALL_CATCH_EXCEPTION();
22704   }
22705
22706 }
22707
22708
22709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22710   float jresult ;
22711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22712   float result;
22713
22714   arg1 = (Dali::Actor *)jarg1;
22715   {
22716     try {
22717       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22718     } CALL_CATCH_EXCEPTION(0);
22719   }
22720
22721   jresult = result;
22722   return jresult;
22723 }
22724
22725
22726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22728   Dali::Vector4 *arg2 = 0 ;
22729
22730   arg1 = (Dali::Actor *)jarg1;
22731   arg2 = (Dali::Vector4 *)jarg2;
22732   if (!arg2) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22734     return ;
22735   }
22736   {
22737     try {
22738       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22739     } CALL_CATCH_EXCEPTION();
22740   }
22741
22742 }
22743
22744
22745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22746   void * jresult ;
22747   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22748   Dali::Vector4 result;
22749
22750   arg1 = (Dali::Actor *)jarg1;
22751   {
22752     try {
22753       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22754     } CALL_CATCH_EXCEPTION(0);
22755   }
22756
22757   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22758   return jresult;
22759 }
22760
22761
22762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22764   Dali::ColorMode arg2 ;
22765
22766   arg1 = (Dali::Actor *)jarg1;
22767   arg2 = (Dali::ColorMode)jarg2;
22768   {
22769     try {
22770       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22771     } CALL_CATCH_EXCEPTION();
22772   }
22773
22774 }
22775
22776
22777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22778   int jresult ;
22779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22780   Dali::ColorMode result;
22781
22782   arg1 = (Dali::Actor *)jarg1;
22783   {
22784     try {
22785       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22786     } CALL_CATCH_EXCEPTION(0);
22787   }
22788
22789   jresult = (int)result;
22790   return jresult;
22791 }
22792
22793
22794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22795   void * jresult ;
22796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22797   Dali::Vector4 result;
22798
22799   arg1 = (Dali::Actor *)jarg1;
22800   {
22801     try {
22802       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22803     } CALL_CATCH_EXCEPTION(0);
22804   }
22805
22806   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22807   return jresult;
22808 }
22809
22810
22811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22813   Dali::DrawMode::Type arg2 ;
22814
22815   arg1 = (Dali::Actor *)jarg1;
22816   arg2 = (Dali::DrawMode::Type)jarg2;
22817   {
22818     try {
22819       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22820     } CALL_CATCH_EXCEPTION();
22821   }
22822
22823 }
22824
22825
22826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22827   int jresult ;
22828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22829   Dali::DrawMode::Type result;
22830
22831   arg1 = (Dali::Actor *)jarg1;
22832   {
22833     try {
22834       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22835     } CALL_CATCH_EXCEPTION(0);
22836   }
22837
22838   jresult = (int)result;
22839   return jresult;
22840 }
22841
22842
22843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22845   bool arg2 ;
22846
22847   arg1 = (Dali::Actor *)jarg1;
22848   arg2 = jarg2 ? true : false;
22849   {
22850     try {
22851       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22852     } CALL_CATCH_EXCEPTION();
22853   }
22854
22855 }
22856
22857
22858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22859   unsigned int jresult ;
22860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22861   bool result;
22862
22863   arg1 = (Dali::Actor *)jarg1;
22864   {
22865     try {
22866       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22867     } CALL_CATCH_EXCEPTION(0);
22868   }
22869
22870   jresult = result;
22871   return jresult;
22872 }
22873
22874
22875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22876   unsigned int jresult ;
22877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22878   float *arg2 = 0 ;
22879   float *arg3 = 0 ;
22880   float arg4 ;
22881   float arg5 ;
22882   bool result;
22883
22884   arg1 = (Dali::Actor *)jarg1;
22885   arg2 = (float *)jarg2;
22886   arg3 = (float *)jarg3;
22887   arg4 = (float)jarg4;
22888   arg5 = (float)jarg5;
22889   {
22890     try {
22891       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22892     } CALL_CATCH_EXCEPTION(0);
22893   }
22894
22895   jresult = result;
22896   return jresult;
22897 }
22898
22899
22900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22902   bool arg2 ;
22903
22904   arg1 = (Dali::Actor *)jarg1;
22905   arg2 = jarg2 ? true : false;
22906   {
22907     try {
22908       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22909     } CALL_CATCH_EXCEPTION();
22910   }
22911
22912 }
22913
22914
22915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22916   unsigned int jresult ;
22917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22918   bool result;
22919
22920   arg1 = (Dali::Actor *)jarg1;
22921   {
22922     try {
22923       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22924     } CALL_CATCH_EXCEPTION(0);
22925   }
22926
22927   jresult = result;
22928   return jresult;
22929 }
22930
22931
22932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22934   bool arg2 ;
22935
22936   arg1 = (Dali::Actor *)jarg1;
22937   arg2 = jarg2 ? true : false;
22938   {
22939     try {
22940       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22941     } CALL_CATCH_EXCEPTION();
22942   }
22943
22944 }
22945
22946
22947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22948   unsigned int jresult ;
22949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22950   bool result;
22951
22952   arg1 = (Dali::Actor *)jarg1;
22953   {
22954     try {
22955       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22956     } CALL_CATCH_EXCEPTION(0);
22957   }
22958
22959   jresult = result;
22960   return jresult;
22961 }
22962
22963
22964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
22965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22966   Dali::ResizePolicy::Type arg2 ;
22967   Dali::Dimension::Type arg3 ;
22968
22969   arg1 = (Dali::Actor *)jarg1;
22970   arg2 = (Dali::ResizePolicy::Type)jarg2;
22971   arg3 = (Dali::Dimension::Type)jarg3;
22972   {
22973     try {
22974       (arg1)->SetResizePolicy(arg2,arg3);
22975     } CALL_CATCH_EXCEPTION();
22976   }
22977
22978 }
22979
22980
22981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
22982   int jresult ;
22983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22984   Dali::Dimension::Type arg2 ;
22985   Dali::ResizePolicy::Type result;
22986
22987   arg1 = (Dali::Actor *)jarg1;
22988   arg2 = (Dali::Dimension::Type)jarg2;
22989   {
22990     try {
22991       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
22992     } CALL_CATCH_EXCEPTION(0);
22993   }
22994
22995   jresult = (int)result;
22996   return jresult;
22997 }
22998
22999
23000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23002   Dali::SizeScalePolicy::Type arg2 ;
23003
23004   arg1 = (Dali::Actor *)jarg1;
23005   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23006   {
23007     try {
23008       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23009     } CALL_CATCH_EXCEPTION();
23010   }
23011
23012 }
23013
23014
23015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23016   int jresult ;
23017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23018   Dali::SizeScalePolicy::Type result;
23019
23020   arg1 = (Dali::Actor *)jarg1;
23021   {
23022     try {
23023       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23024     } CALL_CATCH_EXCEPTION(0);
23025   }
23026
23027   jresult = (int)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23034   Dali::Vector3 *arg2 = 0 ;
23035
23036   arg1 = (Dali::Actor *)jarg1;
23037   arg2 = (Dali::Vector3 *)jarg2;
23038   if (!arg2) {
23039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23040     return ;
23041   }
23042   {
23043     try {
23044       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23045     } CALL_CATCH_EXCEPTION();
23046   }
23047
23048 }
23049
23050
23051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23052   void * jresult ;
23053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23054   Dali::Vector3 result;
23055
23056   arg1 = (Dali::Actor *)jarg1;
23057   {
23058     try {
23059       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23060     } CALL_CATCH_EXCEPTION(0);
23061   }
23062
23063   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23069   float jresult ;
23070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23071   float arg2 ;
23072   float result;
23073
23074   arg1 = (Dali::Actor *)jarg1;
23075   arg2 = (float)jarg2;
23076   {
23077     try {
23078       result = (float)(arg1)->GetHeightForWidth(arg2);
23079     } CALL_CATCH_EXCEPTION(0);
23080   }
23081
23082   jresult = result;
23083   return jresult;
23084 }
23085
23086
23087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23088   float jresult ;
23089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23090   float arg2 ;
23091   float result;
23092
23093   arg1 = (Dali::Actor *)jarg1;
23094   arg2 = (float)jarg2;
23095   {
23096     try {
23097       result = (float)(arg1)->GetWidthForHeight(arg2);
23098     } CALL_CATCH_EXCEPTION(0);
23099   }
23100
23101   jresult = result;
23102   return jresult;
23103 }
23104
23105
23106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23107   float jresult ;
23108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23109   Dali::Dimension::Type arg2 ;
23110   float result;
23111
23112   arg1 = (Dali::Actor *)jarg1;
23113   arg2 = (Dali::Dimension::Type)jarg2;
23114   {
23115     try {
23116       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23117     } CALL_CATCH_EXCEPTION(0);
23118   }
23119
23120   jresult = result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23127   Dali::Padding *arg2 = 0 ;
23128
23129   arg1 = (Dali::Actor *)jarg1;
23130   arg2 = (Dali::Padding *)jarg2;
23131   if (!arg2) {
23132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23133     return ;
23134   }
23135   {
23136     try {
23137       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23138     } CALL_CATCH_EXCEPTION();
23139   }
23140
23141 }
23142
23143
23144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23146   Dali::Padding *arg2 = 0 ;
23147
23148   arg1 = (Dali::Actor *)jarg1;
23149   arg2 = (Dali::Padding *)jarg2;
23150   if (!arg2) {
23151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23152     return ;
23153   }
23154   {
23155     try {
23156       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23157     } CALL_CATCH_EXCEPTION();
23158   }
23159
23160 }
23161
23162
23163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23165   Dali::Vector2 *arg2 = 0 ;
23166
23167   arg1 = (Dali::Actor *)jarg1;
23168   arg2 = (Dali::Vector2 *)jarg2;
23169   if (!arg2) {
23170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23171     return ;
23172   }
23173   {
23174     try {
23175       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23176     } CALL_CATCH_EXCEPTION();
23177   }
23178
23179 }
23180
23181
23182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23183   void * jresult ;
23184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23185   Dali::Vector2 result;
23186
23187   arg1 = (Dali::Actor *)jarg1;
23188   {
23189     try {
23190       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23191     } CALL_CATCH_EXCEPTION(0);
23192   }
23193
23194   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(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::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23212     } CALL_CATCH_EXCEPTION();
23213   }
23214
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(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::MAXIMUM_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 int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23236   int jresult ;
23237   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23238   int result;
23239
23240   arg1 = (Dali::Actor *)jarg1;
23241   {
23242     try {
23243       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23244       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23245     } CALL_CATCH_EXCEPTION(0);
23246   }
23247
23248   jresult = result;
23249   return jresult;
23250 }
23251
23252
23253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23254   unsigned int jresult ;
23255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23256   Dali::Renderer *arg2 = 0 ;
23257   unsigned int result;
23258
23259   arg1 = (Dali::Actor *)jarg1;
23260   arg2 = (Dali::Renderer *)jarg2;
23261   if (!arg2) {
23262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23263     return 0;
23264   }
23265   {
23266     try {
23267       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23268     } CALL_CATCH_EXCEPTION(0);
23269   }
23270
23271   jresult = result;
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23277   unsigned int jresult ;
23278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23279   unsigned int result;
23280
23281   arg1 = (Dali::Actor *)jarg1;
23282   {
23283     try {
23284       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23285     } CALL_CATCH_EXCEPTION(0);
23286   }
23287
23288   jresult = result;
23289   return jresult;
23290 }
23291
23292
23293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23294   void * jresult ;
23295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23296   unsigned int arg2 ;
23297   Dali::Renderer result;
23298
23299   arg1 = (Dali::Actor *)jarg1;
23300   arg2 = (unsigned int)jarg2;
23301   {
23302     try {
23303       result = (arg1)->GetRendererAt(arg2);
23304     } CALL_CATCH_EXCEPTION(0);
23305   }
23306
23307   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23314   Dali::Renderer *arg2 = 0 ;
23315
23316   arg1 = (Dali::Actor *)jarg1;
23317   arg2 = (Dali::Renderer *)jarg2;
23318   if (!arg2) {
23319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23320     return ;
23321   }
23322   {
23323     try {
23324       (arg1)->RemoveRenderer(*arg2);
23325     } CALL_CATCH_EXCEPTION();
23326   }
23327
23328 }
23329
23330
23331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23333   unsigned int arg2 ;
23334
23335   arg1 = (Dali::Actor *)jarg1;
23336   arg2 = (unsigned int)jarg2;
23337   {
23338     try {
23339       (arg1)->RemoveRenderer(arg2);
23340     } CALL_CATCH_EXCEPTION();
23341   }
23342
23343 }
23344
23345
23346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23347   void * jresult ;
23348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23349   Dali::Actor::TouchEventSignalType *result = 0 ;
23350
23351   arg1 = (Dali::Actor *)jarg1;
23352   {
23353     try {
23354       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
23355     } CALL_CATCH_EXCEPTION(0);
23356   }
23357
23358   jresult = (void *)result;
23359   return jresult;
23360 }
23361
23362
23363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23364   void * jresult ;
23365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23366   Dali::Actor::HoverSignalType *result = 0 ;
23367
23368   arg1 = (Dali::Actor *)jarg1;
23369   {
23370     try {
23371       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23372     } CALL_CATCH_EXCEPTION(0);
23373   }
23374
23375   jresult = (void *)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23381   void * jresult ;
23382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23383   Dali::Actor::WheelEventSignalType *result = 0 ;
23384
23385   arg1 = (Dali::Actor *)jarg1;
23386   {
23387     try {
23388       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23389     } CALL_CATCH_EXCEPTION(0);
23390   }
23391
23392   jresult = (void *)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23398   void * jresult ;
23399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23400   Dali::Actor::OnSceneSignalType *result = 0 ;
23401
23402   arg1 = (Dali::Actor *)jarg1;
23403   {
23404     try {
23405       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23406     } CALL_CATCH_EXCEPTION(0);
23407   }
23408
23409   jresult = (void *)result;
23410   return jresult;
23411 }
23412
23413
23414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23415   void * jresult ;
23416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23417   Dali::Actor::OffSceneSignalType *result = 0 ;
23418
23419   arg1 = (Dali::Actor *)jarg1;
23420   {
23421     try {
23422       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23423     } CALL_CATCH_EXCEPTION(0);
23424   }
23425
23426   jresult = (void *)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23432   void * jresult ;
23433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23434   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23435
23436   arg1 = (Dali::Actor *)jarg1;
23437   {
23438     try {
23439       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23440     } CALL_CATCH_EXCEPTION(0);
23441   }
23442
23443   jresult = (void *)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23449   Dali::Actor *arg1 = 0 ;
23450
23451   arg1 = (Dali::Actor *)jarg1;
23452   if (!arg1) {
23453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23454     return ;
23455   }
23456   {
23457     try {
23458       Dali::UnparentAndReset(*arg1);
23459     } CALL_CATCH_EXCEPTION();
23460   }
23461
23462 }
23463
23464
23465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23466   int jresult ;
23467   int result;
23468
23469   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23470   jresult = (int)result;
23471   return jresult;
23472 }
23473
23474
23475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23476   int jresult ;
23477   int result;
23478
23479   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23480   jresult = (int)result;
23481   return jresult;
23482 }
23483
23484
23485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23486   int jresult ;
23487   int result;
23488
23489   result = (int)Dali::Layer::Property::BEHAVIOR;
23490   jresult = (int)result;
23491   return jresult;
23492 }
23493
23494
23495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23496   void * jresult ;
23497   Dali::Layer::Property *result = 0 ;
23498
23499   {
23500     try {
23501       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23502     } CALL_CATCH_EXCEPTION(0);
23503   }
23504
23505   jresult = (void *)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23511   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23512
23513   arg1 = (Dali::Layer::Property *)jarg1;
23514   {
23515     try {
23516       delete arg1;
23517     } CALL_CATCH_EXCEPTION();
23518   }
23519
23520 }
23521
23522
23523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23524   void * jresult ;
23525   Dali::Layer *result = 0 ;
23526
23527   {
23528     try {
23529       result = (Dali::Layer *)new Dali::Layer();
23530     } CALL_CATCH_EXCEPTION(0);
23531   }
23532
23533   jresult = (void *)result;
23534   return jresult;
23535 }
23536
23537
23538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23539   void * jresult ;
23540   Dali::Layer result;
23541
23542   {
23543     try {
23544       result = Dali::Layer::New();
23545     } CALL_CATCH_EXCEPTION(0);
23546   }
23547
23548   jresult = new Dali::Layer((const Dali::Layer &)result);
23549   return jresult;
23550 }
23551
23552
23553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23554   void * jresult ;
23555   Dali::BaseHandle arg1 ;
23556   Dali::BaseHandle *argp1 ;
23557   Dali::Layer result;
23558
23559   argp1 = (Dali::BaseHandle *)jarg1;
23560   if (!argp1) {
23561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23562     return 0;
23563   }
23564   arg1 = *argp1;
23565   {
23566     try {
23567       result = Dali::Layer::DownCast(arg1);
23568     } CALL_CATCH_EXCEPTION(0);
23569   }
23570
23571   jresult = new Dali::Layer((const Dali::Layer &)result);
23572   return jresult;
23573 }
23574
23575
23576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23577   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23578
23579   arg1 = (Dali::Layer *)jarg1;
23580   {
23581     try {
23582       delete arg1;
23583     } CALL_CATCH_EXCEPTION();
23584   }
23585
23586 }
23587
23588
23589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23590   void * jresult ;
23591   Dali::Layer *arg1 = 0 ;
23592   Dali::Layer *result = 0 ;
23593
23594   arg1 = (Dali::Layer *)jarg1;
23595   if (!arg1) {
23596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23597     return 0;
23598   }
23599   {
23600     try {
23601       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23602     } CALL_CATCH_EXCEPTION(0);
23603   }
23604
23605   jresult = (void *)result;
23606   return jresult;
23607 }
23608
23609
23610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23611   void * jresult ;
23612   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23613   Dali::Layer *arg2 = 0 ;
23614   Dali::Layer *result = 0 ;
23615
23616   arg1 = (Dali::Layer *)jarg1;
23617   arg2 = (Dali::Layer *)jarg2;
23618   if (!arg2) {
23619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23620     return 0;
23621   }
23622   {
23623     try {
23624       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23625     } CALL_CATCH_EXCEPTION(0);
23626   }
23627
23628   jresult = (void *)result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23634   unsigned int jresult ;
23635   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23636   unsigned int result;
23637
23638   arg1 = (Dali::Layer *)jarg1;
23639   {
23640     try {
23641       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23642     } CALL_CATCH_EXCEPTION(0);
23643   }
23644
23645   jresult = result;
23646   return jresult;
23647 }
23648
23649
23650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23651   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23652
23653   arg1 = (Dali::Layer *)jarg1;
23654   {
23655     try {
23656       (arg1)->Raise();
23657     } CALL_CATCH_EXCEPTION();
23658   }
23659
23660 }
23661
23662
23663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23664   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23665
23666   arg1 = (Dali::Layer *)jarg1;
23667   {
23668     try {
23669       (arg1)->Lower();
23670     } CALL_CATCH_EXCEPTION();
23671   }
23672
23673 }
23674
23675
23676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23677   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23678   Dali::Layer arg2 ;
23679   Dali::Layer *argp2 ;
23680
23681   arg1 = (Dali::Layer *)jarg1;
23682   argp2 = (Dali::Layer *)jarg2;
23683   if (!argp2) {
23684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23685     return ;
23686   }
23687   arg2 = *argp2;
23688   {
23689     try {
23690       (arg1)->RaiseAbove(arg2);
23691     } CALL_CATCH_EXCEPTION();
23692   }
23693
23694 }
23695
23696
23697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23698   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23699   Dali::Layer arg2 ;
23700   Dali::Layer *argp2 ;
23701
23702   arg1 = (Dali::Layer *)jarg1;
23703   argp2 = (Dali::Layer *)jarg2;
23704   if (!argp2) {
23705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23706     return ;
23707   }
23708   arg2 = *argp2;
23709   {
23710     try {
23711       (arg1)->LowerBelow(arg2);
23712     } CALL_CATCH_EXCEPTION();
23713   }
23714
23715 }
23716
23717
23718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23720
23721   arg1 = (Dali::Layer *)jarg1;
23722   {
23723     try {
23724       (arg1)->RaiseToTop();
23725     } CALL_CATCH_EXCEPTION();
23726   }
23727
23728 }
23729
23730
23731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23732   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23733
23734   arg1 = (Dali::Layer *)jarg1;
23735   {
23736     try {
23737       (arg1)->LowerToBottom();
23738     } CALL_CATCH_EXCEPTION();
23739   }
23740
23741 }
23742
23743
23744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23745   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23746   Dali::Layer arg2 ;
23747   Dali::Layer *argp2 ;
23748
23749   arg1 = (Dali::Layer *)jarg1;
23750   argp2 = (Dali::Layer *)jarg2;
23751   if (!argp2) {
23752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23753     return ;
23754   }
23755   arg2 = *argp2;
23756   {
23757     try {
23758       (arg1)->MoveAbove(arg2);
23759     } CALL_CATCH_EXCEPTION();
23760   }
23761
23762 }
23763
23764
23765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23766   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23767   Dali::Layer arg2 ;
23768   Dali::Layer *argp2 ;
23769
23770   arg1 = (Dali::Layer *)jarg1;
23771   argp2 = (Dali::Layer *)jarg2;
23772   if (!argp2) {
23773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23774     return ;
23775   }
23776   arg2 = *argp2;
23777   {
23778     try {
23779       (arg1)->MoveBelow(arg2);
23780     } CALL_CATCH_EXCEPTION();
23781   }
23782
23783 }
23784
23785
23786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23787   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23788   Dali::Layer::Behavior arg2 ;
23789
23790   arg1 = (Dali::Layer *)jarg1;
23791   arg2 = (Dali::Layer::Behavior)jarg2;
23792   {
23793     try {
23794       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23795     } CALL_CATCH_EXCEPTION();
23796   }
23797
23798 }
23799
23800
23801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23802   int jresult ;
23803   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23804   Dali::Layer::Behavior result;
23805
23806   arg1 = (Dali::Layer *)jarg1;
23807   {
23808     try {
23809       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23810     } CALL_CATCH_EXCEPTION(0);
23811   }
23812
23813   jresult = (int)result;
23814   return jresult;
23815 }
23816
23817
23818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23819   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23820   bool arg2 ;
23821
23822   arg1 = (Dali::Layer *)jarg1;
23823   arg2 = jarg2 ? true : false;
23824   {
23825     try {
23826       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23827     } CALL_CATCH_EXCEPTION();
23828   }
23829
23830 }
23831
23832
23833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23834   unsigned int jresult ;
23835   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23836   bool result;
23837
23838   arg1 = (Dali::Layer *)jarg1;
23839   {
23840     try {
23841       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23842     } CALL_CATCH_EXCEPTION(0);
23843   }
23844
23845   jresult = result;
23846   return jresult;
23847 }
23848
23849
23850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23851   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23852   int arg2 ;
23853   int arg3 ;
23854   int arg4 ;
23855   int arg5 ;
23856
23857   arg1 = (Dali::Layer *)jarg1;
23858   arg2 = (int)jarg2;
23859   arg3 = (int)jarg3;
23860   arg4 = (int)jarg4;
23861   arg5 = (int)jarg5;
23862   {
23863     try {
23864       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23865     } CALL_CATCH_EXCEPTION();
23866   }
23867
23868 }
23869
23870
23871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23872   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23873   Dali::ClippingBox arg2 ;
23874   Dali::ClippingBox *argp2 ;
23875
23876   arg1 = (Dali::Layer *)jarg1;
23877   argp2 = (Dali::ClippingBox *)jarg2;
23878   if (!argp2) {
23879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23880     return ;
23881   }
23882   arg2 = *argp2;
23883   {
23884     try {
23885       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23886     } CALL_CATCH_EXCEPTION();
23887   }
23888
23889 }
23890
23891
23892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23893   void * jresult ;
23894   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23895   Dali::ClippingBox result;
23896
23897   arg1 = (Dali::Layer *)jarg1;
23898   {
23899     try {
23900       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23901     } CALL_CATCH_EXCEPTION(0);
23902   }
23903
23904   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23905   return jresult;
23906 }
23907
23908
23909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23910   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23911   bool arg2 ;
23912
23913   arg1 = (Dali::Layer *)jarg1;
23914   arg2 = jarg2 ? true : false;
23915   {
23916     try {
23917       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23918     } CALL_CATCH_EXCEPTION();
23919   }
23920
23921 }
23922
23923
23924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23925   unsigned int jresult ;
23926   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23927   bool result;
23928
23929   arg1 = (Dali::Layer *)jarg1;
23930   {
23931     try {
23932       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23933     } CALL_CATCH_EXCEPTION(0);
23934   }
23935
23936   jresult = result;
23937   return jresult;
23938 }
23939
23940
23941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23942   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23943   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23944
23945   arg1 = (Dali::Layer *)jarg1;
23946   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23947   {
23948     try {
23949       (arg1)->SetSortFunction(arg2);
23950     } CALL_CATCH_EXCEPTION();
23951   }
23952
23953 }
23954
23955
23956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23957   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23958   bool arg2 ;
23959
23960   arg1 = (Dali::Layer *)jarg1;
23961   arg2 = jarg2 ? true : false;
23962   {
23963     try {
23964       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
23965     } CALL_CATCH_EXCEPTION();
23966   }
23967
23968 }
23969
23970
23971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
23972   unsigned int jresult ;
23973   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23974   bool result;
23975
23976   arg1 = (Dali::Layer *)jarg1;
23977   {
23978     try {
23979       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
23980     } CALL_CATCH_EXCEPTION(0);
23981   }
23982
23983   jresult = result;
23984   return jresult;
23985 }
23986
23987
23988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
23989   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23990   bool arg2 ;
23991
23992   arg1 = (Dali::Layer *)jarg1;
23993   arg2 = jarg2 ? true : false;
23994   {
23995     try {
23996       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
23997     } CALL_CATCH_EXCEPTION();
23998   }
23999
24000 }
24001
24002
24003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24004   unsigned int jresult ;
24005   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24006   bool result;
24007
24008   arg1 = (Dali::Layer *)jarg1;
24009   {
24010     try {
24011       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24012     } CALL_CATCH_EXCEPTION(0);
24013   }
24014
24015   jresult = result;
24016   return jresult;
24017 }
24018
24019
24020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24021   void * jresult ;
24022   Dali::Stage result;
24023
24024   {
24025     try {
24026       result = Dali::Stage::GetCurrent();
24027     } CALL_CATCH_EXCEPTION(0);
24028   }
24029
24030   jresult = new Dali::Stage((const Dali::Stage &)result);
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24036   unsigned int jresult ;
24037   bool result;
24038
24039   {
24040     try {
24041       result = (bool)Dali::Stage::IsInstalled();
24042     } CALL_CATCH_EXCEPTION(0);
24043   }
24044
24045   jresult = result;
24046   return jresult;
24047 }
24048
24049
24050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24051   void * jresult ;
24052   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24053   Dali::Vector2 result;
24054
24055   arg1 = (Dali::Stage *)jarg1;
24056   {
24057     try {
24058       result = ((Dali::Stage const *)arg1)->GetDpi();
24059     } CALL_CATCH_EXCEPTION(0);
24060   }
24061
24062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24063   return jresult;
24064 }
24065
24066
24067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24069   float arg2 ;
24070
24071   arg1 = (Dali::Stage *)jarg1;
24072   arg2 = (float)jarg2;
24073   {
24074     try {
24075       (arg1)->KeepRendering(arg2);
24076     } CALL_CATCH_EXCEPTION();
24077   }
24078
24079 }
24080
24081
24082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24083   void * jresult ;
24084   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24085   Dali::Stage::KeyEventSignalType *result = 0 ;
24086
24087   arg1 = (Dali::Stage *)jarg1;
24088   {
24089     try {
24090       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24091     } CALL_CATCH_EXCEPTION(0);
24092   }
24093
24094   jresult = (void *)result;
24095   return jresult;
24096 }
24097
24098
24099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24100   void * jresult ;
24101   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24102   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24103
24104   arg1 = (Dali::Stage *)jarg1;
24105   {
24106     try {
24107       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24108     } CALL_CATCH_EXCEPTION(0);
24109   }
24110
24111   jresult = (void *)result;
24112   return jresult;
24113 }
24114
24115
24116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24117   void * jresult ;
24118   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24119   Dali::Stage::TouchEventSignalType *result = 0 ;
24120
24121   arg1 = (Dali::Stage *)jarg1;
24122   {
24123     try {
24124       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
24125     } CALL_CATCH_EXCEPTION(0);
24126   }
24127
24128   jresult = (void *)result;
24129   return jresult;
24130 }
24131
24132
24133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24134   void * jresult ;
24135   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24136   Dali::Stage::WheelEventSignalType *result = 0 ;
24137
24138   arg1 = (Dali::Stage *)jarg1;
24139   {
24140     try {
24141       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24142     } CALL_CATCH_EXCEPTION(0);
24143   }
24144
24145   jresult = (void *)result;
24146   return jresult;
24147 }
24148
24149
24150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24151   void * jresult ;
24152   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24153   Dali::Stage::ContextStatusSignal *result = 0 ;
24154
24155   arg1 = (Dali::Stage *)jarg1;
24156   {
24157     try {
24158       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24159     } CALL_CATCH_EXCEPTION(0);
24160   }
24161
24162   jresult = (void *)result;
24163   return jresult;
24164 }
24165
24166
24167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
24168   void * jresult ;
24169   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24170   Dali::Stage::ContextStatusSignal *result = 0 ;
24171
24172   arg1 = (Dali::Stage *)jarg1;
24173   {
24174     try {
24175       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
24176     } CALL_CATCH_EXCEPTION(0);
24177   }
24178
24179   jresult = (void *)result;
24180   return jresult;
24181 }
24182
24183
24184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24185   void * jresult ;
24186   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24187   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24188
24189   arg1 = (Dali::Stage *)jarg1;
24190   {
24191     try {
24192       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24193     } CALL_CATCH_EXCEPTION(0);
24194   }
24195
24196   jresult = (void *)result;
24197   return jresult;
24198 }
24199
24200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24201   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24202   Dali::DevelStage::Rendering arg2 ;
24203
24204   arg1 = (Dali::Stage *)jarg1;
24205   arg2 = (Dali::DevelStage::Rendering)jarg2;
24206   {
24207     try {
24208       DevelStage::SetRenderingBehavior(*arg1,arg2);
24209     } CALL_CATCH_EXCEPTION();
24210   }
24211
24212 }
24213
24214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24215
24216   int jresult ;
24217   int result ;
24218   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24219
24220   arg1 = (Dali::Stage *)jarg1;
24221   {
24222     try {
24223       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24224     } CALL_CATCH_EXCEPTION(0);
24225   }
24226
24227   jresult = result;
24228   return jresult;
24229 }
24230
24231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24232   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24233
24234   arg1 = (Dali::RelayoutContainer *)jarg1;
24235   {
24236     try {
24237       delete arg1;
24238     } CALL_CATCH_EXCEPTION();
24239   }
24240
24241 }
24242
24243
24244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24245   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24246   Dali::Actor *arg2 = 0 ;
24247   Dali::Vector2 *arg3 = 0 ;
24248
24249   arg1 = (Dali::RelayoutContainer *)jarg1;
24250   arg2 = (Dali::Actor *)jarg2;
24251   if (!arg2) {
24252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24253     return ;
24254   }
24255   arg3 = (Dali::Vector2 *)jarg3;
24256   if (!arg3) {
24257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24258     return ;
24259   }
24260   {
24261     try {
24262       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24263     } CALL_CATCH_EXCEPTION();
24264   }
24265
24266 }
24267
24268
24269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24270   void * jresult ;
24271   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24272   Dali::CustomActor result;
24273
24274   arg1 = (Dali::CustomActorImpl *)jarg1;
24275   {
24276     try {
24277       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24278     } CALL_CATCH_EXCEPTION(0);
24279   }
24280
24281   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24282   return jresult;
24283 }
24284
24285
24286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24287   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24288   int arg2 ;
24289
24290   arg1 = (Dali::CustomActorImpl *)jarg1;
24291   arg2 = (int)jarg2;
24292   {
24293     try {
24294       (arg1)->OnSceneConnection(arg2);
24295     } CALL_CATCH_EXCEPTION();
24296   }
24297
24298 }
24299
24300
24301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24302   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24303
24304   arg1 = (Dali::CustomActorImpl *)jarg1;
24305   {
24306     try {
24307       (arg1)->OnSceneDisconnection();
24308     } CALL_CATCH_EXCEPTION();
24309   }
24310
24311 }
24312
24313
24314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
24315   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24316   Dali::Actor *arg2 = 0 ;
24317
24318   arg1 = (Dali::CustomActorImpl *)jarg1;
24319   arg2 = (Dali::Actor *)jarg2;
24320   if (!arg2) {
24321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24322     return ;
24323   }
24324   {
24325     try {
24326       (arg1)->OnChildAdd(*arg2);
24327     } CALL_CATCH_EXCEPTION();
24328   }
24329
24330 }
24331
24332
24333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24334   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24335   Dali::Actor *arg2 = 0 ;
24336
24337   arg1 = (Dali::CustomActorImpl *)jarg1;
24338   arg2 = (Dali::Actor *)jarg2;
24339   if (!arg2) {
24340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24341     return ;
24342   }
24343   {
24344     try {
24345       (arg1)->OnChildRemove(*arg2);
24346     } CALL_CATCH_EXCEPTION();
24347   }
24348
24349 }
24350
24351
24352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24353   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24354   Dali::Property::Index arg2 ;
24355   Dali::Property::Value arg3 ;
24356   Dali::Property::Value *argp3 ;
24357
24358   arg1 = (Dali::CustomActorImpl *)jarg1;
24359   arg2 = (Dali::Property::Index)jarg2;
24360   argp3 = (Dali::Property::Value *)jarg3;
24361   if (!argp3) {
24362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24363     return ;
24364   }
24365   arg3 = *argp3;
24366   {
24367     try {
24368       (arg1)->OnPropertySet(arg2,arg3);
24369     } CALL_CATCH_EXCEPTION();
24370   }
24371
24372 }
24373
24374
24375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24376   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24377   Dali::Vector3 *arg2 = 0 ;
24378
24379   arg1 = (Dali::CustomActorImpl *)jarg1;
24380   arg2 = (Dali::Vector3 *)jarg2;
24381   if (!arg2) {
24382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24383     return ;
24384   }
24385   {
24386     try {
24387       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24388     } CALL_CATCH_EXCEPTION();
24389   }
24390
24391 }
24392
24393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24394   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24395   Dali::Animation *arg2 = 0 ;
24396   Dali::Vector3 *arg3 = 0 ;
24397
24398   arg1 = (Dali::CustomActorImpl *)jarg1;
24399   arg2 = (Dali::Animation *)jarg2;
24400   if (!arg2) {
24401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24402     return ;
24403   }
24404   arg3 = (Dali::Vector3 *)jarg3;
24405   if (!arg3) {
24406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24407     return ;
24408   }
24409   {
24410     try {
24411       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24412     } CALL_CATCH_EXCEPTION();
24413   }
24414 }
24415
24416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24417   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24418   Dali::Vector2 *arg2 = 0 ;
24419   Dali::RelayoutContainer *arg3 = 0 ;
24420
24421   arg1 = (Dali::CustomActorImpl *)jarg1;
24422   arg2 = (Dali::Vector2 *)jarg2;
24423   if (!arg2) {
24424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24425     return ;
24426   }
24427   arg3 = (Dali::RelayoutContainer *)jarg3;
24428   if (!arg3) {
24429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24430     return ;
24431   }
24432   {
24433     try {
24434       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24435     } CALL_CATCH_EXCEPTION();
24436   }
24437
24438 }
24439
24440
24441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24442   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24443   Dali::ResizePolicy::Type arg2 ;
24444   Dali::Dimension::Type arg3 ;
24445
24446   arg1 = (Dali::CustomActorImpl *)jarg1;
24447   arg2 = (Dali::ResizePolicy::Type)jarg2;
24448   arg3 = (Dali::Dimension::Type)jarg3;
24449   {
24450     try {
24451       (arg1)->OnSetResizePolicy(arg2,arg3);
24452     } CALL_CATCH_EXCEPTION();
24453   }
24454
24455 }
24456
24457
24458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24459   void * jresult ;
24460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24461   Dali::Vector3 result;
24462
24463   arg1 = (Dali::CustomActorImpl *)jarg1;
24464   {
24465     try {
24466       result = (arg1)->GetNaturalSize();
24467     } CALL_CATCH_EXCEPTION(0);
24468   }
24469
24470   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24471   return jresult;
24472 }
24473
24474
24475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24476   float jresult ;
24477   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24478   Dali::Actor *arg2 = 0 ;
24479   Dali::Dimension::Type arg3 ;
24480   float result;
24481
24482   arg1 = (Dali::CustomActorImpl *)jarg1;
24483   arg2 = (Dali::Actor *)jarg2;
24484   if (!arg2) {
24485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24486     return 0;
24487   }
24488   arg3 = (Dali::Dimension::Type)jarg3;
24489   {
24490     try {
24491       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24492     } CALL_CATCH_EXCEPTION(0);
24493   }
24494
24495   jresult = result;
24496   return jresult;
24497 }
24498
24499
24500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24501   float jresult ;
24502   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24503   float arg2 ;
24504   float result;
24505
24506   arg1 = (Dali::CustomActorImpl *)jarg1;
24507   arg2 = (float)jarg2;
24508   {
24509     try {
24510       result = (float)(arg1)->GetHeightForWidth(arg2);
24511     } CALL_CATCH_EXCEPTION(0);
24512   }
24513
24514   jresult = result;
24515   return jresult;
24516 }
24517
24518
24519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24520   float jresult ;
24521   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24522   float arg2 ;
24523   float result;
24524
24525   arg1 = (Dali::CustomActorImpl *)jarg1;
24526   arg2 = (float)jarg2;
24527   {
24528     try {
24529       result = (float)(arg1)->GetWidthForHeight(arg2);
24530     } CALL_CATCH_EXCEPTION(0);
24531   }
24532
24533   jresult = result;
24534   return jresult;
24535 }
24536
24537
24538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24539   unsigned int jresult ;
24540   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24541   Dali::Dimension::Type arg2 ;
24542   bool result;
24543
24544   arg1 = (Dali::CustomActorImpl *)jarg1;
24545   arg2 = (Dali::Dimension::Type)jarg2;
24546   {
24547     try {
24548       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24549     } CALL_CATCH_EXCEPTION(0);
24550   }
24551
24552   jresult = result;
24553   return jresult;
24554 }
24555
24556
24557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24558   unsigned int jresult ;
24559   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24560   bool result;
24561
24562   arg1 = (Dali::CustomActorImpl *)jarg1;
24563   {
24564     try {
24565       result = (bool)(arg1)->RelayoutDependentOnChildren();
24566     } CALL_CATCH_EXCEPTION(0);
24567   }
24568
24569   jresult = result;
24570   return jresult;
24571 }
24572
24573
24574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24575   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24576   Dali::Dimension::Type arg2 ;
24577
24578   arg1 = (Dali::CustomActorImpl *)jarg1;
24579   arg2 = (Dali::Dimension::Type)jarg2;
24580   {
24581     try {
24582       (arg1)->OnCalculateRelayoutSize(arg2);
24583     } CALL_CATCH_EXCEPTION();
24584   }
24585
24586 }
24587
24588
24589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24590   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24591   float arg2 ;
24592   Dali::Dimension::Type arg3 ;
24593
24594   arg1 = (Dali::CustomActorImpl *)jarg1;
24595   arg2 = (float)jarg2;
24596   arg3 = (Dali::Dimension::Type)jarg3;
24597   {
24598     try {
24599       (arg1)->OnLayoutNegotiated(arg2,arg3);
24600     } CALL_CATCH_EXCEPTION();
24601   }
24602
24603 }
24604
24605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
24606   unsigned int jresult ;
24607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24608   bool result;
24609
24610   arg1 = (Dali::CustomActorImpl *)jarg1;
24611   {
24612     try {
24613       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
24614     } CALL_CATCH_EXCEPTION(0);
24615   }
24616
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24622   void * jresult ;
24623   Dali::CustomActor *result = 0 ;
24624
24625   {
24626     try {
24627       result = (Dali::CustomActor *)new Dali::CustomActor();
24628     } CALL_CATCH_EXCEPTION(0);
24629   }
24630
24631   jresult = (void *)result;
24632   return jresult;
24633 }
24634
24635
24636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24637   void * jresult ;
24638   Dali::BaseHandle arg1 ;
24639   Dali::BaseHandle *argp1 ;
24640   Dali::CustomActor result;
24641
24642   argp1 = (Dali::BaseHandle *)jarg1;
24643   if (!argp1) {
24644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24645     return 0;
24646   }
24647   arg1 = *argp1;
24648   {
24649     try {
24650       result = Dali::CustomActor::DownCast(arg1);
24651     } CALL_CATCH_EXCEPTION(0);
24652   }
24653
24654   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24660   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24661
24662   arg1 = (Dali::CustomActor *)jarg1;
24663   {
24664     try {
24665       delete arg1;
24666     } CALL_CATCH_EXCEPTION();
24667   }
24668
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24673   void * jresult ;
24674   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24675   Dali::CustomActorImpl *result = 0 ;
24676
24677   arg1 = (Dali::CustomActor *)jarg1;
24678   {
24679     try {
24680       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24681     } CALL_CATCH_EXCEPTION(0);
24682   }
24683
24684   jresult = (void *)result;
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24690   void * jresult ;
24691   Dali::CustomActorImpl *arg1 = 0 ;
24692   Dali::CustomActor *result = 0 ;
24693
24694   arg1 = (Dali::CustomActorImpl *)jarg1;
24695   if (!arg1) {
24696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24697     return 0;
24698   }
24699   {
24700     try {
24701       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24702     } CALL_CATCH_EXCEPTION(0);
24703   }
24704
24705   jresult = (void *)result;
24706   return jresult;
24707 }
24708
24709
24710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24711   void * jresult ;
24712   Dali::CustomActor *arg1 = 0 ;
24713   Dali::CustomActor *result = 0 ;
24714
24715   arg1 = (Dali::CustomActor *)jarg1;
24716   if (!arg1) {
24717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24718     return 0;
24719   }
24720   {
24721     try {
24722       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24723     } CALL_CATCH_EXCEPTION(0);
24724   }
24725
24726   jresult = (void *)result;
24727   return jresult;
24728 }
24729
24730
24731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24732   void * jresult ;
24733   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24734   Dali::CustomActor *arg2 = 0 ;
24735   Dali::CustomActor *result = 0 ;
24736
24737   arg1 = (Dali::CustomActor *)jarg1;
24738   arg2 = (Dali::CustomActor *)jarg2;
24739   if (!arg2) {
24740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24741     return 0;
24742   }
24743   {
24744     try {
24745       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24746     } CALL_CATCH_EXCEPTION(0);
24747   }
24748
24749   jresult = (void *)result;
24750   return jresult;
24751 }
24752
24753
24754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24755   int jresult ;
24756   int result;
24757
24758   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24759   jresult = (int)result;
24760   return jresult;
24761 }
24762
24763
24764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24765   int jresult ;
24766   int result;
24767
24768   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24769   jresult = (int)result;
24770   return jresult;
24771 }
24772
24773
24774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24775   int jresult ;
24776   int result;
24777
24778   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24779   jresult = (int)result;
24780   return jresult;
24781 }
24782
24783
24784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24785   int jresult ;
24786   int result;
24787
24788   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24789   jresult = (int)result;
24790   return jresult;
24791 }
24792
24793
24794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24795   int jresult ;
24796   int result;
24797
24798   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24799   jresult = (int)result;
24800   return jresult;
24801 }
24802
24803
24804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24805   int jresult ;
24806   int result;
24807
24808   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24809   jresult = (int)result;
24810   return jresult;
24811 }
24812
24813
24814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24815   int jresult ;
24816   int result;
24817
24818   result = (int)Dali::PanGestureDetector::Property::PANNING;
24819   jresult = (int)result;
24820   return jresult;
24821 }
24822
24823
24824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24825   void * jresult ;
24826   Dali::PanGestureDetector::Property *result = 0 ;
24827
24828   {
24829     try {
24830       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24831     } CALL_CATCH_EXCEPTION(0);
24832   }
24833
24834   jresult = (void *)result;
24835   return jresult;
24836 }
24837
24838
24839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
24840   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
24841
24842   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
24843   {
24844     try {
24845       delete arg1;
24846     } CALL_CATCH_EXCEPTION();
24847   }
24848
24849 }
24850
24851
24852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
24853   void * jresult ;
24854   Dali::Radian *result = 0 ;
24855
24856   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
24857   jresult = (void *)result;
24858   return jresult;
24859 }
24860
24861
24862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
24863   void * jresult ;
24864   Dali::Radian *result = 0 ;
24865
24866   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
24867   jresult = (void *)result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
24873   void * jresult ;
24874   Dali::Radian *result = 0 ;
24875
24876   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
24877   jresult = (void *)result;
24878   return jresult;
24879 }
24880
24881
24882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
24883   void * jresult ;
24884   Dali::Radian *result = 0 ;
24885
24886   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
24887   jresult = (void *)result;
24888   return jresult;
24889 }
24890
24891
24892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
24893   void * jresult ;
24894   Dali::Radian *result = 0 ;
24895
24896   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
24897   jresult = (void *)result;
24898   return jresult;
24899 }
24900
24901
24902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
24903   void * jresult ;
24904   Dali::Radian *result = 0 ;
24905
24906   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
24907   jresult = (void *)result;
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
24913   void * jresult ;
24914   Dali::Radian *result = 0 ;
24915
24916   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
24917   jresult = (void *)result;
24918   return jresult;
24919 }
24920
24921
24922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
24923   void * jresult ;
24924   Dali::PanGestureDetector *result = 0 ;
24925
24926   {
24927     try {
24928       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
24929     } CALL_CATCH_EXCEPTION(0);
24930   }
24931
24932   jresult = (void *)result;
24933   return jresult;
24934 }
24935
24936
24937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
24938   void * jresult ;
24939   Dali::PanGestureDetector result;
24940
24941   {
24942     try {
24943       result = Dali::PanGestureDetector::New();
24944     } CALL_CATCH_EXCEPTION(0);
24945   }
24946
24947   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
24948   return jresult;
24949 }
24950
24951
24952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
24953   void * jresult ;
24954   Dali::BaseHandle arg1 ;
24955   Dali::BaseHandle *argp1 ;
24956   Dali::PanGestureDetector result;
24957
24958   argp1 = (Dali::BaseHandle *)jarg1;
24959   if (!argp1) {
24960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24961     return 0;
24962   }
24963   arg1 = *argp1;
24964   {
24965     try {
24966       result = Dali::PanGestureDetector::DownCast(arg1);
24967     } CALL_CATCH_EXCEPTION(0);
24968   }
24969
24970   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
24971   return jresult;
24972 }
24973
24974
24975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
24976   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
24977
24978   arg1 = (Dali::PanGestureDetector *)jarg1;
24979   {
24980     try {
24981       delete arg1;
24982     } CALL_CATCH_EXCEPTION();
24983   }
24984
24985 }
24986
24987
24988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
24989   void * jresult ;
24990   Dali::PanGestureDetector *arg1 = 0 ;
24991   Dali::PanGestureDetector *result = 0 ;
24992
24993   arg1 = (Dali::PanGestureDetector *)jarg1;
24994   if (!arg1) {
24995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
24996     return 0;
24997   }
24998   {
24999     try {
25000       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25001     } CALL_CATCH_EXCEPTION(0);
25002   }
25003
25004   jresult = (void *)result;
25005   return jresult;
25006 }
25007
25008
25009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25010   void * jresult ;
25011   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25012   Dali::PanGestureDetector *arg2 = 0 ;
25013   Dali::PanGestureDetector *result = 0 ;
25014
25015   arg1 = (Dali::PanGestureDetector *)jarg1;
25016   arg2 = (Dali::PanGestureDetector *)jarg2;
25017   if (!arg2) {
25018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25019     return 0;
25020   }
25021   {
25022     try {
25023       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25024     } CALL_CATCH_EXCEPTION(0);
25025   }
25026
25027   jresult = (void *)result;
25028   return jresult;
25029 }
25030
25031
25032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25033   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25034   unsigned int arg2 ;
25035
25036   arg1 = (Dali::PanGestureDetector *)jarg1;
25037   arg2 = (unsigned int)jarg2;
25038   {
25039     try {
25040       (arg1)->SetMinimumTouchesRequired(arg2);
25041     } CALL_CATCH_EXCEPTION();
25042   }
25043
25044 }
25045
25046
25047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25048   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25049   unsigned int arg2 ;
25050
25051   arg1 = (Dali::PanGestureDetector *)jarg1;
25052   arg2 = (unsigned int)jarg2;
25053   {
25054     try {
25055       (arg1)->SetMaximumTouchesRequired(arg2);
25056     } CALL_CATCH_EXCEPTION();
25057   }
25058
25059 }
25060
25061
25062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25063   unsigned int jresult ;
25064   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25065   unsigned int result;
25066
25067   arg1 = (Dali::PanGestureDetector *)jarg1;
25068   {
25069     try {
25070       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25071     } CALL_CATCH_EXCEPTION(0);
25072   }
25073
25074   jresult = result;
25075   return jresult;
25076 }
25077
25078
25079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25080   unsigned int jresult ;
25081   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25082   unsigned int result;
25083
25084   arg1 = (Dali::PanGestureDetector *)jarg1;
25085   {
25086     try {
25087       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25088     } CALL_CATCH_EXCEPTION(0);
25089   }
25090
25091   jresult = result;
25092   return jresult;
25093 }
25094
25095
25096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25097   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25098   Dali::Radian arg2 ;
25099   Dali::Radian arg3 ;
25100   Dali::Radian *argp2 ;
25101   Dali::Radian *argp3 ;
25102
25103   arg1 = (Dali::PanGestureDetector *)jarg1;
25104   argp2 = (Dali::Radian *)jarg2;
25105   if (!argp2) {
25106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25107     return ;
25108   }
25109   arg2 = *argp2;
25110   argp3 = (Dali::Radian *)jarg3;
25111   if (!argp3) {
25112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25113     return ;
25114   }
25115   arg3 = *argp3;
25116   {
25117     try {
25118       (arg1)->AddAngle(arg2,arg3);
25119     } CALL_CATCH_EXCEPTION();
25120   }
25121
25122 }
25123
25124
25125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25126   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25127   Dali::Radian arg2 ;
25128   Dali::Radian *argp2 ;
25129
25130   arg1 = (Dali::PanGestureDetector *)jarg1;
25131   argp2 = (Dali::Radian *)jarg2;
25132   if (!argp2) {
25133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25134     return ;
25135   }
25136   arg2 = *argp2;
25137   {
25138     try {
25139       (arg1)->AddAngle(arg2);
25140     } CALL_CATCH_EXCEPTION();
25141   }
25142
25143 }
25144
25145
25146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25147   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25148   Dali::Radian arg2 ;
25149   Dali::Radian arg3 ;
25150   Dali::Radian *argp2 ;
25151   Dali::Radian *argp3 ;
25152
25153   arg1 = (Dali::PanGestureDetector *)jarg1;
25154   argp2 = (Dali::Radian *)jarg2;
25155   if (!argp2) {
25156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25157     return ;
25158   }
25159   arg2 = *argp2;
25160   argp3 = (Dali::Radian *)jarg3;
25161   if (!argp3) {
25162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25163     return ;
25164   }
25165   arg3 = *argp3;
25166   {
25167     try {
25168       (arg1)->AddDirection(arg2,arg3);
25169     } CALL_CATCH_EXCEPTION();
25170   }
25171
25172 }
25173
25174
25175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25176   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25177   Dali::Radian arg2 ;
25178   Dali::Radian *argp2 ;
25179
25180   arg1 = (Dali::PanGestureDetector *)jarg1;
25181   argp2 = (Dali::Radian *)jarg2;
25182   if (!argp2) {
25183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25184     return ;
25185   }
25186   arg2 = *argp2;
25187   {
25188     try {
25189       (arg1)->AddDirection(arg2);
25190     } CALL_CATCH_EXCEPTION();
25191   }
25192
25193 }
25194
25195
25196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25197   unsigned long jresult ;
25198   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25199   size_t result;
25200
25201   arg1 = (Dali::PanGestureDetector *)jarg1;
25202   {
25203     try {
25204       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25205     } CALL_CATCH_EXCEPTION(0);
25206   }
25207
25208   jresult = (unsigned long)result;
25209   return jresult;
25210 }
25211
25212
25213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25214   void * jresult ;
25215   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25216   size_t arg2 ;
25217   Dali::PanGestureDetector::AngleThresholdPair result;
25218
25219   arg1 = (Dali::PanGestureDetector *)jarg1;
25220   arg2 = (size_t)jarg2;
25221   {
25222     try {
25223       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25224     } CALL_CATCH_EXCEPTION(0);
25225   }
25226
25227   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25228   return jresult;
25229 }
25230
25231
25232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25233   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25234
25235   arg1 = (Dali::PanGestureDetector *)jarg1;
25236   {
25237     try {
25238       (arg1)->ClearAngles();
25239     } CALL_CATCH_EXCEPTION();
25240   }
25241
25242 }
25243
25244
25245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25246   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25247   Dali::Radian arg2 ;
25248   Dali::Radian *argp2 ;
25249
25250   arg1 = (Dali::PanGestureDetector *)jarg1;
25251   argp2 = (Dali::Radian *)jarg2;
25252   if (!argp2) {
25253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25254     return ;
25255   }
25256   arg2 = *argp2;
25257   {
25258     try {
25259       (arg1)->RemoveAngle(arg2);
25260     } CALL_CATCH_EXCEPTION();
25261   }
25262
25263 }
25264
25265
25266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25267   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25268   Dali::Radian arg2 ;
25269   Dali::Radian *argp2 ;
25270
25271   arg1 = (Dali::PanGestureDetector *)jarg1;
25272   argp2 = (Dali::Radian *)jarg2;
25273   if (!argp2) {
25274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25275     return ;
25276   }
25277   arg2 = *argp2;
25278   {
25279     try {
25280       (arg1)->RemoveDirection(arg2);
25281     } CALL_CATCH_EXCEPTION();
25282   }
25283
25284 }
25285
25286
25287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25288   void * jresult ;
25289   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25290   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25291
25292   arg1 = (Dali::PanGestureDetector *)jarg1;
25293   {
25294     try {
25295       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25296     } CALL_CATCH_EXCEPTION(0);
25297   }
25298
25299   jresult = (void *)result;
25300   return jresult;
25301 }
25302
25303
25304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25305   Dali::PanGesture *arg1 = 0 ;
25306
25307   arg1 = (Dali::PanGesture *)jarg1;
25308   if (!arg1) {
25309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25310     return ;
25311   }
25312   {
25313     try {
25314       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25315     } CALL_CATCH_EXCEPTION();
25316   }
25317
25318 }
25319
25320
25321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25322   void * jresult ;
25323   Dali::PanGesture *result = 0 ;
25324
25325   {
25326     try {
25327       result = (Dali::PanGesture *)new Dali::PanGesture();
25328     } CALL_CATCH_EXCEPTION(0);
25329   }
25330
25331   jresult = (void *)result;
25332   return jresult;
25333 }
25334
25335 // Need to delete this
25336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25337   void * jresult ;
25338   Dali::GestureState arg1 ;
25339   Dali::PanGesture *result = 0 ;
25340
25341   arg1 = (Dali::GestureState)jarg1;
25342   {
25343     try {
25344       result = (Dali::PanGesture *)new Dali::PanGesture();
25345     } catch (std::out_of_range& e) {
25346       {
25347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25348       };
25349     } catch (std::exception& e) {
25350       {
25351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25352       };
25353     } catch (Dali::DaliException e) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25360       };
25361     }
25362   }
25363
25364   jresult = (void *)result;
25365   return jresult;
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25370   void * jresult ;
25371   Dali::PanGesture *arg1 = 0 ;
25372   Dali::PanGesture *result = 0 ;
25373
25374   arg1 = (Dali::PanGesture *)jarg1;
25375   if (!arg1) {
25376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25377     return 0;
25378   }
25379   {
25380     try {
25381       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25382     } CALL_CATCH_EXCEPTION(0);
25383   }
25384
25385   jresult = (void *)result;
25386   return jresult;
25387 }
25388
25389
25390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25391   void * jresult ;
25392   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25393   Dali::PanGesture *arg2 = 0 ;
25394   Dali::PanGesture *result = 0 ;
25395
25396   arg1 = (Dali::PanGesture *)jarg1;
25397   arg2 = (Dali::PanGesture *)jarg2;
25398   if (!arg2) {
25399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25400     return 0;
25401   }
25402   {
25403     try {
25404       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25405     } CALL_CATCH_EXCEPTION(0);
25406   }
25407
25408   jresult = (void *)result;
25409   return jresult;
25410 }
25411
25412
25413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25414   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25415
25416   arg1 = (Dali::PanGesture *)jarg1;
25417   {
25418     try {
25419       delete arg1;
25420     } CALL_CATCH_EXCEPTION();
25421   }
25422
25423 }
25424
25425
25426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25427   void * jresult ;
25428   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25429   Dali::Vector2 result;
25430
25431   arg1 = (Dali::PanGesture *)jarg1;
25432   {
25433     try {
25434       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
25435     } catch (std::out_of_range& e) {
25436       {
25437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25438       };
25439     } catch (std::exception& e) {
25440       {
25441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25442       };
25443     } catch (Dali::DaliException e) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25446       };
25447     } catch (...) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25450       };
25451     }
25452   }
25453   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25454   return jresult;
25455 }
25456
25457
25458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25459   void * jresult ;
25460   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25461   Dali::Vector2 result;
25462
25463   arg1 = (Dali::PanGesture *)jarg1;
25464   {
25465     try {
25466       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
25467     } catch (std::out_of_range& e) {
25468       {
25469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25470       };
25471     } catch (std::exception& e) {
25472       {
25473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (Dali::DaliException e) {
25476       {
25477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25478       };
25479     } catch (...) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25482       };
25483     }
25484   }
25485   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25486   return jresult;
25487 }
25488
25489
25490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25491   void * jresult ;
25492   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25493   Dali::Vector2 result;
25494
25495   arg1 = (Dali::PanGesture *)jarg1;
25496   {
25497     try {
25498       result = ((Dali::PanGesture const *)arg1)->GetPosition();
25499     } catch (std::out_of_range& e) {
25500       {
25501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (std::exception& e) {
25504       {
25505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25506       };
25507     } catch (Dali::DaliException e) {
25508       {
25509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25510       };
25511     } catch (...) {
25512       {
25513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25514       };
25515     }
25516   }
25517   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25518   return jresult;
25519 }
25520
25521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25522   void * jresult ;
25523   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25524   Dali::Vector2 result;
25525
25526   arg1 = (Dali::PanGesture *)jarg1;
25527   {
25528     try {
25529       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
25530     } catch (std::out_of_range& e) {
25531       {
25532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25533       };
25534     } catch (std::exception& e) {
25535       {
25536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25537       };
25538     } catch (Dali::DaliException e) {
25539       {
25540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25541       };
25542     } catch (...) {
25543       {
25544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25545       };
25546     }
25547   }
25548   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25549   return jresult;
25550 }
25551
25552
25553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25554   void * jresult ;
25555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25556   Dali::Vector2 result;
25557
25558   arg1 = (Dali::PanGesture *)jarg1;
25559   {
25560     try {
25561       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
25562     } catch (std::out_of_range& e) {
25563       {
25564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25565       };
25566     } catch (std::exception& e) {
25567       {
25568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25569       };
25570     } catch (Dali::DaliException e) {
25571       {
25572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25573       };
25574     } catch (...) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25577       };
25578     }
25579   }
25580   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25581   return jresult;
25582 }
25583
25584
25585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25586   void * jresult ;
25587   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25588   Dali::Vector2 result;
25589
25590   arg1 = (Dali::PanGesture *)jarg1;
25591   {
25592     try {
25593       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
25594     } catch (std::out_of_range& e) {
25595       {
25596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25597       };
25598     } catch (std::exception& e) {
25599       {
25600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25601       };
25602     } catch (Dali::DaliException e) {
25603       {
25604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25605       };
25606     } catch (...) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25609       };
25610     }
25611   }
25612   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25613   return jresult;
25614 }
25615
25616
25617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25618   unsigned int jresult ;
25619   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25620   unsigned int result;
25621
25622   arg1 = (Dali::PanGesture *)jarg1;
25623   result = (unsigned int) ((arg1)->GetNumberOfTouches());
25624   jresult = result;
25625   return jresult;
25626 }
25627
25628
25629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25630   float jresult ;
25631   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25632   float result;
25633
25634   arg1 = (Dali::PanGesture *)jarg1;
25635   {
25636     try {
25637       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25638     } CALL_CATCH_EXCEPTION(0);
25639   }
25640
25641   jresult = result;
25642   return jresult;
25643 }
25644
25645
25646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
25647   float jresult ;
25648   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25649   float result;
25650
25651   arg1 = (Dali::PanGesture *)jarg1;
25652   {
25653     try {
25654       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
25655     } CALL_CATCH_EXCEPTION(0);
25656   }
25657
25658   jresult = result;
25659   return jresult;
25660 }
25661
25662
25663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
25664   float jresult ;
25665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25666   float result;
25667
25668   arg1 = (Dali::PanGesture *)jarg1;
25669   {
25670     try {
25671       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
25672     } CALL_CATCH_EXCEPTION(0);
25673   }
25674
25675   jresult = result;
25676   return jresult;
25677 }
25678
25679
25680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
25681   float jresult ;
25682   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25683   float result;
25684
25685   arg1 = (Dali::PanGesture *)jarg1;
25686   {
25687     try {
25688       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
25689     } CALL_CATCH_EXCEPTION(0);
25690   }
25691
25692   jresult = result;
25693   return jresult;
25694 }
25695
25696
25697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25698   void * jresult ;
25699   Dali::PinchGestureDetector *result = 0 ;
25700
25701   {
25702     try {
25703       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25704     } CALL_CATCH_EXCEPTION(0);
25705   }
25706
25707   jresult = (void *)result;
25708   return jresult;
25709 }
25710
25711
25712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25713   void * jresult ;
25714   Dali::PinchGestureDetector result;
25715
25716   {
25717     try {
25718       result = Dali::PinchGestureDetector::New();
25719     } CALL_CATCH_EXCEPTION(0);
25720   }
25721
25722   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25723   return jresult;
25724 }
25725
25726
25727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25728   void * jresult ;
25729   Dali::BaseHandle arg1 ;
25730   Dali::BaseHandle *argp1 ;
25731   Dali::PinchGestureDetector result;
25732
25733   argp1 = (Dali::BaseHandle *)jarg1;
25734   if (!argp1) {
25735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25736     return 0;
25737   }
25738   arg1 = *argp1;
25739   {
25740     try {
25741       result = Dali::PinchGestureDetector::DownCast(arg1);
25742     } CALL_CATCH_EXCEPTION(0);
25743   }
25744
25745   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25746   return jresult;
25747 }
25748
25749
25750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25751   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25752
25753   arg1 = (Dali::PinchGestureDetector *)jarg1;
25754   {
25755     try {
25756       delete arg1;
25757     } CALL_CATCH_EXCEPTION();
25758   }
25759
25760 }
25761
25762
25763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25764   void * jresult ;
25765   Dali::PinchGestureDetector *arg1 = 0 ;
25766   Dali::PinchGestureDetector *result = 0 ;
25767
25768   arg1 = (Dali::PinchGestureDetector *)jarg1;
25769   if (!arg1) {
25770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25771     return 0;
25772   }
25773   {
25774     try {
25775       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25776     } CALL_CATCH_EXCEPTION(0);
25777   }
25778
25779   jresult = (void *)result;
25780   return jresult;
25781 }
25782
25783
25784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25785   void * jresult ;
25786   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25787   Dali::PinchGestureDetector *arg2 = 0 ;
25788   Dali::PinchGestureDetector *result = 0 ;
25789
25790   arg1 = (Dali::PinchGestureDetector *)jarg1;
25791   arg2 = (Dali::PinchGestureDetector *)jarg2;
25792   if (!arg2) {
25793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25794     return 0;
25795   }
25796   {
25797     try {
25798       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25799     } CALL_CATCH_EXCEPTION(0);
25800   }
25801
25802   jresult = (void *)result;
25803   return jresult;
25804 }
25805
25806
25807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25808   void * jresult ;
25809   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25810   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25811
25812   arg1 = (Dali::PinchGestureDetector *)jarg1;
25813   {
25814     try {
25815       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25816     } CALL_CATCH_EXCEPTION(0);
25817   }
25818
25819   jresult = (void *)result;
25820   return jresult;
25821 }
25822
25823
25824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
25825   void * jresult ;
25826   Dali::PinchGesture *result = 0 ;
25827
25828   {
25829     try {
25830       result = (Dali::PinchGesture *)new Dali::PinchGesture();
25831     } CALL_CATCH_EXCEPTION(0);
25832   }
25833
25834   jresult = (void *)result;
25835   return jresult;
25836 }
25837
25838
25839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25840   void * jresult ;
25841   Dali::PinchGesture *arg1 = 0 ;
25842   Dali::PinchGesture *result = 0 ;
25843
25844   arg1 = (Dali::PinchGesture *)jarg1;
25845   if (!arg1) {
25846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25847     return 0;
25848   }
25849   {
25850     try {
25851       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
25852     } CALL_CATCH_EXCEPTION(0);
25853   }
25854
25855   jresult = (void *)result;
25856   return jresult;
25857 }
25858
25859
25860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
25861   void * jresult ;
25862   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25863   Dali::PinchGesture *arg2 = 0 ;
25864   Dali::PinchGesture *result = 0 ;
25865
25866   arg1 = (Dali::PinchGesture *)jarg1;
25867   arg2 = (Dali::PinchGesture *)jarg2;
25868   if (!arg2) {
25869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25870     return 0;
25871   }
25872   {
25873     try {
25874       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
25875     } CALL_CATCH_EXCEPTION(0);
25876   }
25877
25878   jresult = (void *)result;
25879   return jresult;
25880 }
25881
25882
25883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
25884   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25885
25886   arg1 = (Dali::PinchGesture *)jarg1;
25887   {
25888     try {
25889       delete arg1;
25890     } CALL_CATCH_EXCEPTION();
25891   }
25892
25893 }
25894
25895
25896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
25897   float jresult ;
25898   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25899   float result;
25900
25901   arg1 = (Dali::PinchGesture *)jarg1;
25902   result = (float) ((arg1)->GetScale());
25903   jresult = result;
25904   return jresult;
25905 }
25906
25907
25908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
25909   float jresult ;
25910   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25911   float result;
25912
25913   arg1 = (Dali::PinchGesture *)jarg1;
25914   result = (float) ((arg1)->GetSpeed());
25915   jresult = result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
25921   void * jresult ;
25922   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25923   Dali::Vector2 result;
25924
25925   arg1 = (Dali::PinchGesture *)jarg1;
25926   {
25927     try {
25928       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
25929     } catch (std::out_of_range& e) {
25930       {
25931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25932       };
25933     } catch (std::exception& e) {
25934       {
25935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25936       };
25937     } catch (Dali::DaliException e) {
25938       {
25939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25940       };
25941     } catch (...) {
25942       {
25943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25944       };
25945     }
25946   }
25947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25948   return jresult;
25949 }
25950
25951
25952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
25953   void * jresult ;
25954   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25955   Dali::Vector2 result;
25956
25957   arg1 = (Dali::PinchGesture *)jarg1;
25958   {
25959     try {
25960       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
25961     } catch (std::out_of_range& e) {
25962       {
25963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25964       };
25965     } catch (std::exception& e) {
25966       {
25967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25968       };
25969     } catch (Dali::DaliException e) {
25970       {
25971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25972       };
25973     } catch (...) {
25974       {
25975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25976       };
25977     }
25978   }
25979   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25980   return jresult;
25981 }
25982
25983
25984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
25985   void * jresult ;
25986   Dali::TapGestureDetector *result = 0 ;
25987
25988   {
25989     try {
25990       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
25991     } CALL_CATCH_EXCEPTION(0);
25992   }
25993
25994   jresult = (void *)result;
25995   return jresult;
25996 }
25997
25998
25999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26000   void * jresult ;
26001   Dali::TapGestureDetector result;
26002
26003   {
26004     try {
26005       result = Dali::TapGestureDetector::New();
26006     } CALL_CATCH_EXCEPTION(0);
26007   }
26008
26009   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26010   return jresult;
26011 }
26012
26013
26014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26015   void * jresult ;
26016   unsigned int arg1 ;
26017   Dali::TapGestureDetector result;
26018
26019   arg1 = (unsigned int)jarg1;
26020   {
26021     try {
26022       result = Dali::TapGestureDetector::New(arg1);
26023     } CALL_CATCH_EXCEPTION(0);
26024   }
26025
26026   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26027   return jresult;
26028 }
26029
26030
26031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26032   void * jresult ;
26033   Dali::BaseHandle arg1 ;
26034   Dali::BaseHandle *argp1 ;
26035   Dali::TapGestureDetector result;
26036
26037   argp1 = (Dali::BaseHandle *)jarg1;
26038   if (!argp1) {
26039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26040     return 0;
26041   }
26042   arg1 = *argp1;
26043   {
26044     try {
26045       result = Dali::TapGestureDetector::DownCast(arg1);
26046     } CALL_CATCH_EXCEPTION(0);
26047   }
26048
26049   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26050   return jresult;
26051 }
26052
26053
26054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26055   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26056
26057   arg1 = (Dali::TapGestureDetector *)jarg1;
26058   {
26059     try {
26060       delete arg1;
26061     } CALL_CATCH_EXCEPTION();
26062   }
26063
26064 }
26065
26066
26067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26068   void * jresult ;
26069   Dali::TapGestureDetector *arg1 = 0 ;
26070   Dali::TapGestureDetector *result = 0 ;
26071
26072   arg1 = (Dali::TapGestureDetector *)jarg1;
26073   if (!arg1) {
26074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26075     return 0;
26076   }
26077   {
26078     try {
26079       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26080     } CALL_CATCH_EXCEPTION(0);
26081   }
26082
26083   jresult = (void *)result;
26084   return jresult;
26085 }
26086
26087
26088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26089   void * jresult ;
26090   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26091   Dali::TapGestureDetector *arg2 = 0 ;
26092   Dali::TapGestureDetector *result = 0 ;
26093
26094   arg1 = (Dali::TapGestureDetector *)jarg1;
26095   arg2 = (Dali::TapGestureDetector *)jarg2;
26096   if (!arg2) {
26097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26098     return 0;
26099   }
26100   {
26101     try {
26102       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26103     } CALL_CATCH_EXCEPTION(0);
26104   }
26105
26106   jresult = (void *)result;
26107   return jresult;
26108 }
26109
26110
26111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26112   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26113   unsigned int arg2 ;
26114
26115   arg1 = (Dali::TapGestureDetector *)jarg1;
26116   arg2 = (unsigned int)jarg2;
26117   {
26118     try {
26119       (arg1)->SetMinimumTapsRequired(arg2);
26120     } CALL_CATCH_EXCEPTION();
26121   }
26122
26123 }
26124
26125
26126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26127   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26128   unsigned int arg2 ;
26129
26130   arg1 = (Dali::TapGestureDetector *)jarg1;
26131   arg2 = (unsigned int)jarg2;
26132   {
26133     try {
26134       (arg1)->SetMaximumTapsRequired(arg2);
26135     } CALL_CATCH_EXCEPTION();
26136   }
26137
26138 }
26139
26140
26141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26142   unsigned int jresult ;
26143   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26144   unsigned int result;
26145
26146   arg1 = (Dali::TapGestureDetector *)jarg1;
26147   {
26148     try {
26149       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26150     } CALL_CATCH_EXCEPTION(0);
26151   }
26152
26153   jresult = result;
26154   return jresult;
26155 }
26156
26157
26158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
26159   unsigned int jresult ;
26160   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26161   unsigned int result;
26162
26163   arg1 = (Dali::TapGestureDetector *)jarg1;
26164   {
26165     try {
26166       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
26167     } CALL_CATCH_EXCEPTION(0);
26168   }
26169
26170   jresult = result;
26171   return jresult;
26172 }
26173
26174
26175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26176   void * jresult ;
26177   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26178   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26179
26180   arg1 = (Dali::TapGestureDetector *)jarg1;
26181   {
26182     try {
26183       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26184     } CALL_CATCH_EXCEPTION(0);
26185   }
26186
26187   jresult = (void *)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26193   void * jresult ;
26194   Dali::TapGesture *result = 0 ;
26195
26196   {
26197     try {
26198       result = (Dali::TapGesture *)new Dali::TapGesture();
26199     } CALL_CATCH_EXCEPTION(0);
26200   }
26201
26202   jresult = (void *)result;
26203   return jresult;
26204 }
26205
26206
26207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26208   void * jresult ;
26209   Dali::TapGesture *arg1 = 0 ;
26210   Dali::TapGesture *result = 0 ;
26211
26212   arg1 = (Dali::TapGesture *)jarg1;
26213   if (!arg1) {
26214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26215     return 0;
26216   }
26217   {
26218     try {
26219       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26220     } CALL_CATCH_EXCEPTION(0);
26221   }
26222
26223   jresult = (void *)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26229   void * jresult ;
26230   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26231   Dali::TapGesture *arg2 = 0 ;
26232   Dali::TapGesture *result = 0 ;
26233
26234   arg1 = (Dali::TapGesture *)jarg1;
26235   arg2 = (Dali::TapGesture *)jarg2;
26236   if (!arg2) {
26237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26238     return 0;
26239   }
26240   {
26241     try {
26242       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26243     } CALL_CATCH_EXCEPTION(0);
26244   }
26245
26246   jresult = (void *)result;
26247   return jresult;
26248 }
26249
26250
26251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26252   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26253
26254   arg1 = (Dali::TapGesture *)jarg1;
26255   {
26256     try {
26257       delete arg1;
26258     } CALL_CATCH_EXCEPTION();
26259   }
26260
26261 }
26262
26263
26264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26265   unsigned int jresult ;
26266   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26267   unsigned int result;
26268
26269   arg1 = (Dali::TapGesture *)jarg1;
26270   result = (unsigned int) ((arg1)->GetNumberOfTaps());
26271   jresult = result;
26272   return jresult;
26273 }
26274
26275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26276   unsigned int jresult ;
26277   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26278   unsigned int result;
26279
26280   arg1 = (Dali::TapGesture *)jarg1;
26281   result = (unsigned int) ((arg1)->GetNumberOfTouches());
26282   jresult = result;
26283   return jresult;
26284 }
26285
26286
26287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26288   void * jresult ;
26289   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26290   Dali::Vector2 result;
26291
26292   arg1 = (Dali::TapGesture *)jarg1;
26293   {
26294     try {
26295       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
26296     } catch (std::out_of_range& e) {
26297       {
26298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26299       };
26300     } catch (std::exception& e) {
26301       {
26302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26303       };
26304     } catch (Dali::DaliException e) {
26305       {
26306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26307       };
26308     } catch (...) {
26309       {
26310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26311       };
26312     }
26313   }
26314   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26315   return jresult;
26316 }
26317
26318
26319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26320   void * jresult ;
26321   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26322   Dali::Vector2 result;
26323
26324   arg1 = (Dali::TapGesture *)jarg1;
26325   {
26326     try {
26327       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
26328     } catch (std::out_of_range& e) {
26329       {
26330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26331       };
26332     } catch (std::exception& e) {
26333       {
26334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26335       };
26336     } catch (Dali::DaliException e) {
26337       {
26338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26339       };
26340     } catch (...) {
26341       {
26342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26343       };
26344     }
26345   }
26346   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26352   void * jresult ;
26353   Dali::AlphaFunction *result = 0 ;
26354
26355   {
26356     try {
26357       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26358     } CALL_CATCH_EXCEPTION(0);
26359   }
26360
26361   jresult = (void *)result;
26362   return jresult;
26363 }
26364
26365
26366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26367   void * jresult ;
26368   Dali::AlphaFunction::BuiltinFunction arg1 ;
26369   Dali::AlphaFunction *result = 0 ;
26370
26371   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26372   {
26373     try {
26374       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26375     } CALL_CATCH_EXCEPTION(0);
26376   }
26377
26378   jresult = (void *)result;
26379   return jresult;
26380 }
26381
26382
26383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
26384   void * jresult ;
26385   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26386   Dali::AlphaFunction *result = 0 ;
26387
26388   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
26389   {
26390     try {
26391       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26392     } CALL_CATCH_EXCEPTION(0);
26393   }
26394
26395   jresult = (void *)result;
26396   return jresult;
26397 }
26398
26399
26400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
26401   void * jresult ;
26402   Dali::Vector2 *arg1 = 0 ;
26403   Dali::Vector2 *arg2 = 0 ;
26404   Dali::AlphaFunction *result = 0 ;
26405
26406   arg1 = (Dali::Vector2 *)jarg1;
26407   if (!arg1) {
26408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26409     return 0;
26410   }
26411   arg2 = (Dali::Vector2 *)jarg2;
26412   if (!arg2) {
26413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26414     return 0;
26415   }
26416   {
26417     try {
26418       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26419     } CALL_CATCH_EXCEPTION(0);
26420   }
26421
26422   jresult = (void *)result;
26423   return jresult;
26424 }
26425
26426
26427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26428   void * jresult ;
26429   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26430   Dali::Vector4 result;
26431
26432   arg1 = (Dali::AlphaFunction *)jarg1;
26433   {
26434     try {
26435       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26436     } CALL_CATCH_EXCEPTION(0);
26437   }
26438
26439   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26445   void * jresult ;
26446   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26447   Dali::AlphaFunctionPrototype result;
26448
26449   arg1 = (Dali::AlphaFunction *)jarg1;
26450   {
26451     try {
26452       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26453     } CALL_CATCH_EXCEPTION(0);
26454   }
26455
26456   jresult = (void *)result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26462   int jresult ;
26463   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26464   Dali::AlphaFunction::BuiltinFunction result;
26465
26466   arg1 = (Dali::AlphaFunction *)jarg1;
26467   {
26468     try {
26469       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26470     } CALL_CATCH_EXCEPTION(0);
26471   }
26472
26473   jresult = (int)result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26479   int jresult ;
26480   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26481   Dali::AlphaFunction::Mode result;
26482
26483   arg1 = (Dali::AlphaFunction *)jarg1;
26484   {
26485     try {
26486       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26487     } CALL_CATCH_EXCEPTION(0);
26488   }
26489
26490   jresult = (int)result;
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26496   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26497
26498   arg1 = (Dali::AlphaFunction *)jarg1;
26499   {
26500     try {
26501       delete arg1;
26502     } CALL_CATCH_EXCEPTION();
26503   }
26504
26505 }
26506
26507
26508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26509   void * jresult ;
26510   Dali::KeyFrames result;
26511
26512   {
26513     try {
26514       result = Dali::KeyFrames::New();
26515     } CALL_CATCH_EXCEPTION(0);
26516   }
26517
26518   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26519   return jresult;
26520 }
26521
26522
26523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26524   void * jresult ;
26525   Dali::BaseHandle arg1 ;
26526   Dali::BaseHandle *argp1 ;
26527   Dali::KeyFrames result;
26528
26529   argp1 = (Dali::BaseHandle *)jarg1;
26530   if (!argp1) {
26531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26532     return 0;
26533   }
26534   arg1 = *argp1;
26535   {
26536     try {
26537       result = Dali::KeyFrames::DownCast(arg1);
26538     } CALL_CATCH_EXCEPTION(0);
26539   }
26540
26541   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26542   return jresult;
26543 }
26544
26545
26546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26547   void * jresult ;
26548   Dali::KeyFrames *result = 0 ;
26549
26550   {
26551     try {
26552       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26553     } CALL_CATCH_EXCEPTION(0);
26554   }
26555
26556   jresult = (void *)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26562   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26563
26564   arg1 = (Dali::KeyFrames *)jarg1;
26565   {
26566     try {
26567       delete arg1;
26568     } CALL_CATCH_EXCEPTION();
26569   }
26570
26571 }
26572
26573
26574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26575   void * jresult ;
26576   Dali::KeyFrames *arg1 = 0 ;
26577   Dali::KeyFrames *result = 0 ;
26578
26579   arg1 = (Dali::KeyFrames *)jarg1;
26580   if (!arg1) {
26581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26582     return 0;
26583   }
26584   {
26585     try {
26586       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26587     } CALL_CATCH_EXCEPTION(0);
26588   }
26589
26590   jresult = (void *)result;
26591   return jresult;
26592 }
26593
26594
26595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26596   void * jresult ;
26597   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26598   Dali::KeyFrames *arg2 = 0 ;
26599   Dali::KeyFrames *result = 0 ;
26600
26601   arg1 = (Dali::KeyFrames *)jarg1;
26602   arg2 = (Dali::KeyFrames *)jarg2;
26603   if (!arg2) {
26604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26605     return 0;
26606   }
26607   {
26608     try {
26609       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26610     } CALL_CATCH_EXCEPTION(0);
26611   }
26612
26613   jresult = (void *)result;
26614   return jresult;
26615 }
26616
26617
26618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26619   int jresult ;
26620   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26621   Dali::Property::Type result;
26622
26623   arg1 = (Dali::KeyFrames *)jarg1;
26624   {
26625     try {
26626       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26627     } CALL_CATCH_EXCEPTION(0);
26628   }
26629
26630   jresult = (int)result;
26631   return jresult;
26632 }
26633
26634
26635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26636   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26637   float arg2 ;
26638   Dali::Property::Value arg3 ;
26639   Dali::Property::Value *argp3 ;
26640
26641   arg1 = (Dali::KeyFrames *)jarg1;
26642   arg2 = (float)jarg2;
26643   argp3 = (Dali::Property::Value *)jarg3;
26644   if (!argp3) {
26645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26646     return ;
26647   }
26648   arg3 = *argp3;
26649   {
26650     try {
26651       (arg1)->Add(arg2,arg3);
26652     } CALL_CATCH_EXCEPTION();
26653   }
26654
26655 }
26656
26657
26658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26659   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26660   float arg2 ;
26661   Dali::Property::Value arg3 ;
26662   Dali::AlphaFunction arg4 ;
26663   Dali::Property::Value *argp3 ;
26664   Dali::AlphaFunction *argp4 ;
26665
26666   arg1 = (Dali::KeyFrames *)jarg1;
26667   arg2 = (float)jarg2;
26668   argp3 = (Dali::Property::Value *)jarg3;
26669   if (!argp3) {
26670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26671     return ;
26672   }
26673   arg3 = *argp3;
26674   argp4 = (Dali::AlphaFunction *)jarg4;
26675   if (!argp4) {
26676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26677     return ;
26678   }
26679   arg4 = *argp4;
26680   {
26681     try {
26682       (arg1)->Add(arg2,arg3,arg4);
26683     } CALL_CATCH_EXCEPTION();
26684   }
26685
26686 }
26687
26688
26689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26690   int jresult ;
26691   int result;
26692
26693   result = (int)Dali::Path::Property::POINTS;
26694   jresult = (int)result;
26695   return jresult;
26696 }
26697
26698
26699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26700   int jresult ;
26701   int result;
26702
26703   result = (int)Dali::Path::Property::CONTROL_POINTS;
26704   jresult = (int)result;
26705   return jresult;
26706 }
26707
26708
26709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26710   void * jresult ;
26711   Dali::Path::Property *result = 0 ;
26712
26713   {
26714     try {
26715       result = (Dali::Path::Property *)new Dali::Path::Property();
26716     } CALL_CATCH_EXCEPTION(0);
26717   }
26718
26719   jresult = (void *)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26725   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26726
26727   arg1 = (Dali::Path::Property *)jarg1;
26728   {
26729     try {
26730       delete arg1;
26731     } CALL_CATCH_EXCEPTION();
26732   }
26733
26734 }
26735
26736
26737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26738   void * jresult ;
26739   Dali::Path result;
26740
26741   {
26742     try {
26743       result = Dali::Path::New();
26744     } CALL_CATCH_EXCEPTION(0);
26745   }
26746
26747   jresult = new Dali::Path((const Dali::Path &)result);
26748   return jresult;
26749 }
26750
26751
26752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26753   void * jresult ;
26754   Dali::BaseHandle arg1 ;
26755   Dali::BaseHandle *argp1 ;
26756   Dali::Path result;
26757
26758   argp1 = (Dali::BaseHandle *)jarg1;
26759   if (!argp1) {
26760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26761     return 0;
26762   }
26763   arg1 = *argp1;
26764   {
26765     try {
26766       result = Dali::Path::DownCast(arg1);
26767     } CALL_CATCH_EXCEPTION(0);
26768   }
26769
26770   jresult = new Dali::Path((const Dali::Path &)result);
26771   return jresult;
26772 }
26773
26774
26775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26776   void * jresult ;
26777   Dali::Path *result = 0 ;
26778
26779   {
26780     try {
26781       result = (Dali::Path *)new Dali::Path();
26782     } CALL_CATCH_EXCEPTION(0);
26783   }
26784
26785   jresult = (void *)result;
26786   return jresult;
26787 }
26788
26789
26790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26791   Dali::Path *arg1 = (Dali::Path *) 0 ;
26792
26793   arg1 = (Dali::Path *)jarg1;
26794   {
26795     try {
26796       delete arg1;
26797     } CALL_CATCH_EXCEPTION();
26798   }
26799
26800 }
26801
26802
26803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26804   void * jresult ;
26805   Dali::Path *arg1 = 0 ;
26806   Dali::Path *result = 0 ;
26807
26808   arg1 = (Dali::Path *)jarg1;
26809   if (!arg1) {
26810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26811     return 0;
26812   }
26813   {
26814     try {
26815       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26816     } CALL_CATCH_EXCEPTION(0);
26817   }
26818
26819   jresult = (void *)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26825   void * jresult ;
26826   Dali::Path *arg1 = (Dali::Path *) 0 ;
26827   Dali::Path *arg2 = 0 ;
26828   Dali::Path *result = 0 ;
26829
26830   arg1 = (Dali::Path *)jarg1;
26831   arg2 = (Dali::Path *)jarg2;
26832   if (!arg2) {
26833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26834     return 0;
26835   }
26836   {
26837     try {
26838       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26839     } CALL_CATCH_EXCEPTION(0);
26840   }
26841
26842   jresult = (void *)result;
26843   return jresult;
26844 }
26845
26846
26847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
26848   Dali::Path *arg1 = (Dali::Path *) 0 ;
26849   Dali::Vector3 *arg2 = 0 ;
26850
26851   arg1 = (Dali::Path *)jarg1;
26852   arg2 = (Dali::Vector3 *)jarg2;
26853   if (!arg2) {
26854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26855     return ;
26856   }
26857   {
26858     try {
26859       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
26860     } CALL_CATCH_EXCEPTION();
26861   }
26862
26863 }
26864
26865
26866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
26867   Dali::Path *arg1 = (Dali::Path *) 0 ;
26868   Dali::Vector3 *arg2 = 0 ;
26869
26870   arg1 = (Dali::Path *)jarg1;
26871   arg2 = (Dali::Vector3 *)jarg2;
26872   if (!arg2) {
26873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26874     return ;
26875   }
26876   {
26877     try {
26878       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
26879     } CALL_CATCH_EXCEPTION();
26880   }
26881
26882 }
26883
26884
26885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
26886   Dali::Path *arg1 = (Dali::Path *) 0 ;
26887   float arg2 ;
26888
26889   arg1 = (Dali::Path *)jarg1;
26890   arg2 = (float)jarg2;
26891   {
26892     try {
26893       (arg1)->GenerateControlPoints(arg2);
26894     } CALL_CATCH_EXCEPTION();
26895   }
26896
26897 }
26898
26899
26900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26901   Dali::Path *arg1 = (Dali::Path *) 0 ;
26902   float arg2 ;
26903   Dali::Vector3 *arg3 = 0 ;
26904   Dali::Vector3 *arg4 = 0 ;
26905
26906   arg1 = (Dali::Path *)jarg1;
26907   arg2 = (float)jarg2;
26908   arg3 = (Dali::Vector3 *)jarg3;
26909   if (!arg3) {
26910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
26911     return ;
26912   }
26913   arg4 = (Dali::Vector3 *)jarg4;
26914   if (!arg4) {
26915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
26916     return ;
26917   }
26918   {
26919     try {
26920       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
26921     } CALL_CATCH_EXCEPTION();
26922   }
26923
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
26928   void * jresult ;
26929   Dali::Path *arg1 = (Dali::Path *) 0 ;
26930   size_t arg2 ;
26931   Dali::Vector3 *result = 0 ;
26932
26933   arg1 = (Dali::Path *)jarg1;
26934   arg2 = (size_t)jarg2;
26935   {
26936     try {
26937       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
26938     } CALL_CATCH_EXCEPTION(0);
26939   }
26940
26941   jresult = (void *)result;
26942   return jresult;
26943 }
26944
26945
26946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
26947   void * jresult ;
26948   Dali::Path *arg1 = (Dali::Path *) 0 ;
26949   size_t arg2 ;
26950   Dali::Vector3 *result = 0 ;
26951
26952   arg1 = (Dali::Path *)jarg1;
26953   arg2 = (size_t)jarg2;
26954   {
26955     try {
26956       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
26957     } CALL_CATCH_EXCEPTION(0);
26958   }
26959
26960   jresult = (void *)result;
26961   return jresult;
26962 }
26963
26964
26965 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
26966   unsigned long jresult ;
26967   Dali::Path *arg1 = (Dali::Path *) 0 ;
26968   size_t result;
26969
26970   arg1 = (Dali::Path *)jarg1;
26971   {
26972     try {
26973       result = ((Dali::Path const *)arg1)->GetPointCount();
26974     } CALL_CATCH_EXCEPTION(0);
26975   }
26976
26977   jresult = (unsigned long)result;
26978   return jresult;
26979 }
26980
26981
26982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
26983   void * jresult ;
26984   float arg1 ;
26985   Dali::TimePeriod *result = 0 ;
26986
26987   arg1 = (float)jarg1;
26988   {
26989     try {
26990       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
26991     } CALL_CATCH_EXCEPTION(0);
26992   }
26993
26994   jresult = (void *)result;
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27000   void * jresult ;
27001   float arg1 ;
27002   float arg2 ;
27003   Dali::TimePeriod *result = 0 ;
27004
27005   arg1 = (float)jarg1;
27006   arg2 = (float)jarg2;
27007   {
27008     try {
27009       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27010     } CALL_CATCH_EXCEPTION(0);
27011   }
27012
27013   jresult = (void *)result;
27014   return jresult;
27015 }
27016
27017
27018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27019   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27020
27021   arg1 = (Dali::TimePeriod *)jarg1;
27022   {
27023     try {
27024       delete arg1;
27025     } CALL_CATCH_EXCEPTION();
27026   }
27027
27028 }
27029
27030
27031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27032   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27033   float arg2 ;
27034
27035   arg1 = (Dali::TimePeriod *)jarg1;
27036   arg2 = (float)jarg2;
27037   if (arg1) (arg1)->delaySeconds = arg2;
27038 }
27039
27040
27041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27042   float jresult ;
27043   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27044   float result;
27045
27046   arg1 = (Dali::TimePeriod *)jarg1;
27047   result = (float) ((arg1)->delaySeconds);
27048   jresult = result;
27049   return jresult;
27050 }
27051
27052
27053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27054   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27055   float arg2 ;
27056
27057   arg1 = (Dali::TimePeriod *)jarg1;
27058   arg2 = (float)jarg2;
27059   if (arg1) (arg1)->durationSeconds = arg2;
27060 }
27061
27062
27063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27064   float jresult ;
27065   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27066   float result;
27067
27068   arg1 = (Dali::TimePeriod *)jarg1;
27069   result = (float) ((arg1)->durationSeconds);
27070   jresult = result;
27071   return jresult;
27072 }
27073
27074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27075   int jresult ;
27076   int result;
27077
27078   result = (int)Dali::LinearConstrainer::Property::VALUE;
27079   jresult = (int)result;
27080   return jresult;
27081 }
27082
27083
27084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27085   int jresult ;
27086   int result;
27087
27088   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27089   jresult = (int)result;
27090   return jresult;
27091 }
27092
27093
27094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27095   void * jresult ;
27096   Dali::LinearConstrainer::Property *result = 0 ;
27097
27098   {
27099     try {
27100       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27101     } CALL_CATCH_EXCEPTION(0);
27102   }
27103
27104   jresult = (void *)result;
27105   return jresult;
27106 }
27107
27108
27109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27110   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27111
27112   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27113   {
27114     try {
27115       delete arg1;
27116     } CALL_CATCH_EXCEPTION();
27117   }
27118
27119 }
27120
27121
27122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27123   void * jresult ;
27124   Dali::LinearConstrainer result;
27125
27126   {
27127     try {
27128       result = Dali::LinearConstrainer::New();
27129     } CALL_CATCH_EXCEPTION(0);
27130   }
27131
27132   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27133   return jresult;
27134 }
27135
27136
27137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27138   void * jresult ;
27139   Dali::BaseHandle arg1 ;
27140   Dali::BaseHandle *argp1 ;
27141   Dali::LinearConstrainer result;
27142
27143   argp1 = (Dali::BaseHandle *)jarg1;
27144   if (!argp1) {
27145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27146     return 0;
27147   }
27148   arg1 = *argp1;
27149   {
27150     try {
27151       result = Dali::LinearConstrainer::DownCast(arg1);
27152     } CALL_CATCH_EXCEPTION(0);
27153   }
27154
27155   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27156   return jresult;
27157 }
27158
27159
27160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27161   void * jresult ;
27162   Dali::LinearConstrainer *result = 0 ;
27163
27164   {
27165     try {
27166       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27167     } CALL_CATCH_EXCEPTION(0);
27168   }
27169
27170   jresult = (void *)result;
27171   return jresult;
27172 }
27173
27174
27175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27176   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27177
27178   arg1 = (Dali::LinearConstrainer *)jarg1;
27179   {
27180     try {
27181       delete arg1;
27182     } CALL_CATCH_EXCEPTION();
27183   }
27184
27185 }
27186
27187
27188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27189   void * jresult ;
27190   Dali::LinearConstrainer *arg1 = 0 ;
27191   Dali::LinearConstrainer *result = 0 ;
27192
27193   arg1 = (Dali::LinearConstrainer *)jarg1;
27194   if (!arg1) {
27195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27196     return 0;
27197   }
27198   {
27199     try {
27200       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27201     } CALL_CATCH_EXCEPTION(0);
27202   }
27203
27204   jresult = (void *)result;
27205   return jresult;
27206 }
27207
27208
27209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27210   void * jresult ;
27211   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27212   Dali::LinearConstrainer *arg2 = 0 ;
27213   Dali::LinearConstrainer *result = 0 ;
27214
27215   arg1 = (Dali::LinearConstrainer *)jarg1;
27216   arg2 = (Dali::LinearConstrainer *)jarg2;
27217   if (!arg2) {
27218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27219     return 0;
27220   }
27221   {
27222     try {
27223       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27224     } CALL_CATCH_EXCEPTION(0);
27225   }
27226
27227   jresult = (void *)result;
27228   return jresult;
27229 }
27230
27231
27232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27233   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27234   SwigValueWrapper< Dali::Property > arg2 ;
27235   SwigValueWrapper< Dali::Property > arg3 ;
27236   Dali::Vector2 *arg4 = 0 ;
27237   Dali::Vector2 *arg5 = 0 ;
27238   Dali::Property *argp2 ;
27239   Dali::Property *argp3 ;
27240
27241   arg1 = (Dali::LinearConstrainer *)jarg1;
27242   argp2 = (Dali::Property *)jarg2;
27243   if (!argp2) {
27244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27245     return ;
27246   }
27247   arg2 = *argp2;
27248   argp3 = (Dali::Property *)jarg3;
27249   if (!argp3) {
27250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27251     return ;
27252   }
27253   arg3 = *argp3;
27254   arg4 = (Dali::Vector2 *)jarg4;
27255   if (!arg4) {
27256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27257     return ;
27258   }
27259   arg5 = (Dali::Vector2 *)jarg5;
27260   if (!arg5) {
27261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27262     return ;
27263   }
27264   {
27265     try {
27266       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27267     } CALL_CATCH_EXCEPTION();
27268   }
27269
27270 }
27271
27272
27273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27274   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27275   SwigValueWrapper< Dali::Property > arg2 ;
27276   SwigValueWrapper< Dali::Property > arg3 ;
27277   Dali::Vector2 *arg4 = 0 ;
27278   Dali::Property *argp2 ;
27279   Dali::Property *argp3 ;
27280
27281   arg1 = (Dali::LinearConstrainer *)jarg1;
27282   argp2 = (Dali::Property *)jarg2;
27283   if (!argp2) {
27284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27285     return ;
27286   }
27287   arg2 = *argp2;
27288   argp3 = (Dali::Property *)jarg3;
27289   if (!argp3) {
27290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27291     return ;
27292   }
27293   arg3 = *argp3;
27294   arg4 = (Dali::Vector2 *)jarg4;
27295   if (!arg4) {
27296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27297     return ;
27298   }
27299   {
27300     try {
27301       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27302     } CALL_CATCH_EXCEPTION();
27303   }
27304
27305 }
27306
27307
27308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27309   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27310   Dali::Handle *arg2 = 0 ;
27311
27312   arg1 = (Dali::LinearConstrainer *)jarg1;
27313   arg2 = (Dali::Handle *)jarg2;
27314   if (!arg2) {
27315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27316     return ;
27317   }
27318   {
27319     try {
27320       (arg1)->Remove(*arg2);
27321     } CALL_CATCH_EXCEPTION();
27322   }
27323
27324 }
27325
27326
27327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27328   int jresult ;
27329   int result;
27330
27331   result = (int)Dali::PathConstrainer::Property::FORWARD;
27332   jresult = (int)result;
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27338   int jresult ;
27339   int result;
27340
27341   result = (int)Dali::PathConstrainer::Property::POINTS;
27342   jresult = (int)result;
27343   return jresult;
27344 }
27345
27346
27347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27348   int jresult ;
27349   int result;
27350
27351   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27352   jresult = (int)result;
27353   return jresult;
27354 }
27355
27356
27357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27358   void * jresult ;
27359   Dali::PathConstrainer::Property *result = 0 ;
27360
27361   {
27362     try {
27363       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27364     } CALL_CATCH_EXCEPTION(0);
27365   }
27366
27367   jresult = (void *)result;
27368   return jresult;
27369 }
27370
27371
27372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27373   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27374
27375   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27376   {
27377     try {
27378       delete arg1;
27379     } CALL_CATCH_EXCEPTION();
27380   }
27381
27382 }
27383
27384
27385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27386   void * jresult ;
27387   Dali::PathConstrainer result;
27388
27389   {
27390     try {
27391       result = Dali::PathConstrainer::New();
27392     } CALL_CATCH_EXCEPTION(0);
27393   }
27394
27395   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27396   return jresult;
27397 }
27398
27399
27400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27401   void * jresult ;
27402   Dali::BaseHandle arg1 ;
27403   Dali::BaseHandle *argp1 ;
27404   Dali::PathConstrainer result;
27405
27406   argp1 = (Dali::BaseHandle *)jarg1;
27407   if (!argp1) {
27408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27409     return 0;
27410   }
27411   arg1 = *argp1;
27412   {
27413     try {
27414       result = Dali::PathConstrainer::DownCast(arg1);
27415     } CALL_CATCH_EXCEPTION(0);
27416   }
27417
27418   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27419   return jresult;
27420 }
27421
27422
27423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27424   void * jresult ;
27425   Dali::PathConstrainer *result = 0 ;
27426
27427   {
27428     try {
27429       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27430     } CALL_CATCH_EXCEPTION(0);
27431   }
27432
27433   jresult = (void *)result;
27434   return jresult;
27435 }
27436
27437
27438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27439   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27440
27441   arg1 = (Dali::PathConstrainer *)jarg1;
27442   {
27443     try {
27444       delete arg1;
27445     } CALL_CATCH_EXCEPTION();
27446   }
27447
27448 }
27449
27450
27451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27452   void * jresult ;
27453   Dali::PathConstrainer *arg1 = 0 ;
27454   Dali::PathConstrainer *result = 0 ;
27455
27456   arg1 = (Dali::PathConstrainer *)jarg1;
27457   if (!arg1) {
27458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27459     return 0;
27460   }
27461   {
27462     try {
27463       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27464     } CALL_CATCH_EXCEPTION(0);
27465   }
27466
27467   jresult = (void *)result;
27468   return jresult;
27469 }
27470
27471
27472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27473   void * jresult ;
27474   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27475   Dali::PathConstrainer *arg2 = 0 ;
27476   Dali::PathConstrainer *result = 0 ;
27477
27478   arg1 = (Dali::PathConstrainer *)jarg1;
27479   arg2 = (Dali::PathConstrainer *)jarg2;
27480   if (!arg2) {
27481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27482     return 0;
27483   }
27484   {
27485     try {
27486       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27487     } CALL_CATCH_EXCEPTION(0);
27488   }
27489
27490   jresult = (void *)result;
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27496   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27497   SwigValueWrapper< Dali::Property > arg2 ;
27498   SwigValueWrapper< Dali::Property > arg3 ;
27499   Dali::Vector2 *arg4 = 0 ;
27500   Dali::Vector2 *arg5 = 0 ;
27501   Dali::Property *argp2 ;
27502   Dali::Property *argp3 ;
27503
27504   arg1 = (Dali::PathConstrainer *)jarg1;
27505   argp2 = (Dali::Property *)jarg2;
27506   if (!argp2) {
27507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27508     return ;
27509   }
27510   arg2 = *argp2;
27511   argp3 = (Dali::Property *)jarg3;
27512   if (!argp3) {
27513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27514     return ;
27515   }
27516   arg3 = *argp3;
27517   arg4 = (Dali::Vector2 *)jarg4;
27518   if (!arg4) {
27519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27520     return ;
27521   }
27522   arg5 = (Dali::Vector2 *)jarg5;
27523   if (!arg5) {
27524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27525     return ;
27526   }
27527   {
27528     try {
27529       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27530     } CALL_CATCH_EXCEPTION();
27531   }
27532
27533 }
27534
27535
27536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27537   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27538   SwigValueWrapper< Dali::Property > arg2 ;
27539   SwigValueWrapper< Dali::Property > arg3 ;
27540   Dali::Vector2 *arg4 = 0 ;
27541   Dali::Property *argp2 ;
27542   Dali::Property *argp3 ;
27543
27544   arg1 = (Dali::PathConstrainer *)jarg1;
27545   argp2 = (Dali::Property *)jarg2;
27546   if (!argp2) {
27547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27548     return ;
27549   }
27550   arg2 = *argp2;
27551   argp3 = (Dali::Property *)jarg3;
27552   if (!argp3) {
27553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27554     return ;
27555   }
27556   arg3 = *argp3;
27557   arg4 = (Dali::Vector2 *)jarg4;
27558   if (!arg4) {
27559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27560     return ;
27561   }
27562   {
27563     try {
27564       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27565     } CALL_CATCH_EXCEPTION();
27566   }
27567
27568 }
27569
27570
27571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27572   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27573   Dali::Handle *arg2 = 0 ;
27574
27575   arg1 = (Dali::PathConstrainer *)jarg1;
27576   arg2 = (Dali::Handle *)jarg2;
27577   if (!arg2) {
27578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27579     return ;
27580   }
27581   {
27582     try {
27583       (arg1)->Remove(*arg2);
27584     } CALL_CATCH_EXCEPTION();
27585   }
27586
27587 }
27588
27589
27590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27591   int jresult ;
27592   Dali::FittingMode::Type result;
27593
27594   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27595   jresult = (int)result;
27596   return jresult;
27597 }
27598
27599
27600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27601   int jresult ;
27602   Dali::SamplingMode::Type result;
27603
27604   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27605   jresult = (int)result;
27606   return jresult;
27607 }
27608
27609
27610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27611   unsigned int jresult ;
27612   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27613   bool result;
27614
27615   arg1 = (Dali::NativeImageInterface *)jarg1;
27616   {
27617     try {
27618       result = (bool)(arg1)->CreateResource();
27619     } CALL_CATCH_EXCEPTION(0);
27620   }
27621
27622   jresult = result;
27623   return jresult;
27624 }
27625
27626
27627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27628   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27629
27630   arg1 = (Dali::NativeImageInterface *)jarg1;
27631   {
27632     try {
27633       (arg1)->DestroyResource();
27634     } CALL_CATCH_EXCEPTION();
27635   }
27636
27637 }
27638
27639
27640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27641   unsigned int jresult ;
27642   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27643   unsigned int result;
27644
27645   arg1 = (Dali::NativeImageInterface *)jarg1;
27646   {
27647     try {
27648       result = (unsigned int)(arg1)->TargetTexture();
27649     } CALL_CATCH_EXCEPTION(0);
27650   }
27651
27652   jresult = result;
27653   return jresult;
27654 }
27655
27656
27657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27658   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27659
27660   arg1 = (Dali::NativeImageInterface *)jarg1;
27661   {
27662     try {
27663       (arg1)->PrepareTexture();
27664     } CALL_CATCH_EXCEPTION();
27665   }
27666
27667 }
27668
27669
27670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27671   unsigned int jresult ;
27672   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27673   unsigned int result;
27674
27675   arg1 = (Dali::NativeImageInterface *)jarg1;
27676   {
27677     try {
27678       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27679     } CALL_CATCH_EXCEPTION(0);
27680   }
27681
27682   jresult = result;
27683   return jresult;
27684 }
27685
27686
27687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
27688   unsigned int jresult ;
27689   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27690   unsigned int result;
27691
27692   arg1 = (Dali::NativeImageInterface *)jarg1;
27693   {
27694     try {
27695       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
27696     } CALL_CATCH_EXCEPTION(0);
27697   }
27698
27699   jresult = result;
27700   return jresult;
27701 }
27702
27703
27704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27705   unsigned int jresult ;
27706   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27707   bool result;
27708
27709   arg1 = (Dali::NativeImageInterface *)jarg1;
27710   {
27711     try {
27712       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27713     } CALL_CATCH_EXCEPTION(0);
27714   }
27715
27716   jresult = result;
27717   return jresult;
27718 }
27719
27720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27721   int jresult ;
27722   int result;
27723
27724   result = (int)Dali::CameraActor::Property::TYPE;
27725   jresult = (int)result;
27726   return jresult;
27727 }
27728
27729
27730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27731   int jresult ;
27732   int result;
27733
27734   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27735   jresult = (int)result;
27736   return jresult;
27737 }
27738
27739
27740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27741   int jresult ;
27742   int result;
27743
27744   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27745   jresult = (int)result;
27746   return jresult;
27747 }
27748
27749
27750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27751   int jresult ;
27752   int result;
27753
27754   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27755   jresult = (int)result;
27756   return jresult;
27757 }
27758
27759
27760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27761   int jresult ;
27762   int result;
27763
27764   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27765   jresult = (int)result;
27766   return jresult;
27767 }
27768
27769
27770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27771   int jresult ;
27772   int result;
27773
27774   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27775   jresult = (int)result;
27776   return jresult;
27777 }
27778
27779
27780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27781   int jresult ;
27782   int result;
27783
27784   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27785   jresult = (int)result;
27786   return jresult;
27787 }
27788
27789
27790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27791   int jresult ;
27792   int result;
27793
27794   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27795   jresult = (int)result;
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27801   int jresult ;
27802   int result;
27803
27804   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27805   jresult = (int)result;
27806   return jresult;
27807 }
27808
27809
27810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27811   int jresult ;
27812   int result;
27813
27814   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27815   jresult = (int)result;
27816   return jresult;
27817 }
27818
27819
27820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27821   int jresult ;
27822   int result;
27823
27824   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27825   jresult = (int)result;
27826   return jresult;
27827 }
27828
27829
27830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27831   int jresult ;
27832   int result;
27833
27834   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27835   jresult = (int)result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27841   int jresult ;
27842   int result;
27843
27844   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
27845   jresult = (int)result;
27846   return jresult;
27847 }
27848
27849
27850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
27851   int jresult ;
27852   int result;
27853
27854   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
27855   jresult = (int)result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
27861   void * jresult ;
27862   Dali::CameraActor::Property *result = 0 ;
27863
27864   {
27865     try {
27866       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
27867     } CALL_CATCH_EXCEPTION(0);
27868   }
27869
27870   jresult = (void *)result;
27871   return jresult;
27872 }
27873
27874
27875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
27876   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
27877
27878   arg1 = (Dali::CameraActor::Property *)jarg1;
27879   {
27880     try {
27881       delete arg1;
27882     } CALL_CATCH_EXCEPTION();
27883   }
27884
27885 }
27886
27887
27888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
27889   void * jresult ;
27890   Dali::CameraActor *result = 0 ;
27891
27892   {
27893     try {
27894       result = (Dali::CameraActor *)new Dali::CameraActor();
27895     } CALL_CATCH_EXCEPTION(0);
27896   }
27897
27898   jresult = (void *)result;
27899   return jresult;
27900 }
27901
27902
27903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
27904   void * jresult ;
27905   Dali::CameraActor result;
27906
27907   {
27908     try {
27909       result = Dali::CameraActor::New();
27910     } CALL_CATCH_EXCEPTION(0);
27911   }
27912
27913   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27914   return jresult;
27915 }
27916
27917
27918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
27919   void * jresult ;
27920   Dali::Size *arg1 = 0 ;
27921   Dali::CameraActor result;
27922
27923   arg1 = (Dali::Size *)jarg1;
27924   if (!arg1) {
27925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
27926     return 0;
27927   }
27928   {
27929     try {
27930       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
27931     } CALL_CATCH_EXCEPTION(0);
27932   }
27933
27934   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
27940   void * jresult ;
27941   Dali::BaseHandle arg1 ;
27942   Dali::BaseHandle *argp1 ;
27943   Dali::CameraActor result;
27944
27945   argp1 = (Dali::BaseHandle *)jarg1;
27946   if (!argp1) {
27947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27948     return 0;
27949   }
27950   arg1 = *argp1;
27951   {
27952     try {
27953       result = Dali::CameraActor::DownCast(arg1);
27954     } CALL_CATCH_EXCEPTION(0);
27955   }
27956
27957   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
27958   return jresult;
27959 }
27960
27961
27962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
27963   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
27964
27965   arg1 = (Dali::CameraActor *)jarg1;
27966   {
27967     try {
27968       delete arg1;
27969     } CALL_CATCH_EXCEPTION();
27970   }
27971
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
27976   void * jresult ;
27977   Dali::CameraActor *arg1 = 0 ;
27978   Dali::CameraActor *result = 0 ;
27979
27980   arg1 = (Dali::CameraActor *)jarg1;
27981   if (!arg1) {
27982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
27983     return 0;
27984   }
27985   {
27986     try {
27987       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
27988     } CALL_CATCH_EXCEPTION(0);
27989   }
27990
27991   jresult = (void *)result;
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
27997   void * jresult ;
27998   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
27999   Dali::CameraActor *arg2 = 0 ;
28000   Dali::CameraActor *result = 0 ;
28001
28002   arg1 = (Dali::CameraActor *)jarg1;
28003   arg2 = (Dali::CameraActor *)jarg2;
28004   if (!arg2) {
28005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28006     return 0;
28007   }
28008   {
28009     try {
28010       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28011     } CALL_CATCH_EXCEPTION(0);
28012   }
28013
28014   jresult = (void *)result;
28015   return jresult;
28016 }
28017
28018
28019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28020   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28021   Dali::Camera::Type arg2 ;
28022
28023   arg1 = (Dali::CameraActor *)jarg1;
28024   arg2 = (Dali::Camera::Type)jarg2;
28025   {
28026     try {
28027       (arg1)->SetType(arg2);
28028     } CALL_CATCH_EXCEPTION();
28029   }
28030
28031 }
28032
28033
28034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28035   int jresult ;
28036   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28037   Dali::Camera::Type result;
28038
28039   arg1 = (Dali::CameraActor *)jarg1;
28040   {
28041     try {
28042       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28043     } CALL_CATCH_EXCEPTION(0);
28044   }
28045
28046   jresult = (int)result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28052   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28053   Dali::Camera::ProjectionMode arg2 ;
28054
28055   arg1 = (Dali::CameraActor *)jarg1;
28056   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28057   {
28058     try {
28059       (arg1)->SetProjectionMode(arg2);
28060     } CALL_CATCH_EXCEPTION();
28061   }
28062
28063 }
28064
28065
28066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28067   int jresult ;
28068   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28069   Dali::Camera::ProjectionMode result;
28070
28071   arg1 = (Dali::CameraActor *)jarg1;
28072   {
28073     try {
28074       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28075     } CALL_CATCH_EXCEPTION(0);
28076   }
28077
28078   jresult = (int)result;
28079   return jresult;
28080 }
28081
28082
28083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28085   float arg2 ;
28086
28087   arg1 = (Dali::CameraActor *)jarg1;
28088   arg2 = (float)jarg2;
28089   {
28090     try {
28091       (arg1)->SetFieldOfView(arg2);
28092     } CALL_CATCH_EXCEPTION();
28093   }
28094
28095 }
28096
28097
28098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28099   float jresult ;
28100   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28101   float result;
28102
28103   arg1 = (Dali::CameraActor *)jarg1;
28104   {
28105     try {
28106       result = (float)(arg1)->GetFieldOfView();
28107     } CALL_CATCH_EXCEPTION(0);
28108   }
28109
28110   jresult = result;
28111   return jresult;
28112 }
28113
28114
28115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28116   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28117   float arg2 ;
28118
28119   arg1 = (Dali::CameraActor *)jarg1;
28120   arg2 = (float)jarg2;
28121   {
28122     try {
28123       (arg1)->SetAspectRatio(arg2);
28124     } CALL_CATCH_EXCEPTION();
28125   }
28126
28127 }
28128
28129
28130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28131   float jresult ;
28132   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28133   float result;
28134
28135   arg1 = (Dali::CameraActor *)jarg1;
28136   {
28137     try {
28138       result = (float)(arg1)->GetAspectRatio();
28139     } CALL_CATCH_EXCEPTION(0);
28140   }
28141
28142   jresult = result;
28143   return jresult;
28144 }
28145
28146
28147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28148   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28149   float arg2 ;
28150
28151   arg1 = (Dali::CameraActor *)jarg1;
28152   arg2 = (float)jarg2;
28153   {
28154     try {
28155       (arg1)->SetNearClippingPlane(arg2);
28156     } CALL_CATCH_EXCEPTION();
28157   }
28158
28159 }
28160
28161
28162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28163   float jresult ;
28164   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28165   float result;
28166
28167   arg1 = (Dali::CameraActor *)jarg1;
28168   {
28169     try {
28170       result = (float)(arg1)->GetNearClippingPlane();
28171     } CALL_CATCH_EXCEPTION(0);
28172   }
28173
28174   jresult = result;
28175   return jresult;
28176 }
28177
28178
28179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28180   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28181   float arg2 ;
28182
28183   arg1 = (Dali::CameraActor *)jarg1;
28184   arg2 = (float)jarg2;
28185   {
28186     try {
28187       (arg1)->SetFarClippingPlane(arg2);
28188     } CALL_CATCH_EXCEPTION();
28189   }
28190
28191 }
28192
28193
28194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28195   float jresult ;
28196   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28197   float result;
28198
28199   arg1 = (Dali::CameraActor *)jarg1;
28200   {
28201     try {
28202       result = (float)(arg1)->GetFarClippingPlane();
28203     } CALL_CATCH_EXCEPTION(0);
28204   }
28205
28206   jresult = result;
28207   return jresult;
28208 }
28209
28210
28211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28212   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28213   Dali::Vector3 *arg2 = 0 ;
28214
28215   arg1 = (Dali::CameraActor *)jarg1;
28216   arg2 = (Dali::Vector3 *)jarg2;
28217   if (!arg2) {
28218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28219     return ;
28220   }
28221   {
28222     try {
28223       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28224     } CALL_CATCH_EXCEPTION();
28225   }
28226
28227 }
28228
28229
28230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28231   void * jresult ;
28232   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28233   Dali::Vector3 result;
28234
28235   arg1 = (Dali::CameraActor *)jarg1;
28236   {
28237     try {
28238       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28239     } CALL_CATCH_EXCEPTION(0);
28240   }
28241
28242   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28243   return jresult;
28244 }
28245
28246
28247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28249   bool arg2 ;
28250
28251   arg1 = (Dali::CameraActor *)jarg1;
28252   arg2 = jarg2 ? true : false;
28253   {
28254     try {
28255       (arg1)->SetInvertYAxis(arg2);
28256     } CALL_CATCH_EXCEPTION();
28257   }
28258
28259 }
28260
28261
28262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28263   unsigned int jresult ;
28264   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28265   bool result;
28266
28267   arg1 = (Dali::CameraActor *)jarg1;
28268   {
28269     try {
28270       result = (bool)(arg1)->GetInvertYAxis();
28271     } CALL_CATCH_EXCEPTION(0);
28272   }
28273
28274   jresult = result;
28275   return jresult;
28276 }
28277
28278
28279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28280   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28281   Dali::Size *arg2 = 0 ;
28282
28283   arg1 = (Dali::CameraActor *)jarg1;
28284   arg2 = (Dali::Size *)jarg2;
28285   if (!arg2) {
28286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28287     return ;
28288   }
28289   {
28290     try {
28291       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28292     } CALL_CATCH_EXCEPTION();
28293   }
28294
28295 }
28296
28297
28298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28299   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28300   Dali::Size *arg2 = 0 ;
28301
28302   arg1 = (Dali::CameraActor *)jarg1;
28303   arg2 = (Dali::Size *)jarg2;
28304   if (!arg2) {
28305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28306     return ;
28307   }
28308   {
28309     try {
28310       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28311     } CALL_CATCH_EXCEPTION();
28312   }
28313
28314 }
28315
28316
28317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28318   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28319   float arg2 ;
28320   float arg3 ;
28321   float arg4 ;
28322   float arg5 ;
28323   float arg6 ;
28324   float arg7 ;
28325
28326   arg1 = (Dali::CameraActor *)jarg1;
28327   arg2 = (float)jarg2;
28328   arg3 = (float)jarg3;
28329   arg4 = (float)jarg4;
28330   arg5 = (float)jarg5;
28331   arg6 = (float)jarg6;
28332   arg7 = (float)jarg7;
28333   {
28334     try {
28335       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28336     } CALL_CATCH_EXCEPTION();
28337   }
28338
28339 }
28340
28341
28342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28343   void * jresult ;
28344   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28345
28346   {
28347     try {
28348       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28349     } CALL_CATCH_EXCEPTION(0);
28350   }
28351
28352   jresult = (void *)result;
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28358   void * jresult ;
28359   std::string arg1 ;
28360   Dali::Property::Value arg2 ;
28361   Dali::Property::Value *argp2 ;
28362   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28363
28364   if (!jarg1) {
28365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28366     return 0;
28367   }
28368   (&arg1)->assign(jarg1);
28369   argp2 = (Dali::Property::Value *)jarg2;
28370   if (!argp2) {
28371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28372     return 0;
28373   }
28374   arg2 = *argp2;
28375   {
28376     try {
28377       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28378     } CALL_CATCH_EXCEPTION(0);
28379   }
28380
28381   jresult = (void *)result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28387   void * jresult ;
28388   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28389   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28390
28391   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28392   if (!arg1) {
28393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28394     return 0;
28395   }
28396   {
28397     try {
28398       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);
28399     } CALL_CATCH_EXCEPTION(0);
28400   }
28401
28402   jresult = (void *)result;
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28408   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28409   std::string *arg2 = 0 ;
28410
28411   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28412   if (!jarg2) {
28413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28414     return ;
28415   }
28416   std::string arg2_str(jarg2);
28417   arg2 = &arg2_str;
28418   if (arg1) (arg1)->first = *arg2;
28419
28420   //argout typemap for const std::string&
28421
28422 }
28423
28424
28425 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28426   char * jresult ;
28427   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28428   std::string *result = 0 ;
28429
28430   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28431   result = (std::string *) & ((arg1)->first);
28432   jresult = SWIG_csharp_string_callback(result->c_str());
28433   return jresult;
28434 }
28435
28436
28437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28438   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28439   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28440
28441   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28442   arg2 = (Dali::Property::Value *)jarg2;
28443   if (arg1) (arg1)->second = *arg2;
28444 }
28445
28446
28447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28448   void * jresult ;
28449   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28450   Dali::Property::Value *result = 0 ;
28451
28452   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28453   result = (Dali::Property::Value *)& ((arg1)->second);
28454   jresult = (void *)result;
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28460   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28461
28462   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28463   {
28464     try {
28465       delete arg1;
28466     } CALL_CATCH_EXCEPTION();
28467   }
28468
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28473   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28474
28475   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28476   {
28477     try {
28478       (arg1)->clear();
28479     } CALL_CATCH_EXCEPTION();
28480   }
28481
28482 }
28483
28484
28485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28486   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28487   Dali::TouchPoint *arg2 = 0 ;
28488
28489   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28490   arg2 = (Dali::TouchPoint *)jarg2;
28491   if (!arg2) {
28492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28493     return ;
28494   }
28495   {
28496     try {
28497       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28498     } CALL_CATCH_EXCEPTION();
28499   }
28500
28501 }
28502
28503
28504 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28505   unsigned long jresult ;
28506   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28507   std::vector< Dali::TouchPoint >::size_type result;
28508
28509   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28510   {
28511     try {
28512       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28513     } CALL_CATCH_EXCEPTION(0);
28514   }
28515
28516   jresult = (unsigned long)result;
28517   return jresult;
28518 }
28519
28520
28521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
28522   unsigned long jresult ;
28523   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28524   std::vector< Dali::TouchPoint >::size_type result;
28525
28526   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28527   {
28528     try {
28529       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
28530     } CALL_CATCH_EXCEPTION(0);
28531   }
28532
28533   jresult = (unsigned long)result;
28534   return jresult;
28535 }
28536
28537
28538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28539   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28540   std::vector< Dali::TouchPoint >::size_type arg2 ;
28541
28542   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28543   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28544   {
28545     try {
28546       (arg1)->reserve(arg2);
28547     } CALL_CATCH_EXCEPTION();
28548   }
28549
28550 }
28551
28552
28553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28554   void * jresult ;
28555   std::vector< Dali::TouchPoint > *result = 0 ;
28556
28557   {
28558     try {
28559       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28560     } CALL_CATCH_EXCEPTION(0);
28561   }
28562
28563   jresult = (void *)result;
28564   return jresult;
28565 }
28566
28567
28568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28569   void * jresult ;
28570   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28571   std::vector< Dali::TouchPoint > *result = 0 ;
28572
28573   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28574   if (!arg1) {
28575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28576     return 0;
28577   }
28578   {
28579     try {
28580       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28581     } CALL_CATCH_EXCEPTION(0);
28582   }
28583
28584   jresult = (void *)result;
28585   return jresult;
28586 }
28587
28588
28589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28590   void * jresult ;
28591   int arg1 ;
28592   std::vector< Dali::TouchPoint > *result = 0 ;
28593
28594   arg1 = (int)jarg1;
28595   {
28596     try {
28597       try {
28598         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28599       }
28600       catch(std::out_of_range &_e) {
28601         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28602         return 0;
28603       }
28604
28605     } CALL_CATCH_EXCEPTION(0);
28606   }
28607
28608   jresult = (void *)result;
28609   return jresult;
28610 }
28611
28612
28613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28614   void * jresult ;
28615   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28616   int arg2 ;
28617   SwigValueWrapper< Dali::TouchPoint > result;
28618
28619   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28620   arg2 = (int)jarg2;
28621   {
28622     try {
28623       try {
28624         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28625       }
28626       catch(std::out_of_range &_e) {
28627         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28628         return 0;
28629       }
28630
28631     } CALL_CATCH_EXCEPTION(0);
28632   }
28633
28634   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28635   return jresult;
28636 }
28637
28638
28639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28640   void * jresult ;
28641   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28642   int arg2 ;
28643   Dali::TouchPoint *result = 0 ;
28644
28645   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28646   arg2 = (int)jarg2;
28647   {
28648     try {
28649       try {
28650         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28651       }
28652       catch(std::out_of_range &_e) {
28653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28654         return 0;
28655       }
28656
28657     } CALL_CATCH_EXCEPTION(0);
28658   }
28659
28660   jresult = (void *)result;
28661   return jresult;
28662 }
28663
28664
28665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28666   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28667   int arg2 ;
28668   Dali::TouchPoint *arg3 = 0 ;
28669
28670   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28671   arg2 = (int)jarg2;
28672   arg3 = (Dali::TouchPoint *)jarg3;
28673   if (!arg3) {
28674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28675     return ;
28676   }
28677   {
28678     try {
28679       try {
28680         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28681       }
28682       catch(std::out_of_range &_e) {
28683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28684         return ;
28685       }
28686
28687     } CALL_CATCH_EXCEPTION();
28688   }
28689
28690 }
28691
28692
28693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28694   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28695   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28696
28697   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28698   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28699   if (!arg2) {
28700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28701     return ;
28702   }
28703   {
28704     try {
28705       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28706     } CALL_CATCH_EXCEPTION();
28707   }
28708
28709 }
28710
28711
28712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28713   void * jresult ;
28714   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28715   int arg2 ;
28716   int arg3 ;
28717   std::vector< Dali::TouchPoint > *result = 0 ;
28718
28719   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28720   arg2 = (int)jarg2;
28721   arg3 = (int)jarg3;
28722   {
28723     try {
28724       try {
28725         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28726       }
28727       catch(std::out_of_range &_e) {
28728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28729         return 0;
28730       }
28731       catch(std::invalid_argument &_e) {
28732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28733         return 0;
28734       }
28735
28736     } CALL_CATCH_EXCEPTION(0);
28737   }
28738
28739   jresult = (void *)result;
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28745   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28746   int arg2 ;
28747   Dali::TouchPoint *arg3 = 0 ;
28748
28749   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28750   arg2 = (int)jarg2;
28751   arg3 = (Dali::TouchPoint *)jarg3;
28752   if (!arg3) {
28753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28754     return ;
28755   }
28756   {
28757     try {
28758       try {
28759         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28760       }
28761       catch(std::out_of_range &_e) {
28762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28763         return ;
28764       }
28765
28766     } CALL_CATCH_EXCEPTION();
28767   }
28768
28769 }
28770
28771
28772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28773   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28774   int arg2 ;
28775   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28776
28777   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28778   arg2 = (int)jarg2;
28779   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28780   if (!arg3) {
28781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28782     return ;
28783   }
28784   {
28785     try {
28786       try {
28787         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28788       }
28789       catch(std::out_of_range &_e) {
28790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28791         return ;
28792       }
28793
28794     } CALL_CATCH_EXCEPTION();
28795   }
28796
28797 }
28798
28799
28800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28801   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28802   int arg2 ;
28803
28804   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28805   arg2 = (int)jarg2;
28806   {
28807     try {
28808       try {
28809         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28810       }
28811       catch(std::out_of_range &_e) {
28812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28813         return ;
28814       }
28815
28816     } CALL_CATCH_EXCEPTION();
28817   }
28818
28819 }
28820
28821
28822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28824   int arg2 ;
28825   int arg3 ;
28826
28827   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28828   arg2 = (int)jarg2;
28829   arg3 = (int)jarg3;
28830   {
28831     try {
28832       try {
28833         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28834       }
28835       catch(std::out_of_range &_e) {
28836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28837         return ;
28838       }
28839       catch(std::invalid_argument &_e) {
28840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28841         return ;
28842       }
28843
28844     } CALL_CATCH_EXCEPTION();
28845   }
28846
28847 }
28848
28849
28850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
28851   void * jresult ;
28852   Dali::TouchPoint *arg1 = 0 ;
28853   int arg2 ;
28854   std::vector< Dali::TouchPoint > *result = 0 ;
28855
28856   arg1 = (Dali::TouchPoint *)jarg1;
28857   if (!arg1) {
28858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28859     return 0;
28860   }
28861   arg2 = (int)jarg2;
28862   {
28863     try {
28864       try {
28865         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
28866       }
28867       catch(std::out_of_range &_e) {
28868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28869         return 0;
28870       }
28871
28872     } CALL_CATCH_EXCEPTION(0);
28873   }
28874
28875   jresult = (void *)result;
28876   return jresult;
28877 }
28878
28879
28880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
28881   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28882
28883   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28884   {
28885     try {
28886       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
28887     } CALL_CATCH_EXCEPTION();
28888   }
28889
28890 }
28891
28892
28893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
28894   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28895   int arg2 ;
28896   int arg3 ;
28897
28898   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28899   arg2 = (int)jarg2;
28900   arg3 = (int)jarg3;
28901   {
28902     try {
28903       try {
28904         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
28905       }
28906       catch(std::out_of_range &_e) {
28907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28908         return ;
28909       }
28910       catch(std::invalid_argument &_e) {
28911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28912         return ;
28913       }
28914
28915     } CALL_CATCH_EXCEPTION();
28916   }
28917
28918 }
28919
28920
28921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
28922   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28923   int arg2 ;
28924   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28925
28926   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28927   arg2 = (int)jarg2;
28928   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28929   if (!arg3) {
28930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28931     return ;
28932   }
28933   {
28934     try {
28935       try {
28936         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28937       }
28938       catch(std::out_of_range &_e) {
28939         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28940         return ;
28941       }
28942
28943     } CALL_CATCH_EXCEPTION();
28944   }
28945
28946 }
28947
28948
28949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
28950   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28951
28952   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28953   {
28954     try {
28955       delete arg1;
28956     } CALL_CATCH_EXCEPTION();
28957   }
28958
28959 }
28960
28961
28962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
28963   void * jresult ;
28964   Dali::Rect< int > *result = 0 ;
28965
28966   {
28967     try {
28968       result = (Dali::Rect< int > *)new Dali::Rect< int >();
28969     } CALL_CATCH_EXCEPTION(0);
28970   }
28971
28972   jresult = (void *)result;
28973   return jresult;
28974 }
28975
28976
28977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
28978   void * jresult ;
28979   int arg1 ;
28980   int arg2 ;
28981   int arg3 ;
28982   int arg4 ;
28983   Dali::Rect< int > *result = 0 ;
28984
28985   arg1 = (int)jarg1;
28986   arg2 = (int)jarg2;
28987   arg3 = (int)jarg3;
28988   arg4 = (int)jarg4;
28989   {
28990     try {
28991       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
28992     } CALL_CATCH_EXCEPTION(0);
28993   }
28994
28995   jresult = (void *)result;
28996   return jresult;
28997 }
28998
28999
29000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29001   void * jresult ;
29002   Dali::Rect< int > *arg1 = 0 ;
29003   Dali::Rect< int > *result = 0 ;
29004
29005   arg1 = (Dali::Rect< int > *)jarg1;
29006   if (!arg1) {
29007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29008     return 0;
29009   }
29010   {
29011     try {
29012       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29013     } CALL_CATCH_EXCEPTION(0);
29014   }
29015
29016   jresult = (void *)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29022   void * jresult ;
29023   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29024   Dali::Rect< int > *arg2 = 0 ;
29025   Dali::Rect< int > *result = 0 ;
29026
29027   arg1 = (Dali::Rect< int > *)jarg1;
29028   arg2 = (Dali::Rect< int > *)jarg2;
29029   if (!arg2) {
29030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29031     return 0;
29032   }
29033   {
29034     try {
29035       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29036     } CALL_CATCH_EXCEPTION(0);
29037   }
29038
29039   jresult = (void *)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29045   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29046   int arg2 ;
29047   int arg3 ;
29048   int arg4 ;
29049   int arg5 ;
29050
29051   arg1 = (Dali::Rect< int > *)jarg1;
29052   arg2 = (int)jarg2;
29053   arg3 = (int)jarg3;
29054   arg4 = (int)jarg4;
29055   arg5 = (int)jarg5;
29056   {
29057     try {
29058       (arg1)->Set(arg2,arg3,arg4,arg5);
29059     } CALL_CATCH_EXCEPTION();
29060   }
29061
29062 }
29063
29064
29065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29066   unsigned int jresult ;
29067   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29068   bool result;
29069
29070   arg1 = (Dali::Rect< int > *)jarg1;
29071   {
29072     try {
29073       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29074     } CALL_CATCH_EXCEPTION(0);
29075   }
29076
29077   jresult = result;
29078   return jresult;
29079 }
29080
29081
29082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29083   int jresult ;
29084   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29085   int result;
29086
29087   arg1 = (Dali::Rect< int > *)jarg1;
29088   {
29089     try {
29090       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29091     } CALL_CATCH_EXCEPTION(0);
29092   }
29093
29094   jresult = result;
29095   return jresult;
29096 }
29097
29098
29099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
29100   int jresult ;
29101   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29102   int result;
29103
29104   arg1 = (Dali::Rect< int > *)jarg1;
29105   {
29106     try {
29107       result = (int)((Dali::Rect< int > const *)arg1)->Right();
29108     } CALL_CATCH_EXCEPTION(0);
29109   }
29110
29111   jresult = result;
29112   return jresult;
29113 }
29114
29115
29116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
29117   int jresult ;
29118   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29119   int result;
29120
29121   arg1 = (Dali::Rect< int > *)jarg1;
29122   {
29123     try {
29124       result = (int)((Dali::Rect< int > const *)arg1)->Top();
29125     } CALL_CATCH_EXCEPTION(0);
29126   }
29127
29128   jresult = result;
29129   return jresult;
29130 }
29131
29132
29133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
29134   int jresult ;
29135   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29136   int result;
29137
29138   arg1 = (Dali::Rect< int > *)jarg1;
29139   {
29140     try {
29141       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
29142     } CALL_CATCH_EXCEPTION(0);
29143   }
29144
29145   jresult = result;
29146   return jresult;
29147 }
29148
29149
29150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
29151   int jresult ;
29152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29153   int result;
29154
29155   arg1 = (Dali::Rect< int > *)jarg1;
29156   {
29157     try {
29158       result = (int)((Dali::Rect< int > const *)arg1)->Area();
29159     } CALL_CATCH_EXCEPTION(0);
29160   }
29161
29162   jresult = result;
29163   return jresult;
29164 }
29165
29166
29167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29168   unsigned int jresult ;
29169   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29170   Dali::Rect< int > *arg2 = 0 ;
29171   bool result;
29172
29173   arg1 = (Dali::Rect< int > *)jarg1;
29174   arg2 = (Dali::Rect< int > *)jarg2;
29175   if (!arg2) {
29176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29177     return 0;
29178   }
29179   {
29180     try {
29181       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29182     } CALL_CATCH_EXCEPTION(0);
29183   }
29184
29185   jresult = result;
29186   return jresult;
29187 }
29188
29189
29190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29191   unsigned int jresult ;
29192   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29193   Dali::Rect< int > *arg2 = 0 ;
29194   bool result;
29195
29196   arg1 = (Dali::Rect< int > *)jarg1;
29197   arg2 = (Dali::Rect< int > *)jarg2;
29198   if (!arg2) {
29199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29200     return 0;
29201   }
29202   {
29203     try {
29204       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29205     } CALL_CATCH_EXCEPTION(0);
29206   }
29207
29208   jresult = result;
29209   return jresult;
29210 }
29211
29212
29213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29214   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29215   int arg2 ;
29216
29217   arg1 = (Dali::Rect< int > *)jarg1;
29218   arg2 = (int)jarg2;
29219   if (arg1) (arg1)->x = arg2;
29220 }
29221
29222
29223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29224   int jresult ;
29225   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29226   int result;
29227
29228   arg1 = (Dali::Rect< int > *)jarg1;
29229   result = (int) ((arg1)->x);
29230   jresult = result;
29231   return jresult;
29232 }
29233
29234
29235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29236   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29237   int arg2 ;
29238
29239   arg1 = (Dali::Rect< int > *)jarg1;
29240   arg2 = (int)jarg2;
29241   if (arg1) (arg1)->left = arg2;
29242 }
29243
29244
29245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29246   int jresult ;
29247   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29248   int result;
29249
29250   arg1 = (Dali::Rect< int > *)jarg1;
29251   result = (int) ((arg1)->left);
29252   jresult = result;
29253   return jresult;
29254 }
29255
29256
29257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29258   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29259   int arg2 ;
29260
29261   arg1 = (Dali::Rect< int > *)jarg1;
29262   arg2 = (int)jarg2;
29263   if (arg1) (arg1)->y = arg2;
29264 }
29265
29266
29267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29268   int jresult ;
29269   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29270   int result;
29271
29272   arg1 = (Dali::Rect< int > *)jarg1;
29273   result = (int) ((arg1)->y);
29274   jresult = result;
29275   return jresult;
29276 }
29277
29278
29279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29281   int arg2 ;
29282
29283   arg1 = (Dali::Rect< int > *)jarg1;
29284   arg2 = (int)jarg2;
29285   if (arg1) (arg1)->right = arg2;
29286 }
29287
29288
29289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29290   int jresult ;
29291   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29292   int result;
29293
29294   arg1 = (Dali::Rect< int > *)jarg1;
29295   result = (int) ((arg1)->right);
29296   jresult = result;
29297   return jresult;
29298 }
29299
29300
29301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29302   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29303   int arg2 ;
29304
29305   arg1 = (Dali::Rect< int > *)jarg1;
29306   arg2 = (int)jarg2;
29307   if (arg1) (arg1)->width = arg2;
29308 }
29309
29310
29311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29312   int jresult ;
29313   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29314   int result;
29315
29316   arg1 = (Dali::Rect< int > *)jarg1;
29317   result = (int) ((arg1)->width);
29318   jresult = result;
29319   return jresult;
29320 }
29321
29322
29323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29324   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29325   int arg2 ;
29326
29327   arg1 = (Dali::Rect< int > *)jarg1;
29328   arg2 = (int)jarg2;
29329   if (arg1) (arg1)->bottom = arg2;
29330 }
29331
29332
29333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29334   int jresult ;
29335   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29336   int result;
29337
29338   arg1 = (Dali::Rect< int > *)jarg1;
29339   result = (int) ((arg1)->bottom);
29340   jresult = result;
29341   return jresult;
29342 }
29343
29344
29345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29346   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29347   int arg2 ;
29348
29349   arg1 = (Dali::Rect< int > *)jarg1;
29350   arg2 = (int)jarg2;
29351   if (arg1) (arg1)->height = arg2;
29352 }
29353
29354
29355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29356   int jresult ;
29357   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29358   int result;
29359
29360   arg1 = (Dali::Rect< int > *)jarg1;
29361   result = (int) ((arg1)->height);
29362   jresult = result;
29363   return jresult;
29364 }
29365
29366
29367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29368   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29369   int arg2 ;
29370
29371   arg1 = (Dali::Rect< int > *)jarg1;
29372   arg2 = (int)jarg2;
29373   if (arg1) (arg1)->top = arg2;
29374 }
29375
29376
29377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29378   int jresult ;
29379   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29380   int result;
29381
29382   arg1 = (Dali::Rect< int > *)jarg1;
29383   result = (int) ((arg1)->top);
29384   jresult = result;
29385   return jresult;
29386 }
29387
29388
29389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29390   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29391
29392   arg1 = (Dali::Rect< int > *)jarg1;
29393   {
29394     try {
29395       delete arg1;
29396     } CALL_CATCH_EXCEPTION();
29397   }
29398
29399 }
29400
29401
29402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29403   void * jresult ;
29404   Dali::Rect< float > *result = 0 ;
29405
29406   {
29407     try {
29408       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29409     } CALL_CATCH_EXCEPTION(0);
29410   }
29411
29412   jresult = (void *)result;
29413   return jresult;
29414 }
29415
29416
29417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29418   void * jresult ;
29419   float arg1 ;
29420   float arg2 ;
29421   float arg3 ;
29422   float arg4 ;
29423   Dali::Rect< float > *result = 0 ;
29424
29425   arg1 = (float)jarg1;
29426   arg2 = (float)jarg2;
29427   arg3 = (float)jarg4;
29428   arg4 = (float)jarg3;
29429   {
29430     try {
29431       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29432     } CALL_CATCH_EXCEPTION(0);
29433   }
29434
29435   jresult = (void *)result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29441   void * jresult ;
29442   Dali::Rect< float > *arg1 = 0 ;
29443   Dali::Rect< float > *result = 0 ;
29444
29445   arg1 = (Dali::Rect< float > *)jarg1;
29446   if (!arg1) {
29447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29448     return 0;
29449   }
29450   {
29451     try {
29452       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29453     } CALL_CATCH_EXCEPTION(0);
29454   }
29455
29456   jresult = (void *)result;
29457   return jresult;
29458 }
29459
29460
29461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29462   void * jresult ;
29463   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29464   Dali::Rect< float > *arg2 = 0 ;
29465   Dali::Rect< float > *result = 0 ;
29466
29467   arg1 = (Dali::Rect< float > *)jarg1;
29468   arg2 = (Dali::Rect< float > *)jarg2;
29469   if (!arg2) {
29470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29471     return 0;
29472   }
29473   {
29474     try {
29475       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29476     } CALL_CATCH_EXCEPTION(0);
29477   }
29478
29479   jresult = (void *)result;
29480   return jresult;
29481 }
29482
29483
29484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29485   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29486   float arg2 ;
29487   float arg3 ;
29488   float arg4 ;
29489   float arg5 ;
29490
29491   arg1 = (Dali::Rect< float > *)jarg1;
29492   arg2 = (float)jarg2;
29493   arg3 = (float)jarg3;
29494   arg4 = (float)jarg5;
29495   arg5 = (float)jarg4;
29496   {
29497     try {
29498       (arg1)->Set(arg2,arg3,arg4,arg5);
29499     } CALL_CATCH_EXCEPTION();
29500   }
29501
29502 }
29503
29504
29505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29506   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29507   float arg2 ;
29508
29509   arg1 = (Dali::Rect< float > *)jarg1;
29510   arg2 = (float)jarg2;
29511   if (arg1) (arg1)->left = arg2;
29512 }
29513
29514
29515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29516   float jresult ;
29517   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29518   float result;
29519
29520   arg1 = (Dali::Rect< float > *)jarg1;
29521   result = (float) ((arg1)->left);
29522   jresult = result;
29523   return jresult;
29524 }
29525
29526
29527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29528   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29529   float arg2 ;
29530
29531   arg1 = (Dali::Rect< float > *)jarg1;
29532   arg2 = (float)jarg2;
29533   if (arg1) (arg1)->left = arg2;
29534 }
29535
29536
29537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29538   float jresult ;
29539   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29540   float result;
29541
29542   arg1 = (Dali::Rect< float > *)jarg1;
29543   result = (float) ((arg1)->left);
29544   jresult = result;
29545   return jresult;
29546 }
29547
29548
29549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29550   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29551   float arg2 ;
29552
29553   arg1 = (Dali::Rect< float > *)jarg1;
29554   arg2 = (float)jarg2;
29555   if (arg1) (arg1)->right = arg2;
29556 }
29557
29558
29559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29560   float jresult ;
29561   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29562   float result;
29563
29564   arg1 = (Dali::Rect< float > *)jarg1;
29565   result = (float) ((arg1)->right);
29566   jresult = result;
29567   return jresult;
29568 }
29569
29570
29571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29572   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29573   float arg2 ;
29574
29575   arg1 = (Dali::Rect< float > *)jarg1;
29576   arg2 = (float)jarg2;
29577   if (arg1) (arg1)->right = arg2;
29578 }
29579
29580
29581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29582   float jresult ;
29583   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29584   float result;
29585
29586   arg1 = (Dali::Rect< float > *)jarg1;
29587   result = (float) ((arg1)->right);
29588   jresult = result;
29589   return jresult;
29590 }
29591
29592
29593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29594   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29595   float arg2 ;
29596
29597   arg1 = (Dali::Rect< float > *)jarg1;
29598   arg2 = (float)jarg2;
29599   if (arg1) (arg1)->bottom = arg2;
29600 }
29601
29602
29603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29604   float jresult ;
29605   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29606   float result;
29607
29608   arg1 = (Dali::Rect< float > *)jarg1;
29609   result = (float) ((arg1)->bottom);
29610   jresult = result;
29611   return jresult;
29612 }
29613
29614
29615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29616   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29617   float arg2 ;
29618
29619   arg1 = (Dali::Rect< float > *)jarg1;
29620   arg2 = (float)jarg2;
29621   if (arg1) (arg1)->top = arg2;
29622 }
29623
29624
29625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29626   float jresult ;
29627   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29628   float result;
29629
29630   arg1 = (Dali::Rect< float > *)jarg1;
29631   result = (float) ((arg1)->top);
29632   jresult = result;
29633   return jresult;
29634 }
29635
29636
29637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29638   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29639
29640   arg1 = (Dali::Rect< float > *)jarg1;
29641   {
29642     try {
29643       delete arg1;
29644     } CALL_CATCH_EXCEPTION();
29645   }
29646
29647 }
29648
29649
29650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29651   int jresult ;
29652   int result;
29653
29654   result = (int)Dali::Vector< int >::BaseType;
29655   jresult = (int)result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29661   void * jresult ;
29662   Dali::Vector< int > *result = 0 ;
29663
29664   {
29665     try {
29666       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29667     } CALL_CATCH_EXCEPTION(0);
29668   }
29669
29670   jresult = (void *)result;
29671   return jresult;
29672 }
29673
29674
29675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29676   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29677
29678   arg1 = (Dali::Vector< int > *)jarg1;
29679   {
29680     try {
29681       delete arg1;
29682     } CALL_CATCH_EXCEPTION();
29683   }
29684
29685 }
29686
29687
29688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29689   void * jresult ;
29690   Dali::Vector< int > *arg1 = 0 ;
29691   Dali::Vector< int > *result = 0 ;
29692
29693   arg1 = (Dali::Vector< int > *)jarg1;
29694   if (!arg1) {
29695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29696     return 0;
29697   }
29698   {
29699     try {
29700       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29701     } CALL_CATCH_EXCEPTION(0);
29702   }
29703
29704   jresult = (void *)result;
29705   return jresult;
29706 }
29707
29708
29709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29710   void * jresult ;
29711   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29712   Dali::Vector< int > *arg2 = 0 ;
29713   Dali::Vector< int > *result = 0 ;
29714
29715   arg1 = (Dali::Vector< int > *)jarg1;
29716   arg2 = (Dali::Vector< int > *)jarg2;
29717   if (!arg2) {
29718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29719     return 0;
29720   }
29721   {
29722     try {
29723       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29724     } CALL_CATCH_EXCEPTION(0);
29725   }
29726
29727   jresult = (void *)result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29733   void * jresult ;
29734   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29735   Dali::Vector< int >::Iterator result;
29736
29737   arg1 = (Dali::Vector< int > *)jarg1;
29738   {
29739     try {
29740       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29741     } CALL_CATCH_EXCEPTION(0);
29742   }
29743
29744   jresult = (void *)result;
29745   return jresult;
29746 }
29747
29748
29749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
29750   void * jresult ;
29751   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29752   Dali::Vector< int >::Iterator result;
29753
29754   arg1 = (Dali::Vector< int > *)jarg1;
29755   {
29756     try {
29757       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
29758     } CALL_CATCH_EXCEPTION(0);
29759   }
29760
29761   jresult = (void *)result;
29762   return jresult;
29763 }
29764
29765
29766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29767   void * jresult ;
29768   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29769   Dali::Vector< int >::SizeType arg2 ;
29770   Dali::Vector< int >::ItemType *result = 0 ;
29771
29772   arg1 = (Dali::Vector< int > *)jarg1;
29773   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29774   {
29775     try {
29776       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29777     } CALL_CATCH_EXCEPTION(0);
29778   }
29779
29780   jresult = (void *)result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29786   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29787   Dali::Vector< int >::ItemType *arg2 = 0 ;
29788   Dali::Vector< int >::ItemType temp2 ;
29789
29790   arg1 = (Dali::Vector< int > *)jarg1;
29791   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29792   arg2 = &temp2;
29793   {
29794     try {
29795       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29796     } CALL_CATCH_EXCEPTION();
29797   }
29798
29799 }
29800
29801
29802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29803   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29804   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29805   Dali::Vector< int >::ItemType *arg3 = 0 ;
29806   Dali::Vector< int >::ItemType temp3 ;
29807
29808   arg1 = (Dali::Vector< int > *)jarg1;
29809   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29810   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29811   arg3 = &temp3;
29812   {
29813     try {
29814       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29815     } CALL_CATCH_EXCEPTION();
29816   }
29817
29818 }
29819
29820
29821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29822   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29823   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29824   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29825   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29826
29827   arg1 = (Dali::Vector< int > *)jarg1;
29828   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29829   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29830   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29831   {
29832     try {
29833       (arg1)->Insert(arg2,arg3,arg4);
29834     } CALL_CATCH_EXCEPTION();
29835   }
29836
29837 }
29838
29839
29840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29841   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29842   Dali::Vector< int >::SizeType arg2 ;
29843
29844   arg1 = (Dali::Vector< int > *)jarg1;
29845   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29846   {
29847     try {
29848       (arg1)->Reserve(arg2);
29849     } CALL_CATCH_EXCEPTION();
29850   }
29851
29852 }
29853
29854
29855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
29856   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29857   Dali::Vector< int >::SizeType arg2 ;
29858
29859   arg1 = (Dali::Vector< int > *)jarg1;
29860   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29861   {
29862     try {
29863       (arg1)->Resize(arg2);
29864     } CALL_CATCH_EXCEPTION();
29865   }
29866
29867 }
29868
29869
29870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
29871   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29872   Dali::Vector< int >::SizeType arg2 ;
29873   Dali::Vector< int >::ItemType *arg3 = 0 ;
29874   Dali::Vector< int >::ItemType temp3 ;
29875
29876   arg1 = (Dali::Vector< int > *)jarg1;
29877   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29878   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29879   arg3 = &temp3;
29880   {
29881     try {
29882       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29883     } CALL_CATCH_EXCEPTION();
29884   }
29885
29886 }
29887
29888
29889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
29890   void * jresult ;
29891   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29892   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29893   Dali::Vector< int >::Iterator result;
29894
29895   arg1 = (Dali::Vector< int > *)jarg1;
29896   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29897   {
29898     try {
29899       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
29900     } CALL_CATCH_EXCEPTION(0);
29901   }
29902
29903   jresult = (void *)result;
29904   return jresult;
29905 }
29906
29907
29908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
29909   void * jresult ;
29910   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29911   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29912   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29913   Dali::Vector< int >::Iterator result;
29914
29915   arg1 = (Dali::Vector< int > *)jarg1;
29916   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29917   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29918   {
29919     try {
29920       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
29921     } CALL_CATCH_EXCEPTION(0);
29922   }
29923
29924   jresult = (void *)result;
29925   return jresult;
29926 }
29927
29928
29929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
29930   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29931   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29932
29933   arg1 = (Dali::Vector< int > *)jarg1;
29934   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29935   {
29936     try {
29937       (arg1)->Remove(arg2);
29938     } CALL_CATCH_EXCEPTION();
29939   }
29940
29941 }
29942
29943
29944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
29945   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29946   Dali::Vector< int > *arg2 = 0 ;
29947
29948   arg1 = (Dali::Vector< int > *)jarg1;
29949   arg2 = (Dali::Vector< int > *)jarg2;
29950   if (!arg2) {
29951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
29952     return ;
29953   }
29954   {
29955     try {
29956       (arg1)->Swap(*arg2);
29957     } CALL_CATCH_EXCEPTION();
29958   }
29959
29960 }
29961
29962
29963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
29964   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29965
29966   arg1 = (Dali::Vector< int > *)jarg1;
29967   {
29968     try {
29969       (arg1)->Clear();
29970     } CALL_CATCH_EXCEPTION();
29971   }
29972
29973 }
29974
29975
29976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
29977   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29978
29979   arg1 = (Dali::Vector< int > *)jarg1;
29980   {
29981     try {
29982       (arg1)->Release();
29983     } CALL_CATCH_EXCEPTION();
29984   }
29985
29986 }
29987
29988
29989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
29990   int jresult ;
29991   int result;
29992
29993   result = (int)Dali::Vector< float >::BaseType;
29994   jresult = (int)result;
29995   return jresult;
29996 }
29997
29998
29999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30000   void * jresult ;
30001   Dali::Vector< float > *result = 0 ;
30002
30003   {
30004     try {
30005       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30006     } CALL_CATCH_EXCEPTION(0);
30007   }
30008
30009   jresult = (void *)result;
30010   return jresult;
30011 }
30012
30013
30014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30015   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30016
30017   arg1 = (Dali::Vector< float > *)jarg1;
30018   {
30019     try {
30020       delete arg1;
30021     } CALL_CATCH_EXCEPTION();
30022   }
30023
30024 }
30025
30026
30027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30028   void * jresult ;
30029   Dali::Vector< float > *arg1 = 0 ;
30030   Dali::Vector< float > *result = 0 ;
30031
30032   arg1 = (Dali::Vector< float > *)jarg1;
30033   if (!arg1) {
30034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30035     return 0;
30036   }
30037   {
30038     try {
30039       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30040     } CALL_CATCH_EXCEPTION(0);
30041   }
30042
30043   jresult = (void *)result;
30044   return jresult;
30045 }
30046
30047
30048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30049   void * jresult ;
30050   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30051   Dali::Vector< float > *arg2 = 0 ;
30052   Dali::Vector< float > *result = 0 ;
30053
30054   arg1 = (Dali::Vector< float > *)jarg1;
30055   arg2 = (Dali::Vector< float > *)jarg2;
30056   if (!arg2) {
30057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30058     return 0;
30059   }
30060   {
30061     try {
30062       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30063     } CALL_CATCH_EXCEPTION(0);
30064   }
30065
30066   jresult = (void *)result;
30067   return jresult;
30068 }
30069
30070
30071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30072   void * jresult ;
30073   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30074   Dali::Vector< float >::Iterator result;
30075
30076   arg1 = (Dali::Vector< float > *)jarg1;
30077   {
30078     try {
30079       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30080     } CALL_CATCH_EXCEPTION(0);
30081   }
30082
30083   jresult = (void *)result;
30084   return jresult;
30085 }
30086
30087
30088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
30089   void * jresult ;
30090   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30091   Dali::Vector< float >::Iterator result;
30092
30093   arg1 = (Dali::Vector< float > *)jarg1;
30094   {
30095     try {
30096       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
30097     } CALL_CATCH_EXCEPTION(0);
30098   }
30099
30100   jresult = (void *)result;
30101   return jresult;
30102 }
30103
30104
30105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30106   void * jresult ;
30107   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30108   Dali::Vector< float >::SizeType arg2 ;
30109   Dali::Vector< float >::ItemType *result = 0 ;
30110
30111   arg1 = (Dali::Vector< float > *)jarg1;
30112   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30113   {
30114     try {
30115       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30116     } CALL_CATCH_EXCEPTION(0);
30117   }
30118
30119   jresult = (void *)result;
30120   return jresult;
30121 }
30122
30123
30124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30125   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30126   Dali::Vector< float >::ItemType *arg2 = 0 ;
30127   Dali::Vector< float >::ItemType temp2 ;
30128
30129   arg1 = (Dali::Vector< float > *)jarg1;
30130   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30131   arg2 = &temp2;
30132   {
30133     try {
30134       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30135     } CALL_CATCH_EXCEPTION();
30136   }
30137
30138 }
30139
30140
30141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30142   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30143   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30144   Dali::Vector< float >::ItemType *arg3 = 0 ;
30145   Dali::Vector< float >::ItemType temp3 ;
30146
30147   arg1 = (Dali::Vector< float > *)jarg1;
30148   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30149   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30150   arg3 = &temp3;
30151   {
30152     try {
30153       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30154     } CALL_CATCH_EXCEPTION();
30155   }
30156
30157 }
30158
30159
30160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30161   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30162   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30163   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30164   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30165
30166   arg1 = (Dali::Vector< float > *)jarg1;
30167   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30168   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30169   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30170   {
30171     try {
30172       (arg1)->Insert(arg2,arg3,arg4);
30173     } CALL_CATCH_EXCEPTION();
30174   }
30175
30176 }
30177
30178
30179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30180   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30181   Dali::Vector< float >::SizeType arg2 ;
30182
30183   arg1 = (Dali::Vector< float > *)jarg1;
30184   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30185   {
30186     try {
30187       (arg1)->Reserve(arg2);
30188     } CALL_CATCH_EXCEPTION();
30189   }
30190
30191 }
30192
30193 //// ========================= end of part 2 =============================
30194
30195 //// ========================== start part 3 ===============================
30196
30197
30198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30199   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30200   Dali::Vector< float >::SizeType arg2 ;
30201
30202   arg1 = (Dali::Vector< float > *)jarg1;
30203   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30204   {
30205     try {
30206       (arg1)->Resize(arg2);
30207     } CALL_CATCH_EXCEPTION();
30208   }
30209
30210 }
30211
30212
30213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30214   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30215   Dali::Vector< float >::SizeType arg2 ;
30216   Dali::Vector< float >::ItemType *arg3 = 0 ;
30217   Dali::Vector< float >::ItemType temp3 ;
30218
30219   arg1 = (Dali::Vector< float > *)jarg1;
30220   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30221   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30222   arg3 = &temp3;
30223   {
30224     try {
30225       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30226     } CALL_CATCH_EXCEPTION();
30227   }
30228
30229 }
30230
30231
30232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30233   void * jresult ;
30234   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30235   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30236   Dali::Vector< float >::Iterator result;
30237
30238   arg1 = (Dali::Vector< float > *)jarg1;
30239   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30240   {
30241     try {
30242       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30243     } CALL_CATCH_EXCEPTION(0);
30244   }
30245
30246   jresult = (void *)result;
30247   return jresult;
30248 }
30249
30250
30251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30252   void * jresult ;
30253   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30254   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30255   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30256   Dali::Vector< float >::Iterator result;
30257
30258   arg1 = (Dali::Vector< float > *)jarg1;
30259   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30260   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30261   {
30262     try {
30263       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30264     } CALL_CATCH_EXCEPTION(0);
30265   }
30266
30267   jresult = (void *)result;
30268   return jresult;
30269 }
30270
30271
30272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30273   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30274   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30275
30276   arg1 = (Dali::Vector< float > *)jarg1;
30277   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30278   {
30279     try {
30280       (arg1)->Remove(arg2);
30281     } CALL_CATCH_EXCEPTION();
30282   }
30283
30284 }
30285
30286
30287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30288   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30289   Dali::Vector< float > *arg2 = 0 ;
30290
30291   arg1 = (Dali::Vector< float > *)jarg1;
30292   arg2 = (Dali::Vector< float > *)jarg2;
30293   if (!arg2) {
30294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30295     return ;
30296   }
30297   {
30298     try {
30299       (arg1)->Swap(*arg2);
30300     } CALL_CATCH_EXCEPTION();
30301   }
30302
30303 }
30304
30305
30306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30307   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30308
30309   arg1 = (Dali::Vector< float > *)jarg1;
30310   {
30311     try {
30312       (arg1)->Clear();
30313     } CALL_CATCH_EXCEPTION();
30314   }
30315
30316 }
30317
30318
30319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30320   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30321
30322   arg1 = (Dali::Vector< float > *)jarg1;
30323   {
30324     try {
30325       (arg1)->Release();
30326     } CALL_CATCH_EXCEPTION();
30327   }
30328
30329 }
30330
30331
30332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30333   int jresult ;
30334   int result;
30335
30336   result = (int)Dali::Vector< unsigned char >::BaseType;
30337   jresult = (int)result;
30338   return jresult;
30339 }
30340
30341
30342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30343   void * jresult ;
30344   Dali::Vector< unsigned char > *result = 0 ;
30345
30346   {
30347     try {
30348       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30349     } CALL_CATCH_EXCEPTION(0);
30350   }
30351
30352   jresult = (void *)result;
30353   return jresult;
30354 }
30355
30356
30357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30358   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30359
30360   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30361   {
30362     try {
30363       delete arg1;
30364     } CALL_CATCH_EXCEPTION();
30365   }
30366
30367 }
30368
30369
30370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30371   void * jresult ;
30372   Dali::Vector< unsigned char > *arg1 = 0 ;
30373   Dali::Vector< unsigned char > *result = 0 ;
30374
30375   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30376   if (!arg1) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30378     return 0;
30379   }
30380   {
30381     try {
30382       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30383     } CALL_CATCH_EXCEPTION(0);
30384   }
30385
30386   jresult = (void *)result;
30387   return jresult;
30388 }
30389
30390
30391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30392   void * jresult ;
30393   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30394   Dali::Vector< unsigned char > *arg2 = 0 ;
30395   Dali::Vector< unsigned char > *result = 0 ;
30396
30397   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30398   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30399   if (!arg2) {
30400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30401     return 0;
30402   }
30403   {
30404     try {
30405       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30406     } CALL_CATCH_EXCEPTION(0);
30407   }
30408
30409   jresult = (void *)result;
30410   return jresult;
30411 }
30412
30413
30414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30415   void * jresult ;
30416   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30417   Dali::Vector< unsigned char >::Iterator result;
30418
30419   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30420   {
30421     try {
30422       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30423     } CALL_CATCH_EXCEPTION(0);
30424   }
30425
30426   jresult = (void *)result;
30427   return jresult;
30428 }
30429
30430
30431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
30432   void * jresult ;
30433   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30434   Dali::Vector< unsigned char >::Iterator result;
30435
30436   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30437   {
30438     try {
30439       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
30440     } CALL_CATCH_EXCEPTION(0);
30441   }
30442
30443   jresult = (void *)result;
30444   return jresult;
30445 }
30446
30447
30448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30449   void * jresult ;
30450   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30451   Dali::Vector< unsigned char >::SizeType arg2 ;
30452   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30453
30454   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30455   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30456   {
30457     try {
30458       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30459     } CALL_CATCH_EXCEPTION(0);
30460   }
30461
30462   jresult = (void *)result;
30463   return jresult;
30464 }
30465
30466
30467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30468   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30469   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30470   Dali::Vector< unsigned char >::ItemType temp2 ;
30471
30472   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30473   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30474   arg2 = &temp2;
30475   {
30476     try {
30477       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30478     } CALL_CATCH_EXCEPTION();
30479   }
30480
30481 }
30482
30483
30484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30486   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30487   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30488   Dali::Vector< unsigned char >::ItemType temp3 ;
30489
30490   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30491   arg2 = jarg2;
30492   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30493   arg3 = &temp3;
30494   {
30495     try {
30496       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30497     } CALL_CATCH_EXCEPTION();
30498   }
30499
30500
30501
30502 }
30503
30504
30505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30506   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30507   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30508   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30509   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30510
30511   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30512   arg2 = jarg2;
30513   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30514   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30515   {
30516     try {
30517       (arg1)->Insert(arg2,arg3,arg4);
30518     } CALL_CATCH_EXCEPTION();
30519   }
30520
30521
30522
30523 }
30524
30525
30526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30527   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30528   Dali::Vector< unsigned char >::SizeType arg2 ;
30529
30530   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30531   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30532   {
30533     try {
30534       (arg1)->Reserve(arg2);
30535     } CALL_CATCH_EXCEPTION();
30536   }
30537
30538 }
30539
30540
30541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30543   Dali::Vector< unsigned char >::SizeType arg2 ;
30544
30545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30546   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30547   {
30548     try {
30549       (arg1)->Resize(arg2);
30550     } CALL_CATCH_EXCEPTION();
30551   }
30552
30553 }
30554
30555
30556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30557   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30558   Dali::Vector< unsigned char >::SizeType arg2 ;
30559   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30560   Dali::Vector< unsigned char >::ItemType temp3 ;
30561
30562   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30563   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30564   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30565   arg3 = &temp3;
30566   {
30567     try {
30568       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30569     } CALL_CATCH_EXCEPTION();
30570   }
30571
30572 }
30573
30574
30575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30576   void * jresult ;
30577   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30578   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30579   Dali::Vector< unsigned char >::Iterator result;
30580
30581   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30582   arg2 = jarg2;
30583   {
30584     try {
30585       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30586     } CALL_CATCH_EXCEPTION(0);
30587   }
30588
30589   jresult = (void *)result;
30590
30591
30592   return jresult;
30593 }
30594
30595
30596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30597   void * jresult ;
30598   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30599   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30600   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30601   Dali::Vector< unsigned char >::Iterator result;
30602
30603   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30604   arg2 = jarg2;
30605   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30606   {
30607     try {
30608       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30609     } CALL_CATCH_EXCEPTION(0);
30610   }
30611
30612   jresult = (void *)result;
30613
30614
30615   return jresult;
30616 }
30617
30618
30619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30621   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30622
30623   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30624   arg2 = jarg2;
30625   {
30626     try {
30627       (arg1)->Remove(arg2);
30628     } CALL_CATCH_EXCEPTION();
30629   }
30630
30631
30632
30633 }
30634
30635
30636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30637   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30638   Dali::Vector< unsigned char > *arg2 = 0 ;
30639
30640   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30641   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30642   if (!arg2) {
30643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30644     return ;
30645   }
30646   {
30647     try {
30648       (arg1)->Swap(*arg2);
30649     } CALL_CATCH_EXCEPTION();
30650   }
30651
30652 }
30653
30654
30655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30656   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30657
30658   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30659   {
30660     try {
30661       (arg1)->Clear();
30662     } CALL_CATCH_EXCEPTION();
30663   }
30664
30665 }
30666
30667
30668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30669   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30670
30671   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30672   {
30673     try {
30674       (arg1)->Release();
30675     } CALL_CATCH_EXCEPTION();
30676   }
30677
30678 }
30679
30680
30681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30682   int jresult ;
30683   int result;
30684
30685   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30686   jresult = (int)result;
30687   return jresult;
30688 }
30689
30690
30691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30692   void * jresult ;
30693   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30694
30695   {
30696     try {
30697       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30698     } CALL_CATCH_EXCEPTION(0);
30699   }
30700
30701   jresult = (void *)result;
30702   return jresult;
30703 }
30704
30705
30706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30707   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30708
30709   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30710   {
30711     try {
30712       delete arg1;
30713     } CALL_CATCH_EXCEPTION();
30714   }
30715
30716 }
30717
30718
30719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30720   void * jresult ;
30721   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30722   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30723
30724   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30725   if (!arg1) {
30726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30727     return 0;
30728   }
30729   {
30730     try {
30731       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30732     } CALL_CATCH_EXCEPTION(0);
30733   }
30734
30735   jresult = (void *)result;
30736   return jresult;
30737 }
30738
30739
30740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30741   void * jresult ;
30742   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30743   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30744   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30745
30746   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30747   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30748   if (!arg2) {
30749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30750     return 0;
30751   }
30752   {
30753     try {
30754       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30755     } CALL_CATCH_EXCEPTION(0);
30756   }
30757
30758   jresult = (void *)result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30764   void * jresult ;
30765   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30766   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30767
30768   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30769   {
30770     try {
30771       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30772     } CALL_CATCH_EXCEPTION(0);
30773   }
30774
30775   jresult = (void *)result;
30776   return jresult;
30777 }
30778
30779
30780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
30781   void * jresult ;
30782   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30783   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30784
30785   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30786   {
30787     try {
30788       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
30789     } CALL_CATCH_EXCEPTION(0);
30790   }
30791
30792   jresult = (void *)result;
30793   return jresult;
30794 }
30795
30796
30797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30798   void * jresult ;
30799   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30800   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30801   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30802
30803   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30804   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30805   {
30806     try {
30807       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30808     } CALL_CATCH_EXCEPTION(0);
30809   }
30810
30811   jresult = (void *)result;
30812   return jresult;
30813 }
30814
30815
30816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30817   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30818   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30819
30820   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30821   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30822   if (!arg2) {
30823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30824     return ;
30825   }
30826   {
30827     try {
30828       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30829     } CALL_CATCH_EXCEPTION();
30830   }
30831
30832 }
30833
30834
30835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30836   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30837   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30838   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30839
30840   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30841   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30842   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30843   if (!arg3) {
30844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30845     return ;
30846   }
30847   {
30848     try {
30849       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30850     } CALL_CATCH_EXCEPTION();
30851   }
30852
30853 }
30854
30855
30856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30857   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30858   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30859   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30860   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30861
30862   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30863   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30864   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30865   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
30866   {
30867     try {
30868       (arg1)->Insert(arg2,arg3,arg4);
30869     } CALL_CATCH_EXCEPTION();
30870   }
30871
30872 }
30873
30874
30875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
30876   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30877   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30878
30879   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30880   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30881   {
30882     try {
30883       (arg1)->Reserve(arg2);
30884     } CALL_CATCH_EXCEPTION();
30885   }
30886
30887 }
30888
30889
30890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30891   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30892   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30893
30894   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30895   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30896   {
30897     try {
30898       (arg1)->Resize(arg2);
30899     } CALL_CATCH_EXCEPTION();
30900   }
30901
30902 }
30903
30904
30905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
30906   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30907   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30908   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30909
30910   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30911   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30912   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30913   if (!arg3) {
30914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30915     return ;
30916   }
30917   {
30918     try {
30919       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30920     } CALL_CATCH_EXCEPTION();
30921   }
30922
30923 }
30924
30925
30926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
30927   void * jresult ;
30928   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30929   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30930   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30931
30932   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30933   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30934   {
30935     try {
30936       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
30937     } CALL_CATCH_EXCEPTION(0);
30938   }
30939
30940   jresult = (void *)result;
30941   return jresult;
30942 }
30943
30944
30945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30946   void * jresult ;
30947   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30948   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30949   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30950   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30951
30952   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30953   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30954   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30955   {
30956     try {
30957       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
30958     } CALL_CATCH_EXCEPTION(0);
30959   }
30960
30961   jresult = (void *)result;
30962   return jresult;
30963 }
30964
30965
30966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
30967   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30968   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30969
30970   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30971   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30972   {
30973     try {
30974       (arg1)->Remove(arg2);
30975     } CALL_CATCH_EXCEPTION();
30976   }
30977
30978 }
30979
30980
30981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
30982   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30983   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30984
30985   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30986   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30987   if (!arg2) {
30988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
30989     return ;
30990   }
30991   {
30992     try {
30993       (arg1)->Swap(*arg2);
30994     } CALL_CATCH_EXCEPTION();
30995   }
30996
30997 }
30998
30999
31000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31001   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31002
31003   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31004   {
31005     try {
31006       (arg1)->Clear();
31007     } CALL_CATCH_EXCEPTION();
31008   }
31009
31010 }
31011
31012
31013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31014   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31015
31016   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31017   {
31018     try {
31019       (arg1)->Release();
31020     } CALL_CATCH_EXCEPTION();
31021   }
31022
31023 }
31024
31025
31026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31027   void * jresult ;
31028   Dali::Signal< void () > *result = 0 ;
31029
31030   {
31031     try {
31032       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31033     } CALL_CATCH_EXCEPTION(0);
31034   }
31035
31036   jresult = (void *)result;
31037   return jresult;
31038 }
31039
31040
31041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31042   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31043
31044   arg1 = (Dali::Signal< void () > *)jarg1;
31045   {
31046     try {
31047       delete arg1;
31048     } CALL_CATCH_EXCEPTION();
31049   }
31050
31051 }
31052
31053
31054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31055   unsigned int jresult ;
31056   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31057   bool result;
31058
31059   arg1 = (Dali::Signal< void () > *)jarg1;
31060   {
31061     try {
31062       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31063     } CALL_CATCH_EXCEPTION(0);
31064   }
31065
31066   jresult = result;
31067   return jresult;
31068 }
31069
31070
31071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31072   unsigned long jresult ;
31073   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31074   std::size_t result;
31075
31076   arg1 = (Dali::Signal< void () > *)jarg1;
31077   {
31078     try {
31079       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31080     } CALL_CATCH_EXCEPTION(0);
31081   }
31082
31083   jresult = (unsigned long)result;
31084   return jresult;
31085 }
31086
31087
31088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31089   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31090   void (*arg2)() = (void (*)()) 0 ;
31091
31092   arg1 = (Dali::Signal< void () > *)jarg1;
31093   arg2 = (void (*)())jarg2;
31094   {
31095     try {
31096       (arg1)->Connect(arg2);
31097     } CALL_CATCH_EXCEPTION();
31098   }
31099
31100 }
31101
31102
31103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31104   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31105   void (*arg2)() = (void (*)()) 0 ;
31106
31107   arg1 = (Dali::Signal< void () > *)jarg1;
31108   arg2 = (void (*)())jarg2;
31109   {
31110     try {
31111       (arg1)->Disconnect(arg2);
31112     } CALL_CATCH_EXCEPTION();
31113   }
31114
31115 }
31116
31117
31118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31119   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31120   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31121   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31122
31123   arg1 = (Dali::Signal< void () > *)jarg1;
31124   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31125   arg3 = (Dali::FunctorDelegate *)jarg3;
31126   {
31127     try {
31128       (arg1)->Connect(arg2,arg3);
31129     } CALL_CATCH_EXCEPTION();
31130   }
31131
31132 }
31133
31134
31135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31136   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31137
31138   arg1 = (Dali::Signal< void () > *)jarg1;
31139   {
31140     try {
31141       (arg1)->Emit();
31142     } CALL_CATCH_EXCEPTION();
31143   }
31144
31145 }
31146
31147
31148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31149   unsigned int jresult ;
31150   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31151   bool result;
31152
31153   arg1 = (Dali::Signal< void (float) > *)jarg1;
31154   {
31155     try {
31156       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31157     } CALL_CATCH_EXCEPTION(0);
31158   }
31159
31160   jresult = result;
31161   return jresult;
31162 }
31163
31164
31165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31166   unsigned long jresult ;
31167   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31168   std::size_t result;
31169
31170   arg1 = (Dali::Signal< void (float) > *)jarg1;
31171   {
31172     try {
31173       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31174     } CALL_CATCH_EXCEPTION(0);
31175   }
31176
31177   jresult = (unsigned long)result;
31178   return jresult;
31179 }
31180
31181
31182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31183   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31184   void (*arg2)(float) = (void (*)(float)) 0 ;
31185
31186   arg1 = (Dali::Signal< void (float) > *)jarg1;
31187   arg2 = (void (*)(float))jarg2;
31188   {
31189     try {
31190       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31191     } CALL_CATCH_EXCEPTION();
31192   }
31193
31194 }
31195
31196
31197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31198   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31199   void (*arg2)(float) = (void (*)(float)) 0 ;
31200
31201   arg1 = (Dali::Signal< void (float) > *)jarg1;
31202   arg2 = (void (*)(float))jarg2;
31203   {
31204     try {
31205       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31206     } CALL_CATCH_EXCEPTION();
31207   }
31208
31209 }
31210
31211
31212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31213   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31214   float arg2 ;
31215
31216   arg1 = (Dali::Signal< void (float) > *)jarg1;
31217   arg2 = (float)jarg2;
31218   {
31219     try {
31220       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31221     } CALL_CATCH_EXCEPTION();
31222   }
31223
31224 }
31225
31226
31227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31228   void * jresult ;
31229   Dali::Signal< void (float) > *result = 0 ;
31230
31231   {
31232     try {
31233       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31234     } CALL_CATCH_EXCEPTION(0);
31235   }
31236
31237   jresult = (void *)result;
31238   return jresult;
31239 }
31240
31241
31242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31243   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31244
31245   arg1 = (Dali::Signal< void (float) > *)jarg1;
31246   {
31247     try {
31248       delete arg1;
31249     } CALL_CATCH_EXCEPTION();
31250   }
31251
31252 }
31253
31254
31255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31256   unsigned int jresult ;
31257   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31258   bool result;
31259
31260   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31261   {
31262     try {
31263       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31264     } CALL_CATCH_EXCEPTION(0);
31265   }
31266
31267   jresult = result;
31268   return jresult;
31269 }
31270
31271
31272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31273   unsigned long jresult ;
31274   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31275   std::size_t result;
31276
31277   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31278   {
31279     try {
31280       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31281     } CALL_CATCH_EXCEPTION(0);
31282   }
31283
31284   jresult = (unsigned long)result;
31285   return jresult;
31286 }
31287
31288
31289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31290   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31291   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31292
31293   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31294   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31295   {
31296     try {
31297       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31298     } CALL_CATCH_EXCEPTION();
31299   }
31300
31301 }
31302
31303
31304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31305   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31306   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31307
31308   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31309   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31310   {
31311     try {
31312       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31313     } CALL_CATCH_EXCEPTION();
31314   }
31315
31316 }
31317
31318
31319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31320   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31321   Dali::BaseHandle arg2 ;
31322   Dali::BaseHandle *argp2 ;
31323
31324   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31325   argp2 = (Dali::BaseHandle *)jarg2;
31326   if (!argp2) {
31327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31328     return ;
31329   }
31330   arg2 = *argp2;
31331   {
31332     try {
31333       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31334     } CALL_CATCH_EXCEPTION();
31335   }
31336
31337 }
31338
31339
31340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31341   void * jresult ;
31342   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31343
31344   {
31345     try {
31346       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31347     } CALL_CATCH_EXCEPTION(0);
31348   }
31349
31350   jresult = (void *)result;
31351   return jresult;
31352 }
31353
31354
31355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31356   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31357
31358   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31359   {
31360     try {
31361       delete arg1;
31362     } CALL_CATCH_EXCEPTION();
31363   }
31364
31365 }
31366
31367
31368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31369   unsigned int jresult ;
31370   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31371   bool result;
31372
31373   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31374   {
31375     try {
31376       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31377     } CALL_CATCH_EXCEPTION(0);
31378   }
31379
31380   jresult = result;
31381   return jresult;
31382 }
31383
31384
31385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31386   unsigned long jresult ;
31387   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31388   std::size_t result;
31389
31390   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31391   {
31392     try {
31393       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31394     } CALL_CATCH_EXCEPTION(0);
31395   }
31396
31397   jresult = (unsigned long)result;
31398   return jresult;
31399 }
31400
31401
31402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31403   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31404   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31405
31406   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31407   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31408   {
31409     try {
31410       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31411     } CALL_CATCH_EXCEPTION();
31412   }
31413
31414 }
31415
31416
31417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31418   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31419   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31420
31421   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31422   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31423   {
31424     try {
31425       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31426     } CALL_CATCH_EXCEPTION();
31427   }
31428
31429 }
31430
31431
31432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31433   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31434   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31435
31436   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31437   arg2 = (Dali::RefObject *)jarg2;
31438   {
31439     try {
31440       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31441     } CALL_CATCH_EXCEPTION();
31442   }
31443
31444 }
31445
31446
31447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31448   void * jresult ;
31449   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31450
31451   {
31452     try {
31453       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31454     } CALL_CATCH_EXCEPTION(0);
31455   }
31456
31457   jresult = (void *)result;
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31463   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31464
31465   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31466   {
31467     try {
31468       delete arg1;
31469     } CALL_CATCH_EXCEPTION();
31470   }
31471
31472 }
31473
31474
31475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31476   unsigned int jresult ;
31477   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31478   bool result;
31479
31480   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31481   {
31482     try {
31483       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31484     } CALL_CATCH_EXCEPTION(0);
31485   }
31486
31487   jresult = result;
31488   return jresult;
31489 }
31490
31491
31492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31493   unsigned long jresult ;
31494   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31495   std::size_t result;
31496
31497   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31498   {
31499     try {
31500       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31501     } CALL_CATCH_EXCEPTION(0);
31502   }
31503
31504   jresult = (unsigned long)result;
31505   return jresult;
31506 }
31507
31508
31509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31510   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31511   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31512
31513   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31514   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31515   {
31516     try {
31517       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31518     } CALL_CATCH_EXCEPTION();
31519   }
31520
31521 }
31522
31523
31524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31525   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31526   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31527
31528   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31529   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31530   {
31531     try {
31532       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31533     } CALL_CATCH_EXCEPTION();
31534   }
31535
31536 }
31537
31538
31539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31540   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31541   Dali::PropertyNotification *arg2 = 0 ;
31542
31543   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31544   arg2 = (Dali::PropertyNotification *)jarg2;
31545   if (!arg2) {
31546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31547     return ;
31548   }
31549   {
31550     try {
31551       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31552     } CALL_CATCH_EXCEPTION();
31553   }
31554
31555 }
31556
31557
31558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31559   void * jresult ;
31560   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31561
31562   {
31563     try {
31564       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31565     } CALL_CATCH_EXCEPTION(0);
31566   }
31567
31568   jresult = (void *)result;
31569   return jresult;
31570 }
31571
31572
31573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31574   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31575
31576   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31577   {
31578     try {
31579       delete arg1;
31580     } CALL_CATCH_EXCEPTION();
31581   }
31582
31583 }
31584
31585
31586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31587   void * jresult ;
31588   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31589
31590   {
31591     try {
31592       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31593     } CALL_CATCH_EXCEPTION(0);
31594   }
31595
31596   jresult = (void *)result;
31597   return jresult;
31598 }
31599
31600
31601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31602   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31603
31604   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31605   {
31606     try {
31607       delete arg1;
31608     } CALL_CATCH_EXCEPTION();
31609   }
31610
31611 }
31612
31613
31614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31615   unsigned int jresult ;
31616   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31617   bool result;
31618
31619   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31620   {
31621     try {
31622       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);
31623     } CALL_CATCH_EXCEPTION(0);
31624   }
31625
31626   jresult = result;
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31632   unsigned long jresult ;
31633   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31634   std::size_t result;
31635
31636   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31637   {
31638     try {
31639       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);
31640     } CALL_CATCH_EXCEPTION(0);
31641   }
31642
31643   jresult = (unsigned long)result;
31644   return jresult;
31645 }
31646
31647
31648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31649   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31650   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31651
31652   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31653   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31654   {
31655     try {
31656       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31657     } CALL_CATCH_EXCEPTION();
31658   }
31659
31660 }
31661
31662
31663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31664   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31665   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31666
31667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31668   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31669   {
31670     try {
31671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31672     } CALL_CATCH_EXCEPTION();
31673   }
31674
31675 }
31676
31677
31678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31679   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31680   Dali::Actor arg2 ;
31681   Dali::LongPressGesture *arg3 = 0 ;
31682   Dali::Actor *argp2 ;
31683
31684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31685   argp2 = (Dali::Actor *)jarg2;
31686   if (!argp2) {
31687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31688     return ;
31689   }
31690   arg2 = *argp2;
31691   arg3 = (Dali::LongPressGesture *)jarg3;
31692   if (!arg3) {
31693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31694     return ;
31695   }
31696   {
31697     try {
31698       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31699     } CALL_CATCH_EXCEPTION();
31700   }
31701
31702 }
31703
31704
31705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31706   void * jresult ;
31707   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31708
31709   {
31710     try {
31711       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31712     } CALL_CATCH_EXCEPTION(0);
31713   }
31714
31715   jresult = (void *)result;
31716   return jresult;
31717 }
31718
31719
31720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31721   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31722
31723   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31724   {
31725     try {
31726       delete arg1;
31727     } CALL_CATCH_EXCEPTION();
31728   }
31729
31730 }
31731
31732
31733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31734   unsigned int jresult ;
31735   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31736   bool result;
31737
31738   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31739   {
31740     try {
31741       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);
31742     } CALL_CATCH_EXCEPTION(0);
31743   }
31744
31745   jresult = result;
31746   return jresult;
31747 }
31748
31749
31750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31751   unsigned long jresult ;
31752   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31753   std::size_t result;
31754
31755   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31756   {
31757     try {
31758       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);
31759     } CALL_CATCH_EXCEPTION(0);
31760   }
31761
31762   jresult = (unsigned long)result;
31763   return jresult;
31764 }
31765
31766
31767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31768   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31769   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31770
31771   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31772   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31773   {
31774     try {
31775       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31776     } CALL_CATCH_EXCEPTION();
31777   }
31778
31779 }
31780
31781
31782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31783   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31784   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31785
31786   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31787   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31788   {
31789     try {
31790       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31791     } CALL_CATCH_EXCEPTION();
31792   }
31793
31794 }
31795
31796
31797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31798   unsigned int jresult ;
31799   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31800   Dali::Actor arg2 ;
31801   Dali::TouchEvent *arg3 = 0 ;
31802   Dali::Actor *argp2 ;
31803   bool result;
31804
31805   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31806   argp2 = (Dali::Actor *)jarg2;
31807   if (!argp2) {
31808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31809     return 0;
31810   }
31811   arg2 = *argp2;
31812   arg3 = (Dali::TouchEvent *)jarg3;
31813   if (!arg3) {
31814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31815     return 0;
31816   }
31817   {
31818     try {
31819       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31820     } CALL_CATCH_EXCEPTION(0);
31821   }
31822
31823   jresult = result;
31824   return jresult;
31825 }
31826
31827
31828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31829   void * jresult ;
31830   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31831
31832   {
31833     try {
31834       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31835     } CALL_CATCH_EXCEPTION(0);
31836   }
31837
31838   jresult = (void *)result;
31839   return jresult;
31840 }
31841
31842
31843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
31844   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31845
31846   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31847   {
31848     try {
31849       delete arg1;
31850     } CALL_CATCH_EXCEPTION();
31851   }
31852
31853 }
31854
31855
31856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
31857   unsigned int jresult ;
31858   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31859   bool result;
31860
31861   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31862   {
31863     try {
31864       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);
31865     } CALL_CATCH_EXCEPTION(0);
31866   }
31867
31868   jresult = result;
31869   return jresult;
31870 }
31871
31872
31873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
31874   unsigned long jresult ;
31875   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31876   std::size_t result;
31877
31878   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31879   {
31880     try {
31881       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);
31882     } CALL_CATCH_EXCEPTION(0);
31883   }
31884
31885   jresult = (unsigned long)result;
31886   return jresult;
31887 }
31888
31889
31890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
31891   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31892   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31893
31894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31895   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31896   {
31897     try {
31898       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31899     } CALL_CATCH_EXCEPTION();
31900   }
31901
31902 }
31903
31904
31905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
31906   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31907   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31908
31909   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31910   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31911   {
31912     try {
31913       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31914     } CALL_CATCH_EXCEPTION();
31915   }
31916
31917 }
31918
31919
31920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31921   unsigned int jresult ;
31922   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31923   Dali::Actor arg2 ;
31924   Dali::HoverEvent *arg3 = 0 ;
31925   Dali::Actor *argp2 ;
31926   bool result;
31927
31928   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31929   argp2 = (Dali::Actor *)jarg2;
31930   if (!argp2) {
31931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31932     return 0;
31933   }
31934   arg2 = *argp2;
31935   arg3 = (Dali::HoverEvent *)jarg3;
31936   if (!arg3) {
31937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
31938     return 0;
31939   }
31940   {
31941     try {
31942       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
31943     } CALL_CATCH_EXCEPTION(0);
31944   }
31945
31946   jresult = result;
31947   return jresult;
31948 }
31949
31950
31951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
31952   void * jresult ;
31953   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
31954
31955   {
31956     try {
31957       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
31958     } CALL_CATCH_EXCEPTION(0);
31959   }
31960
31961   jresult = (void *)result;
31962   return jresult;
31963 }
31964
31965
31966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
31967   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31968
31969   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31970   {
31971     try {
31972       delete arg1;
31973     } CALL_CATCH_EXCEPTION();
31974   }
31975
31976 }
31977
31978
31979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
31980   unsigned int jresult ;
31981   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
31982   bool result;
31983
31984   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
31985   {
31986     try {
31987       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);
31988     } CALL_CATCH_EXCEPTION(0);
31989   }
31990
31991   jresult = result;
31992   return jresult;
31993 }
31994
31995
31996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
31997   unsigned long jresult ;
31998   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
31999   std::size_t result;
32000
32001   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32002   {
32003     try {
32004       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);
32005     } CALL_CATCH_EXCEPTION(0);
32006   }
32007
32008   jresult = (unsigned long)result;
32009   return jresult;
32010 }
32011
32012
32013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32014   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32015   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32016
32017   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32018   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32019   {
32020     try {
32021       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32022     } CALL_CATCH_EXCEPTION();
32023   }
32024
32025 }
32026
32027
32028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32029   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32030   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32031
32032   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32033   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32034   {
32035     try {
32036       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32037     } CALL_CATCH_EXCEPTION();
32038   }
32039
32040 }
32041
32042
32043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32044   unsigned int jresult ;
32045   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32046   Dali::Actor arg2 ;
32047   Dali::WheelEvent *arg3 = 0 ;
32048   Dali::Actor *argp2 ;
32049   bool result;
32050
32051   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32052   argp2 = (Dali::Actor *)jarg2;
32053   if (!argp2) {
32054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32055     return 0;
32056   }
32057   arg2 = *argp2;
32058   arg3 = (Dali::WheelEvent *)jarg3;
32059   if (!arg3) {
32060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32061     return 0;
32062   }
32063   {
32064     try {
32065       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32066     } CALL_CATCH_EXCEPTION(0);
32067   }
32068
32069   jresult = result;
32070   return jresult;
32071 }
32072
32073
32074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32075   void * jresult ;
32076   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32077
32078   {
32079     try {
32080       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32081     } CALL_CATCH_EXCEPTION(0);
32082   }
32083
32084   jresult = (void *)result;
32085   return jresult;
32086 }
32087
32088
32089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32090   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32091
32092   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32093   {
32094     try {
32095       delete arg1;
32096     } CALL_CATCH_EXCEPTION();
32097   }
32098
32099 }
32100
32101
32102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32103   unsigned int jresult ;
32104   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32105   bool result;
32106
32107   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32108   {
32109     try {
32110       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32111     } CALL_CATCH_EXCEPTION(0);
32112   }
32113
32114   jresult = result;
32115   return jresult;
32116 }
32117
32118
32119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32120   unsigned long jresult ;
32121   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32122   std::size_t result;
32123
32124   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32125   {
32126     try {
32127       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32128     } CALL_CATCH_EXCEPTION(0);
32129   }
32130
32131   jresult = (unsigned long)result;
32132   return jresult;
32133 }
32134
32135
32136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32137   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32138   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32139
32140   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32141   arg2 = (void (*)(Dali::Actor))jarg2;
32142   {
32143     try {
32144       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32145     } CALL_CATCH_EXCEPTION();
32146   }
32147
32148 }
32149
32150
32151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32152   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32153   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32154
32155   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32156   arg2 = (void (*)(Dali::Actor))jarg2;
32157   {
32158     try {
32159       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32160     } CALL_CATCH_EXCEPTION();
32161   }
32162
32163 }
32164
32165
32166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32167   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32168   Dali::Actor arg2 ;
32169   Dali::Actor *argp2 ;
32170
32171   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32172   argp2 = (Dali::Actor *)jarg2;
32173   if (!argp2) {
32174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32175     return ;
32176   }
32177   arg2 = *argp2;
32178   {
32179     try {
32180       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32181     } CALL_CATCH_EXCEPTION();
32182   }
32183
32184 }
32185
32186
32187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32188   void * jresult ;
32189   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32190
32191   {
32192     try {
32193       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32194     } CALL_CATCH_EXCEPTION(0);
32195   }
32196
32197   jresult = (void *)result;
32198   return jresult;
32199 }
32200
32201
32202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32203   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32204
32205   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32206   {
32207     try {
32208       delete arg1;
32209     } CALL_CATCH_EXCEPTION();
32210   }
32211
32212 }
32213
32214
32215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32216   unsigned int jresult ;
32217   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32218   bool result;
32219
32220   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32221   {
32222     try {
32223       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32224     } CALL_CATCH_EXCEPTION(0);
32225   }
32226
32227   jresult = result;
32228   return jresult;
32229 }
32230
32231
32232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32233   unsigned long jresult ;
32234   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32235   std::size_t result;
32236
32237   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32238   {
32239     try {
32240       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32241     } CALL_CATCH_EXCEPTION(0);
32242   }
32243
32244   jresult = (unsigned long)result;
32245   return jresult;
32246 }
32247
32248
32249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32250   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32251   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32252
32253   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32254   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32255   {
32256     try {
32257       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32258     } CALL_CATCH_EXCEPTION();
32259   }
32260
32261 }
32262
32263
32264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32265   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32266   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32267
32268   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32269   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32270   {
32271     try {
32272       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32273     } CALL_CATCH_EXCEPTION();
32274   }
32275
32276 }
32277
32278
32279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32280   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32281   Dali::KeyEvent *arg2 = 0 ;
32282
32283   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32284   arg2 = (Dali::KeyEvent *)jarg2;
32285   if (!arg2) {
32286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32287     return ;
32288   }
32289   {
32290     try {
32291       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32292     } CALL_CATCH_EXCEPTION();
32293   }
32294
32295 }
32296
32297
32298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32299   void * jresult ;
32300   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32301
32302   {
32303     try {
32304       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32305     } CALL_CATCH_EXCEPTION(0);
32306   }
32307
32308   jresult = (void *)result;
32309   return jresult;
32310 }
32311
32312
32313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32314   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32315
32316   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32317   {
32318     try {
32319       delete arg1;
32320     } CALL_CATCH_EXCEPTION();
32321   }
32322
32323 }
32324
32325
32326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32327   unsigned int jresult ;
32328   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32329   bool result;
32330
32331   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32332   {
32333     try {
32334       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32335     } CALL_CATCH_EXCEPTION(0);
32336   }
32337
32338   jresult = result;
32339   return jresult;
32340 }
32341
32342
32343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32344   unsigned long jresult ;
32345   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32346   std::size_t result;
32347
32348   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32349   {
32350     try {
32351       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32352     } CALL_CATCH_EXCEPTION(0);
32353   }
32354
32355   jresult = (unsigned long)result;
32356   return jresult;
32357 }
32358
32359
32360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32361   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32362   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32363
32364   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32365   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32366   {
32367     try {
32368       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32369     } CALL_CATCH_EXCEPTION();
32370   }
32371
32372 }
32373
32374
32375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32376   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32377   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32378
32379   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32380   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32381   {
32382     try {
32383       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32384     } CALL_CATCH_EXCEPTION();
32385   }
32386
32387 }
32388
32389
32390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32391   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32392   Dali::TouchEvent *arg2 = 0 ;
32393
32394   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32395   arg2 = (Dali::TouchEvent *)jarg2;
32396   if (!arg2) {
32397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32398     return ;
32399   }
32400   {
32401     try {
32402       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32403     } CALL_CATCH_EXCEPTION();
32404   }
32405
32406 }
32407
32408
32409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32410   void * jresult ;
32411   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32412
32413   {
32414     try {
32415       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32416     } CALL_CATCH_EXCEPTION(0);
32417   }
32418
32419   jresult = (void *)result;
32420   return jresult;
32421 }
32422
32423
32424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32425   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32426
32427   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32428   {
32429     try {
32430       delete arg1;
32431     } CALL_CATCH_EXCEPTION();
32432   }
32433
32434 }
32435
32436
32437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32438   unsigned int jresult ;
32439   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32440   bool result;
32441
32442   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32443   {
32444     try {
32445       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32446     } CALL_CATCH_EXCEPTION(0);
32447   }
32448
32449   jresult = result;
32450   return jresult;
32451 }
32452
32453
32454 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32455   unsigned long jresult ;
32456   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32457   std::size_t result;
32458
32459   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32460   {
32461     try {
32462       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32463     } CALL_CATCH_EXCEPTION(0);
32464   }
32465
32466   jresult = (unsigned long)result;
32467   return jresult;
32468 }
32469
32470
32471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32472   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32473   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32474
32475   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32476   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32477   {
32478     try {
32479       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32480     } CALL_CATCH_EXCEPTION();
32481   }
32482
32483 }
32484
32485
32486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32487   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32488   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32489
32490   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32491   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32492   {
32493     try {
32494       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32495     } CALL_CATCH_EXCEPTION();
32496   }
32497
32498 }
32499
32500
32501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32502   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32503   Dali::WheelEvent *arg2 = 0 ;
32504
32505   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32506   arg2 = (Dali::WheelEvent *)jarg2;
32507   if (!arg2) {
32508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32509     return ;
32510   }
32511   {
32512     try {
32513       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32514     } CALL_CATCH_EXCEPTION();
32515   }
32516
32517 }
32518
32519
32520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32521   void * jresult ;
32522   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32523
32524   {
32525     try {
32526       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32527     } CALL_CATCH_EXCEPTION(0);
32528   }
32529
32530   jresult = (void *)result;
32531   return jresult;
32532 }
32533
32534
32535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32536   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32537
32538   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32539   {
32540     try {
32541       delete arg1;
32542     } CALL_CATCH_EXCEPTION();
32543   }
32544
32545 }
32546
32547
32548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32549   void * jresult ;
32550   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32551
32552   {
32553     try {
32554       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32555     } CALL_CATCH_EXCEPTION(0);
32556   }
32557
32558   jresult = (void *)result;
32559   return jresult;
32560 }
32561
32562
32563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32564   void * jresult ;
32565   Dali::Radian arg1 ;
32566   Dali::Radian arg2 ;
32567   Dali::Radian *argp1 ;
32568   Dali::Radian *argp2 ;
32569   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32570
32571   argp1 = (Dali::Radian *)jarg1;
32572   if (!argp1) {
32573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32574     return 0;
32575   }
32576   arg1 = *argp1;
32577   argp2 = (Dali::Radian *)jarg2;
32578   if (!argp2) {
32579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32580     return 0;
32581   }
32582   arg2 = *argp2;
32583   {
32584     try {
32585       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32586     } CALL_CATCH_EXCEPTION(0);
32587   }
32588
32589   jresult = (void *)result;
32590   return jresult;
32591 }
32592
32593
32594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32595   void * jresult ;
32596   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32597   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32598
32599   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32600   if (!arg1) {
32601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32602     return 0;
32603   }
32604   {
32605     try {
32606       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32607     } CALL_CATCH_EXCEPTION(0);
32608   }
32609
32610   jresult = (void *)result;
32611   return jresult;
32612 }
32613
32614
32615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32616   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32617   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32618
32619   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32620   arg2 = (Dali::Radian *)jarg2;
32621   if (arg1) (arg1)->first = *arg2;
32622 }
32623
32624
32625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32626   void * jresult ;
32627   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32628   Dali::Radian *result = 0 ;
32629
32630   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32631   result = (Dali::Radian *)& ((arg1)->first);
32632   jresult = (void *)result;
32633   return jresult;
32634 }
32635
32636
32637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32638   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32639   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32640
32641   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32642   arg2 = (Dali::Radian *)jarg2;
32643   if (arg1) (arg1)->second = *arg2;
32644 }
32645
32646
32647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32648   void * jresult ;
32649   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32650   Dali::Radian *result = 0 ;
32651
32652   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32653   result = (Dali::Radian *)& ((arg1)->second);
32654   jresult = (void *)result;
32655   return jresult;
32656 }
32657
32658
32659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32660   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32661
32662   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32663   {
32664     try {
32665       delete arg1;
32666     } CALL_CATCH_EXCEPTION();
32667   }
32668
32669 }
32670
32671
32672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32673   unsigned int jresult ;
32674   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32675   bool result;
32676
32677   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32678   {
32679     try {
32680       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);
32681     } CALL_CATCH_EXCEPTION(0);
32682   }
32683
32684   jresult = result;
32685   return jresult;
32686 }
32687
32688
32689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32690   unsigned long jresult ;
32691   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32692   std::size_t result;
32693
32694   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32695   {
32696     try {
32697       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);
32698     } CALL_CATCH_EXCEPTION(0);
32699   }
32700
32701   jresult = (unsigned long)result;
32702   return jresult;
32703 }
32704
32705
32706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32707   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32708   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32709
32710   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32711   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32712   {
32713     try {
32714       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32715     } CALL_CATCH_EXCEPTION();
32716   }
32717
32718 }
32719
32720
32721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32722   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32723   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32724
32725   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32726   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32727   {
32728     try {
32729       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32730     } CALL_CATCH_EXCEPTION();
32731   }
32732
32733 }
32734
32735
32736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32737   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32738   Dali::Actor arg2 ;
32739   Dali::PanGesture *arg3 = 0 ;
32740   Dali::Actor *argp2 ;
32741
32742   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32743   argp2 = (Dali::Actor *)jarg2;
32744   if (!argp2) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg2 = *argp2;
32749   arg3 = (Dali::PanGesture *)jarg3;
32750   if (!arg3) {
32751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32752     return ;
32753   }
32754   {
32755     try {
32756       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32757     } CALL_CATCH_EXCEPTION();
32758   }
32759
32760 }
32761
32762
32763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32764   void * jresult ;
32765   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32766
32767   {
32768     try {
32769       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32770     } CALL_CATCH_EXCEPTION(0);
32771   }
32772
32773   jresult = (void *)result;
32774   return jresult;
32775 }
32776
32777
32778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32779   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32780
32781   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32782   {
32783     try {
32784       delete arg1;
32785     } CALL_CATCH_EXCEPTION();
32786   }
32787
32788 }
32789
32790
32791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32792   unsigned int jresult ;
32793   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32794   bool result;
32795
32796   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32797   {
32798     try {
32799       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);
32800     } CALL_CATCH_EXCEPTION(0);
32801   }
32802
32803   jresult = result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32809   unsigned long jresult ;
32810   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32811   std::size_t result;
32812
32813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32814   {
32815     try {
32816       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);
32817     } CALL_CATCH_EXCEPTION(0);
32818   }
32819
32820   jresult = (unsigned long)result;
32821   return jresult;
32822 }
32823
32824
32825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32826   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32827   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32828
32829   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32830   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32831   {
32832     try {
32833       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32834     } CALL_CATCH_EXCEPTION();
32835   }
32836
32837 }
32838
32839
32840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32841   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32842   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32843
32844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32845   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32846   {
32847     try {
32848       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32849     } CALL_CATCH_EXCEPTION();
32850   }
32851
32852 }
32853
32854
32855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32856   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32857   Dali::Actor arg2 ;
32858   Dali::PinchGesture *arg3 = 0 ;
32859   Dali::Actor *argp2 ;
32860
32861   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32862   argp2 = (Dali::Actor *)jarg2;
32863   if (!argp2) {
32864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32865     return ;
32866   }
32867   arg2 = *argp2;
32868   arg3 = (Dali::PinchGesture *)jarg3;
32869   if (!arg3) {
32870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
32871     return ;
32872   }
32873   {
32874     try {
32875       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
32876     } CALL_CATCH_EXCEPTION();
32877   }
32878
32879 }
32880
32881
32882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
32883   void * jresult ;
32884   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
32885
32886   {
32887     try {
32888       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
32889     } CALL_CATCH_EXCEPTION(0);
32890   }
32891
32892   jresult = (void *)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
32898   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32899
32900   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32901   {
32902     try {
32903       delete arg1;
32904     } CALL_CATCH_EXCEPTION();
32905   }
32906
32907 }
32908
32909
32910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
32911   unsigned int jresult ;
32912   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32913   bool result;
32914
32915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32916   {
32917     try {
32918       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);
32919     } CALL_CATCH_EXCEPTION(0);
32920   }
32921
32922   jresult = result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32928   unsigned long jresult ;
32929   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32930   std::size_t result;
32931
32932   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32933   {
32934     try {
32935       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);
32936     } CALL_CATCH_EXCEPTION(0);
32937   }
32938
32939   jresult = (unsigned long)result;
32940   return jresult;
32941 }
32942
32943
32944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32945   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32946   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
32947
32948   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32949   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
32950   {
32951     try {
32952       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32953     } CALL_CATCH_EXCEPTION();
32954   }
32955
32956 }
32957
32958
32959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32960   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32961   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
32962
32963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32964   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
32965   {
32966     try {
32967       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32968     } CALL_CATCH_EXCEPTION();
32969   }
32970
32971 }
32972
32973
32974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32975   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
32976   Dali::Actor arg2 ;
32977   Dali::TapGesture *arg3 = 0 ;
32978   Dali::Actor *argp2 ;
32979
32980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
32981   argp2 = (Dali::Actor *)jarg2;
32982   if (!argp2) {
32983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32984     return ;
32985   }
32986   arg2 = *argp2;
32987   arg3 = (Dali::TapGesture *)jarg3;
32988   if (!arg3) {
32989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
32990     return ;
32991   }
32992   {
32993     try {
32994       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
32995     } CALL_CATCH_EXCEPTION();
32996   }
32997
32998 }
32999
33000
33001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33002   void * jresult ;
33003   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33004
33005   {
33006     try {
33007       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33008     } CALL_CATCH_EXCEPTION(0);
33009   }
33010
33011   jresult = (void *)result;
33012   return jresult;
33013 }
33014
33015
33016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33017   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33018
33019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33020   {
33021     try {
33022       delete arg1;
33023     } CALL_CATCH_EXCEPTION();
33024   }
33025
33026 }
33027
33028
33029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33030   unsigned int jresult ;
33031   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33032   bool result = false;
33033
33034   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33035   {
33036     try {
33037       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);
33038     } CALL_CATCH_EXCEPTION(0);
33039   }
33040   jresult = result;
33041   return jresult;
33042 }
33043
33044 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33045   unsigned long jresult ;
33046   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33047   std::size_t result = 0;
33048
33049   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33050   {
33051     try {
33052       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);
33053     }CALL_CATCH_EXCEPTION(0);
33054   }
33055   jresult = (unsigned long)result;
33056   return jresult;
33057 }
33058
33059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33060   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33061   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33062
33063   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33064   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33065   {
33066     try {
33067       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33068     } CALL_CATCH_EXCEPTION();
33069   }
33070 }
33071
33072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33073   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33074   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33075
33076   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33077   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33078   {
33079     try {
33080       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33081     } CALL_CATCH_EXCEPTION();
33082   }
33083 }
33084
33085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33086   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33087   Dali::Actor arg2 ;
33088   //bool arg3 ;
33089   Dali::LayoutDirection::Type arg4 ;
33090   Dali::Actor *argp2 ;
33091
33092   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33093   argp2 = (Dali::Actor *)jarg2;
33094   if (!argp2) {
33095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33096     return ;
33097   }
33098   arg2 = *argp2;
33099   //arg3 = jarg3 ? true : false;
33100   arg4 = (Dali::LayoutDirection::Type)jarg4;
33101   {
33102     try {
33103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33104     } CALL_CATCH_EXCEPTION();
33105   }
33106 }
33107
33108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33109   void * jresult ;
33110   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33111
33112   {
33113     try {
33114       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33115     } CALL_CATCH_EXCEPTION(0);
33116   }
33117   jresult = (void *)result;
33118   return jresult;
33119 }
33120
33121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33122   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33123
33124   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33125   {
33126     try {
33127       delete arg1;
33128     } CALL_CATCH_EXCEPTION();
33129   }
33130 }
33131
33132
33133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_iewVisibilityChangedSignal_Empty(void * jarg1) {
33134   unsigned int jresult ;
33135   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33136   bool result = false;
33137
33138   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33139   {
33140     try {
33141           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);
33142     } CALL_CATCH_EXCEPTION(0);
33143   }
33144   jresult = result;
33145   return jresult;
33146 }
33147
33148
33149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33150   unsigned long jresult ;
33151   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33152   std::size_t result;
33153
33154   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33155   {
33156     try {
33157       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);
33158     } CALL_CATCH_EXCEPTION(0);
33159   }
33160
33161   jresult = (unsigned long)result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33167   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33168   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33169
33170   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33171   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33172   {
33173     try {
33174       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33175     } CALL_CATCH_EXCEPTION();
33176   }
33177
33178 }
33179
33180
33181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33182   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33183   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33184
33185   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33186   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33187   {
33188     try {
33189       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33190     } CALL_CATCH_EXCEPTION();
33191   }
33192
33193 }
33194
33195
33196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33197   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33198   Dali::Actor arg2 ;
33199   bool arg3 ;
33200   Dali::DevelActor::VisibilityChange::Type arg4 ;
33201   Dali::Actor *argp2 ;
33202
33203   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33204   argp2 = (Dali::Actor *)jarg2;
33205   if (!argp2) {
33206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33207     return ;
33208   }
33209   arg2 = *argp2;
33210   arg3 = jarg3 ? true : false;
33211   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33212   {
33213     try {
33214       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33215     } CALL_CATCH_EXCEPTION();
33216   }
33217
33218 }
33219
33220
33221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33222   void * jresult ;
33223   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33224
33225   {
33226     try {
33227       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33228     } CALL_CATCH_EXCEPTION(0);
33229   }
33230
33231   jresult = (void *)result;
33232   return jresult;
33233 }
33234
33235
33236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33237   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33238
33239   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33240   {
33241     try {
33242       delete arg1;
33243     } CALL_CATCH_EXCEPTION();
33244   }
33245
33246 }
33247
33248
33249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33250   void * jresult ;
33251   Dali::Timer *result = 0 ;
33252
33253   {
33254     try {
33255       result = (Dali::Timer *)new Dali::Timer();
33256     } CALL_CATCH_EXCEPTION(0);
33257   }
33258
33259   jresult = (void *)result;
33260   return jresult;
33261 }
33262
33263
33264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33265   void * jresult ;
33266   unsigned int arg1 ;
33267   Dali::Timer result;
33268
33269   arg1 = (unsigned int)jarg1;
33270   {
33271     try {
33272       result = Dali::Timer::New(arg1);
33273     } CALL_CATCH_EXCEPTION(0);
33274   }
33275
33276   jresult = new Dali::Timer((const Dali::Timer &)result);
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33282   void * jresult ;
33283   Dali::Timer *arg1 = 0 ;
33284   Dali::Timer *result = 0 ;
33285
33286   arg1 = (Dali::Timer *)jarg1;
33287   if (!arg1) {
33288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33289     return 0;
33290   }
33291   {
33292     try {
33293       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33294     } CALL_CATCH_EXCEPTION(0);
33295   }
33296
33297   jresult = (void *)result;
33298   return jresult;
33299 }
33300
33301
33302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33303   void * jresult ;
33304   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33305   Dali::Timer *arg2 = 0 ;
33306   Dali::Timer *result = 0 ;
33307
33308   arg1 = (Dali::Timer *)jarg1;
33309   arg2 = (Dali::Timer *)jarg2;
33310   if (!arg2) {
33311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33312     return 0;
33313   }
33314   {
33315     try {
33316       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33317     } CALL_CATCH_EXCEPTION(0);
33318   }
33319
33320   jresult = (void *)result;
33321   return jresult;
33322 }
33323
33324
33325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33326   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33327
33328   arg1 = (Dali::Timer *)jarg1;
33329   {
33330     try {
33331       delete arg1;
33332     } CALL_CATCH_EXCEPTION();
33333   }
33334
33335 }
33336
33337
33338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33339   void * jresult ;
33340   Dali::BaseHandle arg1 ;
33341   Dali::BaseHandle *argp1 ;
33342   Dali::Timer result;
33343
33344   argp1 = (Dali::BaseHandle *)jarg1;
33345   if (!argp1) {
33346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33347     return 0;
33348   }
33349   arg1 = *argp1;
33350   {
33351     try {
33352       result = Dali::Timer::DownCast(arg1);
33353     } CALL_CATCH_EXCEPTION(0);
33354   }
33355
33356   jresult = new Dali::Timer((const Dali::Timer &)result);
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33362   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33363
33364   arg1 = (Dali::Timer *)jarg1;
33365   {
33366     try {
33367       (arg1)->Start();
33368     } CALL_CATCH_EXCEPTION();
33369   }
33370
33371 }
33372
33373
33374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33375   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33376
33377   arg1 = (Dali::Timer *)jarg1;
33378   {
33379     try {
33380       (arg1)->Stop();
33381     } CALL_CATCH_EXCEPTION();
33382   }
33383
33384 }
33385
33386
33387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33388   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33389   unsigned int arg2 ;
33390
33391   arg1 = (Dali::Timer *)jarg1;
33392   arg2 = (unsigned int)jarg2;
33393   {
33394     try {
33395       (arg1)->SetInterval(arg2);
33396     } CALL_CATCH_EXCEPTION();
33397   }
33398
33399 }
33400
33401
33402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33403   unsigned int jresult ;
33404   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33405   unsigned int result;
33406
33407   arg1 = (Dali::Timer *)jarg1;
33408   {
33409     try {
33410       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33411     } CALL_CATCH_EXCEPTION(0);
33412   }
33413
33414   jresult = result;
33415   return jresult;
33416 }
33417
33418
33419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33420   unsigned int jresult ;
33421   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33422   bool result;
33423
33424   arg1 = (Dali::Timer *)jarg1;
33425   {
33426     try {
33427       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33428     } CALL_CATCH_EXCEPTION(0);
33429   }
33430
33431   jresult = result;
33432   return jresult;
33433 }
33434
33435
33436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33437   void * jresult ;
33438   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33439   Dali::Timer::TimerSignalType *result = 0 ;
33440
33441   arg1 = (Dali::Timer *)jarg1;
33442   {
33443     try {
33444       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33445     } CALL_CATCH_EXCEPTION(0);
33446   }
33447
33448   jresult = (void *)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33454   unsigned int jresult ;
33455   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33456   bool result;
33457
33458   arg1 = (Dali::Signal< bool () > *)jarg1;
33459   {
33460     try {
33461       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33462     } CALL_CATCH_EXCEPTION(0);
33463   }
33464
33465   jresult = result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33471   unsigned long jresult ;
33472   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33473   std::size_t result;
33474
33475   arg1 = (Dali::Signal< bool () > *)jarg1;
33476   {
33477     try {
33478       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33479     } CALL_CATCH_EXCEPTION(0);
33480   }
33481
33482   jresult = (unsigned long)result;
33483   return jresult;
33484 }
33485
33486
33487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33488   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33489   bool (*arg2)() = (bool (*)()) 0 ;
33490
33491   arg1 = (Dali::Signal< bool () > *)jarg1;
33492   arg2 = (bool (*)())jarg2;
33493   {
33494     try {
33495       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33496     } CALL_CATCH_EXCEPTION();
33497   }
33498
33499 }
33500
33501
33502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33503   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33504   bool (*arg2)() = (bool (*)()) 0 ;
33505
33506   arg1 = (Dali::Signal< bool () > *)jarg1;
33507   arg2 = (bool (*)())jarg2;
33508   {
33509     try {
33510       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33511     } CALL_CATCH_EXCEPTION();
33512   }
33513
33514 }
33515
33516
33517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33518   unsigned int jresult ;
33519   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33520   bool result;
33521
33522   arg1 = (Dali::Signal< bool () > *)jarg1;
33523   {
33524     try {
33525       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33526     } CALL_CATCH_EXCEPTION(0);
33527   }
33528
33529   jresult = result;
33530   return jresult;
33531 }
33532
33533
33534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33535   void * jresult ;
33536   Dali::Signal< bool () > *result = 0 ;
33537
33538   {
33539     try {
33540       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33541     } CALL_CATCH_EXCEPTION(0);
33542   }
33543
33544   jresult = (void *)result;
33545   return jresult;
33546 }
33547
33548
33549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33550   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33551
33552   arg1 = (Dali::Signal< bool () > *)jarg1;
33553   {
33554     try {
33555       delete arg1;
33556     } CALL_CATCH_EXCEPTION();
33557   }
33558
33559 }
33560
33561
33562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33563   int jresult ;
33564   int result;
33565
33566   {
33567     try {
33568       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33569     } CALL_CATCH_EXCEPTION(0);
33570   }
33571
33572   jresult = (int)result;
33573   return jresult;
33574 }
33575
33576
33577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33578   int jresult ;
33579   int result;
33580
33581   {
33582     try {
33583       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33584     } CALL_CATCH_EXCEPTION(0);
33585   }
33586
33587   jresult = (int)result;
33588   return jresult;
33589 }
33590
33591
33592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33593   int jresult ;
33594   int result;
33595
33596   {
33597     try {
33598       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33599     } CALL_CATCH_EXCEPTION(0);
33600   }
33601
33602   jresult = (int)result;
33603   return jresult;
33604 }
33605
33606
33607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33608   int jresult ;
33609   int result;
33610
33611   {
33612     try {
33613       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33614     } CALL_CATCH_EXCEPTION(0);
33615   }
33616
33617   jresult = (int)result;
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33623   int jresult ;
33624   int result;
33625
33626   {
33627     try {
33628       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33629     } CALL_CATCH_EXCEPTION(0);
33630   }
33631
33632   jresult = (int)result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33638   int jresult ;
33639   int result;
33640
33641   {
33642     try {
33643       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33644     } CALL_CATCH_EXCEPTION(0);
33645   }
33646
33647   jresult = (int)result;
33648   return jresult;
33649 }
33650
33651
33652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33653   int jresult ;
33654   int result;
33655
33656   {
33657     try {
33658       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33659     } CALL_CATCH_EXCEPTION(0);
33660   }
33661
33662   jresult = (int)result;
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33668   int jresult ;
33669   int result;
33670
33671   {
33672     try {
33673       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33674     } CALL_CATCH_EXCEPTION(0);
33675   }
33676
33677   jresult = (int)result;
33678   return jresult;
33679 }
33680
33681
33682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33683   int jresult ;
33684   int result;
33685
33686   {
33687     try {
33688       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33689     } CALL_CATCH_EXCEPTION(0);
33690   }
33691
33692   jresult = (int)result;
33693   return jresult;
33694 }
33695
33696
33697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33698   int jresult ;
33699   int result;
33700
33701   {
33702     try {
33703       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33704     } CALL_CATCH_EXCEPTION(0);
33705   }
33706
33707   jresult = (int)result;
33708   return jresult;
33709 }
33710
33711
33712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33713   int jresult ;
33714   int result;
33715
33716   {
33717     try {
33718       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33719     } CALL_CATCH_EXCEPTION(0);
33720   }
33721
33722   jresult = (int)result;
33723   return jresult;
33724 }
33725
33726
33727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33728   int jresult ;
33729   int result;
33730
33731   {
33732     try {
33733       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33734     } CALL_CATCH_EXCEPTION(0);
33735   }
33736
33737   jresult = (int)result;
33738   return jresult;
33739 }
33740
33741
33742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33743   int jresult ;
33744   int result;
33745
33746   {
33747     try {
33748       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33749     } CALL_CATCH_EXCEPTION(0);
33750   }
33751
33752   jresult = (int)result;
33753   return jresult;
33754 }
33755
33756
33757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33758   int jresult ;
33759   int result;
33760
33761   {
33762     try {
33763       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33764     } CALL_CATCH_EXCEPTION(0);
33765   }
33766
33767   jresult = (int)result;
33768   return jresult;
33769 }
33770
33771
33772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33773   int jresult ;
33774   int result;
33775
33776   {
33777     try {
33778       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33779     } CALL_CATCH_EXCEPTION(0);
33780   }
33781
33782   jresult = (int)result;
33783   return jresult;
33784 }
33785
33786
33787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33788   int jresult ;
33789   int result;
33790
33791   {
33792     try {
33793       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33794     } CALL_CATCH_EXCEPTION(0);
33795   }
33796
33797   jresult = (int)result;
33798   return jresult;
33799 }
33800
33801
33802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33803   int jresult ;
33804   int result;
33805
33806   {
33807     try {
33808       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33809     } CALL_CATCH_EXCEPTION(0);
33810   }
33811
33812   jresult = (int)result;
33813   return jresult;
33814 }
33815
33816
33817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33818   int jresult ;
33819   int result;
33820
33821   {
33822     try {
33823       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33824     } CALL_CATCH_EXCEPTION(0);
33825   }
33826
33827   jresult = (int)result;
33828   return jresult;
33829 }
33830
33831
33832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33833   int jresult ;
33834   int result;
33835
33836   {
33837     try {
33838       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33839     } CALL_CATCH_EXCEPTION(0);
33840   }
33841
33842   jresult = (int)result;
33843   return jresult;
33844 }
33845
33846
33847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
33848   int jresult ;
33849   int result;
33850
33851   {
33852     try {
33853       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
33854     } CALL_CATCH_EXCEPTION(0);
33855   }
33856
33857   jresult = (int)result;
33858   return jresult;
33859 }
33860
33861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
33862   int jresult ;
33863   int result;
33864
33865   {
33866     try {
33867       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
33868     } CALL_CATCH_EXCEPTION(0);
33869   }
33870
33871   jresult = (int)result;
33872   return jresult;
33873 }
33874
33875
33876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
33877   int jresult ;
33878   int result;
33879   {
33880     try
33881     {
33882       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
33883     } CALL_CATCH_EXCEPTION(0);
33884   }
33885
33886   jresult = (int)result;
33887   return jresult;
33888 }
33889
33890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
33891   int jresult ;
33892   int result;
33893   {
33894     try
33895     {
33896       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
33897     } CALL_CATCH_EXCEPTION(0);
33898   }
33899
33900   jresult = (int)result;
33901   return jresult;
33902 }
33903
33904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
33905   int jresult ;
33906   int result;
33907   {
33908     try
33909     {
33910       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
33911     } CALL_CATCH_EXCEPTION(0);
33912   }
33913
33914   jresult = (int)result;
33915   return jresult;
33916 }
33917
33918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
33919   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
33920 }
33921
33922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
33923   int jresult ;
33924   int result;
33925   {
33926     try
33927     {
33928       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
33929     } CALL_CATCH_EXCEPTION(0);
33930   }
33931
33932   jresult = (int)result;
33933   return jresult;
33934 }
33935
33936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
33937   int jresult ;
33938   int result;
33939   {
33940     try
33941     {
33942       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
33943     } CALL_CATCH_EXCEPTION(0);
33944   }
33945
33946   jresult = (int)result;
33947   return jresult;
33948 }
33949
33950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
33951   int jresult ;
33952   int result;
33953
33954   {
33955     try {
33956       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
33957     } CALL_CATCH_EXCEPTION(0);
33958   }
33959
33960   jresult = (int)result;
33961   return jresult;
33962 }
33963
33964
33965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
33966   int jresult ;
33967   int result;
33968
33969   {
33970     try {
33971       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
33972     } CALL_CATCH_EXCEPTION(0);
33973   }
33974
33975   jresult = (int)result;
33976   return jresult;
33977 }
33978
33979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
33980   int jresult ;
33981   int result;
33982   {
33983     try
33984     {
33985       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
33986     } CALL_CATCH_EXCEPTION(0);
33987   }
33988
33989   jresult = (int)result;
33990   return jresult;
33991 }
33992
33993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
33994   int jresult ;
33995   int result;
33996   {
33997     try
33998     {
33999       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34000     } CALL_CATCH_EXCEPTION(0);
34001   }
34002
34003   jresult = (int)result;
34004   return jresult;
34005 }
34006
34007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34008   int jresult ;
34009   int result;
34010   {
34011     try
34012     {
34013       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34014     } CALL_CATCH_EXCEPTION(0);
34015   }
34016
34017   jresult = (int)result;
34018   return jresult;
34019 }
34020
34021
34022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34023   int jresult ;
34024   int result;
34025   {
34026     try
34027     {
34028       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34029     } CALL_CATCH_EXCEPTION(0);
34030   }
34031
34032   jresult = (int)result;
34033   return jresult;
34034 }
34035
34036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34037   int jresult ;
34038   int result;
34039   {
34040     try
34041     {
34042       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34043     } CALL_CATCH_EXCEPTION(0);
34044   }
34045
34046   jresult = (int)result;
34047   return jresult;
34048 }
34049
34050
34051
34052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34053   int jresult ;
34054   int result;
34055
34056   {
34057     try {
34058       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34059     } CALL_CATCH_EXCEPTION(0);
34060   }
34061
34062   jresult = (int)result;
34063   return jresult;
34064 }
34065
34066
34067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34068   int jresult ;
34069   int result;
34070
34071   {
34072     try {
34073       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34074     } CALL_CATCH_EXCEPTION(0);
34075   }
34076
34077   jresult = (int)result;
34078   return jresult;
34079 }
34080
34081
34082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34083   int jresult ;
34084   int result;
34085
34086   {
34087     try {
34088       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34089     } CALL_CATCH_EXCEPTION(0);
34090   }
34091
34092   jresult = (int)result;
34093   return jresult;
34094 }
34095
34096
34097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34098   int jresult ;
34099   int result;
34100
34101   {
34102     try {
34103       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34104     } CALL_CATCH_EXCEPTION(0);
34105   }
34106
34107   jresult = (int)result;
34108   return jresult;
34109 }
34110
34111
34112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34113   int jresult ;
34114   int result;
34115
34116   {
34117     try {
34118       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34119     } CALL_CATCH_EXCEPTION(0);
34120   }
34121
34122   jresult = (int)result;
34123   return jresult;
34124 }
34125
34126
34127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34128   int jresult ;
34129   int result;
34130
34131   {
34132     try {
34133       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34134     } CALL_CATCH_EXCEPTION(0);
34135   }
34136
34137   jresult = (int)result;
34138   return jresult;
34139 }
34140
34141
34142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34143   int jresult ;
34144   int result;
34145
34146   {
34147     try {
34148       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34149     } CALL_CATCH_EXCEPTION(0);
34150   }
34151
34152   jresult = (int)result;
34153   return jresult;
34154 }
34155
34156 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34157   int jresult ;
34158   int result;
34159
34160   {
34161     try {
34162       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34163     } CALL_CATCH_EXCEPTION(0);
34164   }
34165
34166   jresult = (int)result;
34167   return jresult;
34168 }
34169
34170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34171   int jresult ;
34172   int result;
34173
34174   {
34175     try {
34176       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34177     } CALL_CATCH_EXCEPTION(0);
34178   }
34179
34180   jresult = (int)result;
34181   return jresult;
34182 }
34183
34184
34185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34186   int jresult ;
34187   int result;
34188
34189   {
34190     try {
34191       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34192     } CALL_CATCH_EXCEPTION(0);
34193   }
34194
34195   jresult = (int)result;
34196   return jresult;
34197 }
34198
34199
34200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34201   int jresult ;
34202   int result;
34203
34204   {
34205     try {
34206       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34207     } CALL_CATCH_EXCEPTION(0);
34208   }
34209
34210   jresult = (int)result;
34211   return jresult;
34212 }
34213
34214
34215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34216   int jresult ;
34217   int result;
34218
34219   {
34220     try {
34221       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34222     } CALL_CATCH_EXCEPTION(0);
34223   }
34224
34225   jresult = (int)result;
34226   return jresult;
34227 }
34228
34229
34230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34231   int jresult ;
34232   int result;
34233
34234   {
34235     try {
34236       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34237     } CALL_CATCH_EXCEPTION(0);
34238   }
34239
34240   jresult = (int)result;
34241   return jresult;
34242 }
34243
34244
34245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34246   int jresult ;
34247   int result;
34248
34249   {
34250     try {
34251       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34252     } CALL_CATCH_EXCEPTION(0);
34253   }
34254
34255   jresult = (int)result;
34256   return jresult;
34257 }
34258
34259
34260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34261   int jresult ;
34262   int result;
34263
34264   {
34265     try {
34266       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34267     } CALL_CATCH_EXCEPTION(0);
34268   }
34269
34270   jresult = (int)result;
34271   return jresult;
34272 }
34273
34274
34275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34276   int jresult ;
34277   int result;
34278
34279   {
34280     try {
34281       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34282     } CALL_CATCH_EXCEPTION(0);
34283   }
34284
34285   jresult = (int)result;
34286   return jresult;
34287 }
34288
34289
34290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34291   int jresult ;
34292   int result;
34293
34294   {
34295     try {
34296       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34297     } CALL_CATCH_EXCEPTION(0);
34298   }
34299
34300   jresult = (int)result;
34301   return jresult;
34302 }
34303
34304
34305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34306   int jresult ;
34307   int result;
34308
34309   {
34310     try {
34311       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34312     } CALL_CATCH_EXCEPTION(0);
34313   }
34314
34315   jresult = (int)result;
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34321   int jresult ;
34322   int result;
34323
34324   {
34325     try {
34326       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34327     } CALL_CATCH_EXCEPTION(0);
34328   }
34329
34330   jresult = (int)result;
34331   return jresult;
34332 }
34333
34334
34335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34336   int jresult ;
34337   int result;
34338
34339   {
34340     try {
34341       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34342     } CALL_CATCH_EXCEPTION(0);
34343   }
34344
34345   jresult = (int)result;
34346   return jresult;
34347 }
34348
34349
34350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34351   int jresult ;
34352   int result;
34353
34354   {
34355     try {
34356       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34357     } CALL_CATCH_EXCEPTION(0);
34358   }
34359
34360   jresult = (int)result;
34361   return jresult;
34362 }
34363
34364
34365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34366   int jresult ;
34367   int result;
34368
34369   {
34370     try {
34371       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34372     } CALL_CATCH_EXCEPTION(0);
34373   }
34374
34375   jresult = (int)result;
34376   return jresult;
34377 }
34378
34379
34380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34381   int jresult ;
34382   int result;
34383
34384   {
34385     try {
34386       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34387     } CALL_CATCH_EXCEPTION(0);
34388   }
34389
34390   jresult = (int)result;
34391   return jresult;
34392 }
34393
34394
34395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34396   int jresult ;
34397   int result;
34398
34399   {
34400     try {
34401       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34402     } CALL_CATCH_EXCEPTION(0);
34403   }
34404
34405   jresult = (int)result;
34406   return jresult;
34407 }
34408
34409
34410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34411   int jresult ;
34412   int result;
34413
34414   {
34415     try {
34416       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34417     } CALL_CATCH_EXCEPTION(0);
34418   }
34419
34420   jresult = (int)result;
34421   return jresult;
34422 }
34423
34424
34425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34426   int jresult ;
34427   int result;
34428
34429   {
34430     try {
34431       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34432     } CALL_CATCH_EXCEPTION(0);
34433   }
34434
34435   jresult = (int)result;
34436   return jresult;
34437 }
34438
34439
34440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34441   int jresult ;
34442   int result;
34443
34444   {
34445     try {
34446       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34447     } CALL_CATCH_EXCEPTION(0);
34448   }
34449
34450   jresult = (int)result;
34451   return jresult;
34452 }
34453
34454
34455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34456   int jresult ;
34457   int result;
34458
34459   {
34460     try {
34461       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34462     } CALL_CATCH_EXCEPTION(0);
34463   }
34464
34465   jresult = (int)result;
34466   return jresult;
34467 }
34468
34469
34470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34471   int jresult ;
34472   int result;
34473
34474   {
34475     try {
34476       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34477     } CALL_CATCH_EXCEPTION(0);
34478   }
34479
34480   jresult = (int)result;
34481   return jresult;
34482 }
34483
34484
34485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34486   int jresult ;
34487   int result;
34488
34489   {
34490     try {
34491       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34492     } CALL_CATCH_EXCEPTION(0);
34493   }
34494
34495   jresult = (int)result;
34496   return jresult;
34497 }
34498
34499
34500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34501   int jresult ;
34502   int result;
34503
34504   {
34505     try {
34506       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34507     } CALL_CATCH_EXCEPTION(0);
34508   }
34509
34510   jresult = (int)result;
34511   return jresult;
34512 }
34513
34514
34515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34516   int jresult ;
34517   int result;
34518
34519   {
34520     try {
34521       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34522     } CALL_CATCH_EXCEPTION(0);
34523   }
34524
34525   jresult = (int)result;
34526   return jresult;
34527 }
34528
34529
34530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34531   int jresult ;
34532   int result;
34533
34534   {
34535     try {
34536       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34537     } CALL_CATCH_EXCEPTION(0);
34538   }
34539
34540   jresult = (int)result;
34541   return jresult;
34542 }
34543
34544
34545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34546   int jresult ;
34547   int result;
34548
34549   {
34550     try {
34551       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34552     } CALL_CATCH_EXCEPTION(0);
34553   }
34554
34555   jresult = (int)result;
34556   return jresult;
34557 }
34558
34559
34560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34561   int jresult ;
34562   int result;
34563
34564   {
34565     try {
34566       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34567     } CALL_CATCH_EXCEPTION(0);
34568   }
34569
34570   jresult = (int)result;
34571   return jresult;
34572 }
34573
34574
34575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34576   int jresult ;
34577   int result;
34578
34579   {
34580     try {
34581       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34582     } CALL_CATCH_EXCEPTION(0);
34583   }
34584
34585   jresult = (int)result;
34586   return jresult;
34587 }
34588
34589
34590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34591   void * jresult ;
34592   Dali::Toolkit::Builder *result = 0 ;
34593
34594   {
34595     try {
34596       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34597     } CALL_CATCH_EXCEPTION(0);
34598   }
34599
34600   jresult = (void *)result;
34601   return jresult;
34602 }
34603
34604
34605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34606   void * jresult ;
34607   Dali::Toolkit::Builder result;
34608
34609   {
34610     try {
34611       result = Dali::Toolkit::Builder::New();
34612     } CALL_CATCH_EXCEPTION(0);
34613   }
34614
34615   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34616   return jresult;
34617 }
34618
34619
34620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34621   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34622
34623   arg1 = (Dali::Toolkit::Builder *)jarg1;
34624   {
34625     try {
34626       delete arg1;
34627     } CALL_CATCH_EXCEPTION();
34628   }
34629
34630 }
34631
34632
34633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34634   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34635   std::string *arg2 = 0 ;
34636   Dali::Toolkit::Builder::UIFormat arg3 ;
34637
34638   arg1 = (Dali::Toolkit::Builder *)jarg1;
34639   if (!jarg2) {
34640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34641     return ;
34642   }
34643   std::string arg2_str(jarg2);
34644   arg2 = &arg2_str;
34645   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34646   {
34647     try {
34648       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34649     } CALL_CATCH_EXCEPTION();
34650   }
34651
34652
34653   //argout typemap for const std::string&
34654
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34659   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34660   std::string *arg2 = 0 ;
34661
34662   arg1 = (Dali::Toolkit::Builder *)jarg1;
34663   if (!jarg2) {
34664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34665     return ;
34666   }
34667   std::string arg2_str(jarg2);
34668   arg2 = &arg2_str;
34669   {
34670     try {
34671       (arg1)->LoadFromString((std::string const &)*arg2);
34672     } CALL_CATCH_EXCEPTION();
34673   }
34674
34675
34676   //argout typemap for const std::string&
34677
34678 }
34679
34680
34681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34683   Dali::Property::Map *arg2 = 0 ;
34684
34685   arg1 = (Dali::Toolkit::Builder *)jarg1;
34686   arg2 = (Dali::Property::Map *)jarg2;
34687   if (!arg2) {
34688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34689     return ;
34690   }
34691   {
34692     try {
34693       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34694     } CALL_CATCH_EXCEPTION();
34695   }
34696
34697 }
34698
34699
34700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34701   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34702   std::string *arg2 = 0 ;
34703   Dali::Property::Value *arg3 = 0 ;
34704
34705   arg1 = (Dali::Toolkit::Builder *)jarg1;
34706   if (!jarg2) {
34707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34708     return ;
34709   }
34710   std::string arg2_str(jarg2);
34711   arg2 = &arg2_str;
34712   arg3 = (Dali::Property::Value *)jarg3;
34713   if (!arg3) {
34714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34715     return ;
34716   }
34717   {
34718     try {
34719       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34720     } CALL_CATCH_EXCEPTION();
34721   }
34722
34723
34724   //argout typemap for const std::string&
34725
34726 }
34727
34728
34729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34730   void * jresult ;
34731   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34732   Dali::Property::Map *result = 0 ;
34733
34734   arg1 = (Dali::Toolkit::Builder *)jarg1;
34735   {
34736     try {
34737       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34738     } CALL_CATCH_EXCEPTION(0);
34739   }
34740
34741   jresult = (void *)result;
34742   return jresult;
34743 }
34744
34745
34746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34747   void * jresult ;
34748   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34749   std::string *arg2 = 0 ;
34750   Dali::Property::Value *result = 0 ;
34751
34752   arg1 = (Dali::Toolkit::Builder *)jarg1;
34753   if (!jarg2) {
34754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34755     return 0;
34756   }
34757   std::string arg2_str(jarg2);
34758   arg2 = &arg2_str;
34759   {
34760     try {
34761       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34762     } CALL_CATCH_EXCEPTION(0);
34763   }
34764
34765   jresult = (void *)result;
34766
34767   //argout typemap for const std::string&
34768
34769   return jresult;
34770 }
34771
34772
34773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34774   void * jresult ;
34775   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34776   std::string *arg2 = 0 ;
34777   Dali::Animation result;
34778
34779   arg1 = (Dali::Toolkit::Builder *)jarg1;
34780   if (!jarg2) {
34781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34782     return 0;
34783   }
34784   std::string arg2_str(jarg2);
34785   arg2 = &arg2_str;
34786   {
34787     try {
34788       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34789     } CALL_CATCH_EXCEPTION(0);
34790   }
34791
34792   jresult = new Dali::Animation((const Dali::Animation &)result);
34793
34794   //argout typemap for const std::string&
34795
34796   return jresult;
34797 }
34798
34799
34800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34801   void * jresult ;
34802   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34803   std::string *arg2 = 0 ;
34804   Dali::Property::Map *arg3 = 0 ;
34805   Dali::Animation result;
34806
34807   arg1 = (Dali::Toolkit::Builder *)jarg1;
34808   if (!jarg2) {
34809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34810     return 0;
34811   }
34812   std::string arg2_str(jarg2);
34813   arg2 = &arg2_str;
34814   arg3 = (Dali::Property::Map *)jarg3;
34815   if (!arg3) {
34816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34817     return 0;
34818   }
34819   {
34820     try {
34821       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34822     } CALL_CATCH_EXCEPTION(0);
34823   }
34824
34825   jresult = new Dali::Animation((const Dali::Animation &)result);
34826
34827   //argout typemap for const std::string&
34828
34829   return jresult;
34830 }
34831
34832
34833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34834   void * jresult ;
34835   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34836   std::string *arg2 = 0 ;
34837   Dali::Actor arg3 ;
34838   Dali::Actor *argp3 ;
34839   Dali::Animation result;
34840
34841   arg1 = (Dali::Toolkit::Builder *)jarg1;
34842   if (!jarg2) {
34843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34844     return 0;
34845   }
34846   std::string arg2_str(jarg2);
34847   arg2 = &arg2_str;
34848   argp3 = (Dali::Actor *)jarg3;
34849   if (!argp3) {
34850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34851     return 0;
34852   }
34853   arg3 = *argp3;
34854   {
34855     try {
34856       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
34857     } CALL_CATCH_EXCEPTION(0);
34858   }
34859
34860   jresult = new Dali::Animation((const Dali::Animation &)result);
34861
34862   //argout typemap for const std::string&
34863
34864   return jresult;
34865 }
34866
34867
34868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
34869   void * jresult ;
34870   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34871   std::string *arg2 = 0 ;
34872   Dali::Property::Map *arg3 = 0 ;
34873   Dali::Actor arg4 ;
34874   Dali::Actor *argp4 ;
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   arg3 = (Dali::Property::Map *)jarg3;
34885   if (!arg3) {
34886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34887     return 0;
34888   }
34889   argp4 = (Dali::Actor *)jarg4;
34890   if (!argp4) {
34891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34892     return 0;
34893   }
34894   arg4 = *argp4;
34895   {
34896     try {
34897       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
34898     } CALL_CATCH_EXCEPTION(0);
34899   }
34900
34901   jresult = new Dali::Animation((const Dali::Animation &)result);
34902
34903   //argout typemap for const std::string&
34904
34905   return jresult;
34906 }
34907
34908
34909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
34910   void * jresult ;
34911   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34912   std::string *arg2 = 0 ;
34913   Dali::BaseHandle result;
34914
34915   arg1 = (Dali::Toolkit::Builder *)jarg1;
34916   if (!jarg2) {
34917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34918     return 0;
34919   }
34920   std::string arg2_str(jarg2);
34921   arg2 = &arg2_str;
34922   {
34923     try {
34924       result = (arg1)->Create((std::string const &)*arg2);
34925     } CALL_CATCH_EXCEPTION(0);
34926   }
34927
34928   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
34929
34930   //argout typemap for const std::string&
34931
34932   return jresult;
34933 }
34934
34935
34936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34937   void * jresult ;
34938   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34939   std::string *arg2 = 0 ;
34940   Dali::Property::Map *arg3 = 0 ;
34941   Dali::BaseHandle result;
34942
34943   arg1 = (Dali::Toolkit::Builder *)jarg1;
34944   if (!jarg2) {
34945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34946     return 0;
34947   }
34948   std::string arg2_str(jarg2);
34949   arg2 = &arg2_str;
34950   arg3 = (Dali::Property::Map *)jarg3;
34951   if (!arg3) {
34952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34953     return 0;
34954   }
34955   {
34956     try {
34957       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34958     } CALL_CATCH_EXCEPTION(0);
34959   }
34960
34961   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
34962
34963   //argout typemap for const std::string&
34964
34965   return jresult;
34966 }
34967
34968
34969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
34970   void * jresult ;
34971   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34972   std::string *arg2 = 0 ;
34973   Dali::BaseHandle result;
34974
34975   arg1 = (Dali::Toolkit::Builder *)jarg1;
34976   if (!jarg2) {
34977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34978     return 0;
34979   }
34980   std::string arg2_str(jarg2);
34981   arg2 = &arg2_str;
34982   {
34983     try {
34984       result = (arg1)->CreateFromJson((std::string const &)*arg2);
34985     } CALL_CATCH_EXCEPTION(0);
34986   }
34987
34988   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
34989
34990   //argout typemap for const std::string&
34991
34992   return jresult;
34993 }
34994
34995
34996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
34997   unsigned int jresult ;
34998   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34999   std::string *arg2 = 0 ;
35000   Dali::Handle *arg3 = 0 ;
35001   bool result;
35002
35003   arg1 = (Dali::Toolkit::Builder *)jarg1;
35004   if (!jarg2) {
35005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35006     return 0;
35007   }
35008   std::string arg2_str(jarg2);
35009   arg2 = &arg2_str;
35010   arg3 = (Dali::Handle *)jarg3;
35011   if (!arg3) {
35012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35013     return 0;
35014   }
35015   {
35016     try {
35017       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35018     } CALL_CATCH_EXCEPTION(0);
35019   }
35020
35021   jresult = result;
35022
35023   //argout typemap for const std::string&
35024
35025   return jresult;
35026 }
35027
35028
35029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35030   unsigned int jresult ;
35031   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35032   Dali::Handle *arg2 = 0 ;
35033   std::string *arg3 = 0 ;
35034   bool result;
35035
35036   arg1 = (Dali::Toolkit::Builder *)jarg1;
35037   arg2 = (Dali::Handle *)jarg2;
35038   if (!arg2) {
35039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35040     return 0;
35041   }
35042   if (!jarg3) {
35043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35044     return 0;
35045   }
35046   std::string arg3_str(jarg3);
35047   arg3 = &arg3_str;
35048   {
35049     try {
35050       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35051     } CALL_CATCH_EXCEPTION(0);
35052   }
35053
35054   jresult = result;
35055
35056   //argout typemap for const std::string&
35057
35058   return jresult;
35059 }
35060
35061
35062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35063   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35064   Dali::Actor arg2 ;
35065   Dali::Actor *argp2 ;
35066
35067   arg1 = (Dali::Toolkit::Builder *)jarg1;
35068   argp2 = (Dali::Actor *)jarg2;
35069   if (!argp2) {
35070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35071     return ;
35072   }
35073   arg2 = *argp2;
35074   {
35075     try {
35076       (arg1)->AddActors(arg2);
35077     } CALL_CATCH_EXCEPTION();
35078   }
35079
35080 }
35081
35082
35083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35084   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35085   std::string *arg2 = 0 ;
35086   Dali::Actor arg3 ;
35087   Dali::Actor *argp3 ;
35088
35089   arg1 = (Dali::Toolkit::Builder *)jarg1;
35090   if (!jarg2) {
35091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35092     return ;
35093   }
35094   std::string arg2_str(jarg2);
35095   arg2 = &arg2_str;
35096   argp3 = (Dali::Actor *)jarg3;
35097   if (!argp3) {
35098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35099     return ;
35100   }
35101   arg3 = *argp3;
35102   {
35103     try {
35104       (arg1)->AddActors((std::string const &)*arg2,arg3);
35105     } CALL_CATCH_EXCEPTION();
35106   }
35107
35108
35109   //argout typemap for const std::string&
35110
35111 }
35112
35113
35114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35115   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35116   std::string *arg2 = 0 ;
35117
35118   arg1 = (Dali::Toolkit::Builder *)jarg1;
35119   if (!jarg2) {
35120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35121     return ;
35122   }
35123   std::string arg2_str(jarg2);
35124   arg2 = &arg2_str;
35125   {
35126     try {
35127       (arg1)->CreateRenderTask((std::string const &)*arg2);
35128     } CALL_CATCH_EXCEPTION();
35129   }
35130
35131
35132   //argout typemap for const std::string&
35133
35134 }
35135
35136
35137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35138   void * jresult ;
35139   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35140   std::string *arg2 = 0 ;
35141   Dali::Path result;
35142
35143   arg1 = (Dali::Toolkit::Builder *)jarg1;
35144   if (!jarg2) {
35145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35146     return 0;
35147   }
35148   std::string arg2_str(jarg2);
35149   arg2 = &arg2_str;
35150   {
35151     try {
35152       result = (arg1)->GetPath((std::string const &)*arg2);
35153     } CALL_CATCH_EXCEPTION(0);
35154   }
35155
35156   jresult = new Dali::Path((const Dali::Path &)result);
35157
35158   //argout typemap for const std::string&
35159
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35165   void * jresult ;
35166   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35167   std::string *arg2 = 0 ;
35168   Dali::PathConstrainer result;
35169
35170   arg1 = (Dali::Toolkit::Builder *)jarg1;
35171   if (!jarg2) {
35172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35173     return 0;
35174   }
35175   std::string arg2_str(jarg2);
35176   arg2 = &arg2_str;
35177   {
35178     try {
35179       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35180     } CALL_CATCH_EXCEPTION(0);
35181   }
35182
35183   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35184
35185   //argout typemap for const std::string&
35186
35187   return jresult;
35188 }
35189
35190
35191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35192   void * jresult ;
35193   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35194   std::string *arg2 = 0 ;
35195   Dali::LinearConstrainer result;
35196
35197   arg1 = (Dali::Toolkit::Builder *)jarg1;
35198   if (!jarg2) {
35199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35200     return 0;
35201   }
35202   std::string arg2_str(jarg2);
35203   arg2 = &arg2_str;
35204   {
35205     try {
35206       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35207     } CALL_CATCH_EXCEPTION(0);
35208   }
35209
35210   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35211
35212   //argout typemap for const std::string&
35213
35214   return jresult;
35215 }
35216
35217
35218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35219   void * jresult ;
35220   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35221   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35222
35223   arg1 = (Dali::Toolkit::Builder *)jarg1;
35224   {
35225     try {
35226       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35227     } CALL_CATCH_EXCEPTION(0);
35228   }
35229
35230   jresult = (void *)result;
35231   return jresult;
35232 }
35233
35234
35235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35236   void * jresult ;
35237   Dali::Toolkit::TransitionData *result = 0 ;
35238
35239   {
35240     try {
35241       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35242     } CALL_CATCH_EXCEPTION(0);
35243   }
35244
35245   jresult = (void *)result;
35246   return jresult;
35247 }
35248
35249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35250   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35251
35252   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35253   {
35254     try {
35255       delete arg1;
35256     } CALL_CATCH_EXCEPTION();
35257   }
35258
35259 }
35260
35261
35262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35263   void * jresult ;
35264   Dali::Property::Map *arg1 = 0 ;
35265   Dali::Toolkit::TransitionData result;
35266
35267   arg1 = (Dali::Property::Map *)jarg1;
35268   if (!arg1) {
35269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35270     return 0;
35271   }
35272   {
35273     try {
35274       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35275     } CALL_CATCH_EXCEPTION(0);
35276   }
35277
35278   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35279   return jresult;
35280 }
35281
35282
35283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35284   void * jresult ;
35285   Dali::Property::Array *arg1 = 0 ;
35286   Dali::Toolkit::TransitionData result;
35287
35288   arg1 = (Dali::Property::Array *)jarg1;
35289   if (!arg1) {
35290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35291     return 0;
35292   }
35293   {
35294     try {
35295       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35296     } CALL_CATCH_EXCEPTION(0);
35297   }
35298
35299   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35300   return jresult;
35301 }
35302
35303
35304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35305   void * jresult ;
35306   Dali::BaseHandle arg1 ;
35307   Dali::BaseHandle *argp1 ;
35308   Dali::Toolkit::TransitionData result;
35309
35310   argp1 = (Dali::BaseHandle *)jarg1;
35311   if (!argp1) {
35312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35313     return 0;
35314   }
35315   arg1 = *argp1;
35316   {
35317     try {
35318       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35319     } CALL_CATCH_EXCEPTION(0);
35320   }
35321
35322   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35323   return jresult;
35324 }
35325
35326
35327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35328   void * jresult ;
35329   Dali::Toolkit::TransitionData *arg1 = 0 ;
35330   Dali::Toolkit::TransitionData *result = 0 ;
35331
35332   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35333   if (!arg1) {
35334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35335     return 0;
35336   }
35337   {
35338     try {
35339       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35340     } CALL_CATCH_EXCEPTION(0);
35341   }
35342
35343   jresult = (void *)result;
35344   return jresult;
35345 }
35346
35347
35348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35349   void * jresult ;
35350   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35351   Dali::Toolkit::TransitionData *arg2 = 0 ;
35352   Dali::Toolkit::TransitionData *result = 0 ;
35353
35354   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35355   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35356   if (!arg2) {
35357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35358     return 0;
35359   }
35360   {
35361     try {
35362       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35363     } CALL_CATCH_EXCEPTION(0);
35364   }
35365
35366   jresult = (void *)result;
35367   return jresult;
35368 }
35369
35370
35371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35372   unsigned long jresult ;
35373   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35374   size_t result;
35375
35376   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35377   {
35378     try {
35379       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35380     } CALL_CATCH_EXCEPTION(0);
35381   }
35382
35383   jresult = (unsigned long)result;
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35389   void * jresult ;
35390   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35391   size_t arg2 ;
35392   Dali::Property::Map result;
35393
35394   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35395   arg2 = (size_t)jarg2;
35396   {
35397     try {
35398       result = (arg1)->GetAnimatorAt(arg2);
35399     } CALL_CATCH_EXCEPTION(0);
35400   }
35401
35402   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35403   return jresult;
35404 }
35405
35406
35407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35408   int jresult ;
35409   int result;
35410
35411   {
35412     try {
35413       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35414     } CALL_CATCH_EXCEPTION(0);
35415   }
35416
35417   jresult = (int)result;
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35423   int jresult ;
35424   int result;
35425
35426   {
35427     try {
35428       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35429     } CALL_CATCH_EXCEPTION(0);
35430   }
35431
35432   jresult = (int)result;
35433   return jresult;
35434 }
35435
35436
35437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35438   int jresult ;
35439   int result;
35440
35441   {
35442     try {
35443       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35444     } CALL_CATCH_EXCEPTION(0);
35445   }
35446
35447   jresult = (int)result;
35448   return jresult;
35449 }
35450
35451
35452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35453   int jresult ;
35454   int result;
35455
35456   {
35457     try {
35458       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35459     } CALL_CATCH_EXCEPTION(0);
35460   }
35461
35462   jresult = (int)result;
35463   return jresult;
35464 }
35465
35466
35467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35468   int jresult ;
35469   int result;
35470
35471   {
35472     try {
35473       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35474     } CALL_CATCH_EXCEPTION(0);
35475   }
35476
35477   jresult = (int)result;
35478   return jresult;
35479 }
35480
35481
35482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35483   int jresult ;
35484   int result;
35485
35486   {
35487     try {
35488       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35489     } CALL_CATCH_EXCEPTION(0);
35490   }
35491
35492   jresult = (int)result;
35493   return jresult;
35494 }
35495
35496
35497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35498   int jresult ;
35499   int result;
35500
35501   {
35502     try {
35503       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35504     } CALL_CATCH_EXCEPTION(0);
35505   }
35506
35507   jresult = (int)result;
35508   return jresult;
35509 }
35510
35511
35512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35513   int jresult ;
35514   int result;
35515
35516   {
35517     try {
35518       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35519     } CALL_CATCH_EXCEPTION(0);
35520   }
35521
35522   jresult = (int)result;
35523   return jresult;
35524 }
35525
35526
35527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35528   int jresult ;
35529   int result;
35530
35531   {
35532     try {
35533       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35534     } CALL_CATCH_EXCEPTION(0);
35535   }
35536
35537   jresult = (int)result;
35538   return jresult;
35539 }
35540
35541
35542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35543   int jresult ;
35544   int result;
35545
35546   {
35547     try {
35548       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35549     } CALL_CATCH_EXCEPTION(0);
35550   }
35551
35552   jresult = (int)result;
35553   return jresult;
35554 }
35555
35556
35557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35558   int jresult ;
35559   int result;
35560
35561   {
35562     try {
35563       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35564     } CALL_CATCH_EXCEPTION(0);
35565   }
35566
35567   jresult = (int)result;
35568   return jresult;
35569 }
35570
35571
35572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35573   int jresult ;
35574   int result;
35575
35576   {
35577     try {
35578       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35579     } CALL_CATCH_EXCEPTION(0);
35580   }
35581
35582   jresult = (int)result;
35583   return jresult;
35584 }
35585
35586
35587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35588   int jresult ;
35589   int result;
35590
35591   {
35592     try {
35593       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35594     } CALL_CATCH_EXCEPTION(0);
35595   }
35596
35597   jresult = (int)result;
35598   return jresult;
35599 }
35600
35601
35602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35603   int jresult ;
35604   int result;
35605
35606   {
35607     try {
35608       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35609     } CALL_CATCH_EXCEPTION(0);
35610   }
35611
35612   jresult = (int)result;
35613   return jresult;
35614 }
35615
35616
35617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35618   void * jresult ;
35619   Dali::Toolkit::Control result;
35620
35621   {
35622     try {
35623       result = Dali::Toolkit::Internal::Control::New();
35624     } CALL_CATCH_EXCEPTION(0);
35625   }
35626
35627   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35628   return jresult;
35629 }
35630
35631
35632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35634   std::string *arg2 = 0 ;
35635
35636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35637   if (!jarg2) {
35638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35639     return ;
35640   }
35641   std::string arg2_str(jarg2);
35642   arg2 = &arg2_str;
35643   {
35644     try {
35645       (arg1)->SetStyleName((std::string const &)*arg2);
35646     } CALL_CATCH_EXCEPTION();
35647   }
35648
35649
35650   //argout typemap for const std::string&
35651
35652 }
35653
35654
35655 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35656   char * jresult ;
35657   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35658   std::string *result = 0 ;
35659
35660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35661   {
35662     try {
35663       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35664     } CALL_CATCH_EXCEPTION(0);
35665   }
35666
35667   jresult = SWIG_csharp_string_callback(result->c_str());
35668   return jresult;
35669 }
35670
35671
35672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35674   Dali::Vector4 *arg2 = 0 ;
35675
35676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35677   arg2 = (Dali::Vector4 *)jarg2;
35678   if (!arg2) {
35679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35680     return ;
35681   }
35682   {
35683     try {
35684       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35685     } CALL_CATCH_EXCEPTION();
35686   }
35687
35688 }
35689
35690
35691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35692   void * jresult ;
35693   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35694   Dali::Vector4 result;
35695
35696   arg1 = (Dali::Handle *)jarg1;
35697   {
35698     try {
35699       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35700       if (resultMap)
35701       {
35702         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35703         if(type && type->Get<int>() == Visual::COLOR )
35704         {
35705           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35706           if (value)
35707           {
35708             result = value->Get<Vector4>();
35709           }
35710         }
35711       }
35712     } CALL_CATCH_EXCEPTION(0);
35713   }
35714
35715   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35716   return jresult;
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35722   Dali::Property::Map *arg2 = 0 ;
35723
35724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35725   arg2 = (Dali::Property::Map *)jarg2;
35726   if (!arg2) {
35727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35728     return ;
35729   }
35730   {
35731     try {
35732       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35733     } CALL_CATCH_EXCEPTION();
35734   }
35735
35736 }
35737
35738
35739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35741
35742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35743   {
35744     try {
35745       (arg1)->ClearBackground();
35746     } CALL_CATCH_EXCEPTION();
35747   }
35748
35749 }
35750
35751
35752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35754   Dali::GestureType::Value arg2 ;
35755
35756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35757   arg2 = (Dali::GestureType::Value)jarg2;
35758   {
35759     try {
35760       (arg1)->EnableGestureDetection(arg2);
35761     } CALL_CATCH_EXCEPTION();
35762   }
35763
35764 }
35765
35766
35767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35769   Dali::GestureType::Value arg2 ;
35770
35771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35772   arg2 = (Dali::GestureType::Value)jarg2;
35773   {
35774     try {
35775       (arg1)->DisableGestureDetection(arg2);
35776     } CALL_CATCH_EXCEPTION();
35777   }
35778
35779 }
35780
35781
35782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35783   void * jresult ;
35784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35785   Dali::PinchGestureDetector result;
35786
35787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35788   {
35789     try {
35790       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35791     } CALL_CATCH_EXCEPTION(0);
35792   }
35793
35794   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35795   return jresult;
35796 }
35797
35798
35799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35800   void * jresult ;
35801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35802   Dali::PanGestureDetector result;
35803
35804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35805   {
35806     try {
35807       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35808     } CALL_CATCH_EXCEPTION(0);
35809   }
35810
35811   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35812   return jresult;
35813 }
35814
35815
35816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35817   void * jresult ;
35818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35819   Dali::TapGestureDetector result;
35820
35821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35822   {
35823     try {
35824       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35825     } CALL_CATCH_EXCEPTION(0);
35826   }
35827
35828   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35829   return jresult;
35830 }
35831
35832
35833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35834   void * jresult ;
35835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35836   Dali::LongPressGestureDetector result;
35837
35838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35839   {
35840     try {
35841       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35842     } CALL_CATCH_EXCEPTION(0);
35843   }
35844
35845   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35846   return jresult;
35847 }
35848
35849
35850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
35851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35852   bool arg2 ;
35853
35854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35855   arg2 = jarg2 ? true : false;
35856   {
35857     try {
35858       (arg1)->SetKeyboardNavigationSupport(arg2);
35859     } CALL_CATCH_EXCEPTION();
35860   }
35861
35862 }
35863
35864
35865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
35866   unsigned int jresult ;
35867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35868   bool result;
35869
35870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35871   {
35872     try {
35873       result = (bool)(arg1)->IsKeyboardNavigationSupported();
35874     } CALL_CATCH_EXCEPTION(0);
35875   }
35876
35877   jresult = result;
35878   return jresult;
35879 }
35880
35881
35882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
35883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35884
35885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35886   {
35887     try {
35888       (arg1)->SetKeyInputFocus();
35889     } CALL_CATCH_EXCEPTION();
35890   }
35891
35892 }
35893
35894
35895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
35896   unsigned int jresult ;
35897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35898   bool result;
35899
35900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35901   {
35902     try {
35903       result = (bool)(arg1)->HasKeyInputFocus();
35904     } CALL_CATCH_EXCEPTION(0);
35905   }
35906
35907   jresult = result;
35908   return jresult;
35909 }
35910
35911
35912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
35913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35914
35915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35916   {
35917     try {
35918       (arg1)->ClearKeyInputFocus();
35919     } CALL_CATCH_EXCEPTION();
35920   }
35921
35922 }
35923
35924
35925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
35926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35927   bool arg2 ;
35928
35929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35930   arg2 = jarg2 ? true : false;
35931   {
35932     try {
35933       (arg1)->SetAsKeyboardFocusGroup(arg2);
35934     } CALL_CATCH_EXCEPTION();
35935   }
35936
35937 }
35938
35939
35940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
35941   unsigned int jresult ;
35942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35943   bool result;
35944
35945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35946   {
35947     try {
35948       result = (bool)(arg1)->IsKeyboardFocusGroup();
35949     } CALL_CATCH_EXCEPTION(0);
35950   }
35951
35952   jresult = result;
35953   return jresult;
35954 }
35955
35956
35957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
35958   void * jresult ;
35959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35960   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
35961
35962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35963   {
35964     try {
35965       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
35966     } CALL_CATCH_EXCEPTION(0);
35967   }
35968
35969   jresult = (void *)result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
35975   void * jresult ;
35976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35977   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
35978
35979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35980   {
35981     try {
35982       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
35983     } CALL_CATCH_EXCEPTION(0);
35984   }
35985
35986   jresult = (void *)result;
35987   return jresult;
35988 }
35989
35990
35991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
35992   void * jresult ;
35993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35994   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
35995
35996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35997   {
35998     try {
35999       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36000     } CALL_CATCH_EXCEPTION(0);
36001   }
36002
36003   jresult = (void *)result;
36004   return jresult;
36005 }
36006
36007
36008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36010   int arg2 ;
36011   SwigDirector_ViewImpl *darg = 0;
36012
36013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36014   arg2 = (int)jarg2;
36015   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36016   if(!darg) {
36017     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36018     return;
36019   }
36020   {
36021     try {
36022       if(darg) {
36023         (darg)->OnSceneConnection(arg2);
36024       }
36025     } CALL_CATCH_EXCEPTION();
36026   }
36027
36028 }
36029
36030
36031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36033   int arg2 ;
36034   SwigDirector_ViewImpl *darg = 0;
36035
36036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36037   arg2 = (int)jarg2;
36038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36039   if(!darg) {
36040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36041     return;
36042   }
36043   {
36044     try {
36045       if(darg) {
36046         (darg)->OnSceneConnectionSwigPublic(arg2);
36047       }
36048     } CALL_CATCH_EXCEPTION();
36049   }
36050
36051 }
36052
36053
36054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36056   SwigDirector_ViewImpl *darg = 0;
36057
36058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36059   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36060   if(!darg) {
36061     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36062     return;
36063   }
36064   {
36065     try {
36066       if(darg) {
36067         (darg)->OnSceneDisconnection();
36068       }
36069     } CALL_CATCH_EXCEPTION();
36070   }
36071
36072 }
36073
36074
36075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36077   SwigDirector_ViewImpl *darg = 0;
36078
36079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36080   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36081   if(!darg) {
36082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36083     return;
36084   }
36085   {
36086     try {
36087       if(darg) {
36088         (darg)->OnSceneDisconnectionSwigPublic();
36089       }
36090     } CALL_CATCH_EXCEPTION();
36091   }
36092
36093 }
36094
36095
36096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
36097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36098   Dali::Actor *arg2 = 0 ;
36099   SwigDirector_ViewImpl *darg = 0;
36100
36101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36102   arg2 = (Dali::Actor *)jarg2;
36103   if (!arg2) {
36104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36105     return ;
36106   }
36107   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36108   if(!darg) {
36109     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36110     return;
36111   }
36112   {
36113     try {
36114       if(darg) {
36115         (darg)->OnChildAdd(*arg2);
36116       }
36117     } CALL_CATCH_EXCEPTION();
36118   }
36119
36120 }
36121
36122
36123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36125   Dali::Actor *arg2 = 0 ;
36126   SwigDirector_ViewImpl *darg = 0;
36127
36128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36129   arg2 = (Dali::Actor *)jarg2;
36130   if (!arg2) {
36131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36132     return ;
36133   }
36134   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36135   if(!darg) {
36136     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36137     return;
36138   }
36139   {
36140     try {
36141       if(darg) {
36142           (darg)->OnChildAddSwigPublic(*arg2);
36143       }
36144     } CALL_CATCH_EXCEPTION();
36145   }
36146
36147 }
36148
36149
36150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36152   Dali::Actor *arg2 = 0 ;
36153   SwigDirector_ViewImpl *darg = 0;
36154
36155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36156   arg2 = (Dali::Actor *)jarg2;
36157   if (!arg2) {
36158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36159     return ;
36160   }
36161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36162   if(!darg) {
36163     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36164     return;
36165   }
36166   {
36167     try {
36168       if(darg) {
36169         (darg)->OnChildRemove(*arg2);
36170       }
36171     } CALL_CATCH_EXCEPTION();
36172   }
36173
36174 }
36175
36176
36177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36179   Dali::Actor *arg2 = 0 ;
36180   SwigDirector_ViewImpl *darg = 0;
36181
36182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36183   arg2 = (Dali::Actor *)jarg2;
36184   if (!arg2) {
36185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36186     return ;
36187   }
36188   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36189   if(!darg) {
36190     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36191     return;
36192   }
36193   {
36194     try {
36195       if(darg) {
36196         (darg)->OnChildRemoveSwigPublic(*arg2);
36197       }
36198     } CALL_CATCH_EXCEPTION();
36199   }
36200
36201 }
36202
36203
36204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36206   Dali::Property::Index arg2 ;
36207   Dali::Property::Value arg3 ;
36208   Dali::Property::Value *argp3 ;
36209   SwigDirector_ViewImpl *darg = 0;
36210
36211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36212   arg2 = (Dali::Property::Index)jarg2;
36213   argp3 = (Dali::Property::Value *)jarg3;
36214   if (!argp3) {
36215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36216     return ;
36217   }
36218   arg3 = *argp3;
36219   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36220   if (!darg) {
36221     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36222     return;
36223   }
36224   {
36225     try {
36226       (darg)->OnPropertySet(arg2,arg3);
36227     } CALL_CATCH_EXCEPTION();
36228   }
36229
36230 }
36231
36232
36233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36235   Dali::Vector3 *arg2 = 0 ;
36236   SwigDirector_ViewImpl *darg = 0;
36237
36238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36239   arg2 = (Dali::Vector3 *)jarg2;
36240   if (!arg2) {
36241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36242     return ;
36243   }
36244   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36245   if (!darg) {
36246     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36247     return;
36248   }
36249   {
36250     try {
36251       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36252     } CALL_CATCH_EXCEPTION();
36253   }
36254
36255 }
36256
36257
36258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36260   Dali::Vector3 *arg2 = 0 ;
36261   SwigDirector_ViewImpl *darg = 0;
36262
36263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36264   arg2 = (Dali::Vector3 *)jarg2;
36265   if (!arg2) {
36266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36267     return ;
36268   }
36269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36270   if (!darg) {
36271     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36272     return;
36273   }
36274   {
36275     try {
36276       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36277     } CALL_CATCH_EXCEPTION();
36278   }
36279
36280 }
36281
36282
36283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36285   Dali::Animation *arg2 = 0 ;
36286   Dali::Vector3 *arg3 = 0 ;
36287   SwigDirector_ViewImpl *darg = 0;
36288
36289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36290   arg2 = (Dali::Animation *)jarg2;
36291   if (!arg2) {
36292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36293     return ;
36294   }
36295   arg3 = (Dali::Vector3 *)jarg3;
36296   if (!arg3) {
36297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36298     return ;
36299   }
36300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36301   if (!darg) {
36302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36303     return;
36304   }
36305   {
36306     try {
36307       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36308     } CALL_CATCH_EXCEPTION();
36309   }
36310
36311 }
36312
36313
36314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36316   Dali::Animation *arg2 = 0 ;
36317   Dali::Vector3 *arg3 = 0 ;
36318   SwigDirector_ViewImpl *darg = 0;
36319
36320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36321   arg2 = (Dali::Animation *)jarg2;
36322   if (!arg2) {
36323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36324     return ;
36325   }
36326   arg3 = (Dali::Vector3 *)jarg3;
36327   if (!arg3) {
36328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36329     return ;
36330   }
36331   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36332   if (!darg) {
36333     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36334     return;
36335   }
36336   {
36337     try {
36338       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36339     } CALL_CATCH_EXCEPTION();
36340   }
36341 }
36342
36343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36344   unsigned int jresult ;
36345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36346   Dali::KeyEvent *arg2 = 0 ;
36347   SwigDirector_ViewImpl *darg = 0;
36348   bool result;
36349
36350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36351   arg2 = (Dali::KeyEvent *)jarg2;
36352   if (!arg2) {
36353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36354     return 0;
36355   }
36356   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36357   if (!darg) {
36358     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36359     return 0;
36360   }
36361   {
36362     try {
36363       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36364     } CALL_CATCH_EXCEPTION(0);
36365   }
36366
36367   jresult = result;
36368   return jresult;
36369 }
36370
36371
36372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36373   unsigned int jresult ;
36374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36375   Dali::KeyEvent *arg2 = 0 ;
36376   SwigDirector_ViewImpl *darg = 0;
36377   bool result;
36378
36379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36380   arg2 = (Dali::KeyEvent *)jarg2;
36381   if (!arg2) {
36382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36383     return 0;
36384   }
36385   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36386   if (!darg) {
36387     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36388     return 0;
36389   }
36390   {
36391     try {
36392       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36393     } CALL_CATCH_EXCEPTION(0);
36394   }
36395
36396   jresult = result;
36397   return jresult;
36398 }
36399
36400
36401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36403   Dali::Vector2 *arg2 = 0 ;
36404   Dali::RelayoutContainer *arg3 = 0 ;
36405   SwigDirector_ViewImpl *darg = 0;
36406
36407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36408   arg2 = (Dali::Vector2 *)jarg2;
36409   if (!arg2) {
36410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36411     return ;
36412   }
36413   arg3 = (Dali::RelayoutContainer *)jarg3;
36414   if (!arg3) {
36415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36416     return ;
36417   }
36418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36419   if (!darg) {
36420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36421     return;
36422   }
36423   {
36424     try {
36425       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36426     } CALL_CATCH_EXCEPTION();
36427   }
36428
36429 }
36430
36431
36432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36434   Dali::Vector2 *arg2 = 0 ;
36435   Dali::RelayoutContainer *arg3 = 0 ;
36436   SwigDirector_ViewImpl *darg = 0;
36437
36438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36439   arg2 = (Dali::Vector2 *)jarg2;
36440   if (!arg2) {
36441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36442     return ;
36443   }
36444   arg3 = (Dali::RelayoutContainer *)jarg3;
36445   if (!arg3) {
36446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36447     return ;
36448   }
36449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36450   if (!darg) {
36451     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36452     return;
36453   }
36454   {
36455     try {
36456       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36457     } CALL_CATCH_EXCEPTION();
36458   }
36459
36460 }
36461
36462
36463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36465   Dali::ResizePolicy::Type arg2 ;
36466   Dali::Dimension::Type arg3 ;
36467   SwigDirector_ViewImpl *darg = 0;
36468
36469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36470   arg2 = (Dali::ResizePolicy::Type)jarg2;
36471   arg3 = (Dali::Dimension::Type)jarg3;
36472   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36473   if (!darg) {
36474     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36475     return;
36476   }
36477   {
36478     try {
36479       (darg)->OnSetResizePolicy(arg2,arg3);
36480     } CALL_CATCH_EXCEPTION();
36481   }
36482
36483 }
36484
36485
36486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36488   Dali::ResizePolicy::Type arg2 ;
36489   Dali::Dimension::Type arg3 ;
36490   SwigDirector_ViewImpl *darg = 0;
36491
36492   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36493   arg2 = (Dali::ResizePolicy::Type)jarg2;
36494   arg3 = (Dali::Dimension::Type)jarg3;
36495   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36496   if (!darg) {
36497     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36498     return;
36499   }
36500   {
36501     try {
36502       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36503     } CALL_CATCH_EXCEPTION();
36504   }
36505
36506 }
36507
36508
36509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36510   void * jresult ;
36511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36512   SwigDirector_ViewImpl *darg = 0;
36513   Dali::Vector3 result;
36514
36515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36517   if (!darg) {
36518     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36519     return 0;
36520   }
36521   {
36522     try {
36523       result = (darg)->GetNaturalSize();
36524     } CALL_CATCH_EXCEPTION(0);
36525   }
36526
36527   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36528   return jresult;
36529 }
36530
36531
36532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36533   void * jresult ;
36534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36535   SwigDirector_ViewImpl *darg = 0;
36536   Dali::Vector3 result;
36537
36538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36539   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36540   if (!darg) {
36541     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36542     return 0;
36543   }
36544   {
36545     try {
36546       result = (darg)->GetNaturalSizeSwigPublic();
36547     } CALL_CATCH_EXCEPTION(0);
36548   }
36549
36550   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36551   return jresult;
36552 }
36553
36554
36555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36556   float jresult ;
36557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36558   Dali::Actor *arg2 = 0 ;
36559   Dali::Dimension::Type arg3 ;
36560   SwigDirector_ViewImpl *darg = 0;
36561   float result;
36562
36563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36564   arg2 = (Dali::Actor *)jarg2;
36565   if (!arg2) {
36566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36567     return 0;
36568   }
36569   arg3 = (Dali::Dimension::Type)jarg3;
36570   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36571   if (!darg) {
36572     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36573     return 0;
36574   }
36575   {
36576     try {
36577       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36578     } CALL_CATCH_EXCEPTION(0);
36579   }
36580
36581   jresult = result;
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36587   float jresult ;
36588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36589   Dali::Actor *arg2 = 0 ;
36590   Dali::Dimension::Type arg3 ;
36591   SwigDirector_ViewImpl *darg = 0;
36592   float result;
36593
36594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36595   arg2 = (Dali::Actor *)jarg2;
36596   if (!arg2) {
36597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36598     return 0;
36599   }
36600   arg3 = (Dali::Dimension::Type)jarg3;
36601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36602   if (!darg) {
36603     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36604     return 0;
36605   }
36606   {
36607     try {
36608       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36609     } CALL_CATCH_EXCEPTION(0);
36610   }
36611
36612   jresult = result;
36613   return jresult;
36614 }
36615
36616
36617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36618   float jresult ;
36619   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36620   float arg2 ;
36621   SwigDirector_ViewImpl *darg = 0;
36622   float result;
36623
36624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36625   arg2 = (float)jarg2;
36626   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36627   if (!darg) {
36628     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36629     return 0;
36630   }
36631   {
36632     try {
36633       result = (float)(darg)->GetHeightForWidth(arg2);
36634     } CALL_CATCH_EXCEPTION(0);
36635   }
36636
36637   jresult = result;
36638   return jresult;
36639 }
36640
36641
36642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36643   float jresult ;
36644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36645   float arg2 ;
36646   SwigDirector_ViewImpl *darg = 0;
36647   float result;
36648
36649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36650   arg2 = (float)jarg2;
36651   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36652   if (!darg) {
36653     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36654     return 0;
36655   }
36656   {
36657     try {
36658       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36659     } CALL_CATCH_EXCEPTION(0);
36660   }
36661
36662   jresult = result;
36663   return jresult;
36664 }
36665
36666
36667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36668   float jresult ;
36669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36670   float arg2 ;
36671   SwigDirector_ViewImpl *darg = 0;
36672   float result;
36673
36674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36675   arg2 = (float)jarg2;
36676   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36677   if (!darg) {
36678     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36679     return 0;
36680   }
36681   {
36682     try {
36683       result = (float)(darg)->GetWidthForHeight(arg2);
36684     } CALL_CATCH_EXCEPTION(0);
36685   }
36686
36687   jresult = result;
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36693   float jresult ;
36694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36695   float arg2 ;
36696   SwigDirector_ViewImpl *darg = 0;
36697   float result;
36698
36699   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36700   arg2 = (float)jarg2;
36701   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36702   if (!darg) {
36703     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36704     return 0;
36705   }
36706   {
36707     try {
36708       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36709     } CALL_CATCH_EXCEPTION(0);
36710   }
36711
36712   jresult = result;
36713   return jresult;
36714 }
36715
36716
36717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36718   unsigned int jresult ;
36719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36720   Dali::Dimension::Type arg2 ;
36721   SwigDirector_ViewImpl *darg = 0;
36722   bool result;
36723
36724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36725   arg2 = (Dali::Dimension::Type)jarg2;
36726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36727   if (!darg) {
36728     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36729     return 0;
36730   }
36731   {
36732     try {
36733       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
36734     } CALL_CATCH_EXCEPTION(0);
36735   }
36736
36737   jresult = result;
36738   return jresult;
36739 }
36740
36741
36742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
36743   unsigned int jresult ;
36744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36745   Dali::Dimension::Type arg2 ;
36746   SwigDirector_ViewImpl *darg = 0;
36747   bool result;
36748
36749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36750   arg2 = (Dali::Dimension::Type)jarg2;
36751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36752   if (!darg) {
36753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36754     return 0;
36755   }
36756   {
36757     try {
36758       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
36759     } CALL_CATCH_EXCEPTION(0);
36760   }
36761
36762   jresult = result;
36763   return jresult;
36764 }
36765
36766
36767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
36768   unsigned int jresult ;
36769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36770   SwigDirector_ViewImpl *darg = 0;
36771   bool result;
36772
36773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36775   if (!darg) {
36776     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36777     return 0;
36778   }
36779   {
36780     try {
36781       result = (bool)(darg)->RelayoutDependentOnChildren();
36782     } CALL_CATCH_EXCEPTION(0);
36783   }
36784
36785   jresult = result;
36786   return jresult;
36787 }
36788
36789
36790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
36791   unsigned int jresult ;
36792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36793   SwigDirector_ViewImpl *darg = 0;
36794   bool result;
36795
36796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36797   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36798   if (!darg) {
36799     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36800     return 0;
36801   }
36802   {
36803     try {
36804       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
36805     } CALL_CATCH_EXCEPTION(0);
36806   }
36807
36808   jresult = result;
36809   return jresult;
36810 }
36811
36812
36813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
36814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36815   Dali::Dimension::Type arg2 ;
36816   SwigDirector_ViewImpl *darg = 0;
36817
36818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36819   arg2 = (Dali::Dimension::Type)jarg2;
36820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36821   if (!darg) {
36822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36823     return;
36824   }
36825   {
36826     try {
36827       (darg)->OnCalculateRelayoutSize(arg2);
36828     } CALL_CATCH_EXCEPTION();
36829   }
36830
36831 }
36832
36833
36834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
36835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36836   Dali::Dimension::Type arg2 ;
36837   SwigDirector_ViewImpl *darg = 0;
36838
36839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36840   arg2 = (Dali::Dimension::Type)jarg2;
36841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36842   if (!darg) {
36843     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36844     return;
36845   }
36846   {
36847     try {
36848       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
36849     } CALL_CATCH_EXCEPTION();
36850   }
36851
36852 }
36853
36854
36855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
36856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36857   float arg2 ;
36858   Dali::Dimension::Type arg3 ;
36859   SwigDirector_ViewImpl *darg = 0;
36860
36861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36862   arg2 = (float)jarg2;
36863   arg3 = (Dali::Dimension::Type)jarg3;
36864   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36865   if (!darg) {
36866     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36867     return;
36868   }
36869   {
36870     try {
36871       (darg)->OnLayoutNegotiated(arg2,arg3);
36872     } CALL_CATCH_EXCEPTION();
36873   }
36874
36875 }
36876
36877
36878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
36879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36880   float arg2 ;
36881   Dali::Dimension::Type arg3 ;
36882   SwigDirector_ViewImpl *darg = 0;
36883
36884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36885   arg2 = (float)jarg2;
36886   arg3 = (Dali::Dimension::Type)jarg3;
36887   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36888   if (!darg) {
36889     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36890     return;
36891   }
36892   {
36893     try {
36894       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
36895     } CALL_CATCH_EXCEPTION();
36896   }
36897
36898 }
36899
36900
36901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
36902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36903
36904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36905   {
36906     try {
36907       (arg1)->OnInitialize();
36908     } CALL_CATCH_EXCEPTION();
36909   }
36910
36911 }
36912
36913
36914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
36915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36916
36917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36918   {
36919     try {
36920       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
36921     } CALL_CATCH_EXCEPTION();
36922   }
36923
36924 }
36925
36926
36927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
36928   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36929   Dali::Toolkit::StyleManager arg2 ;
36930   Dali::StyleChange::Type arg3 ;
36931   Dali::Toolkit::StyleManager *argp2 ;
36932
36933   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36934   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
36935   if (!argp2) {
36936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
36937     return ;
36938   }
36939   arg2 = *argp2;
36940   arg3 = (Dali::StyleChange::Type)jarg3;
36941   {
36942     try {
36943       (arg1)->OnStyleChange(arg2,arg3);
36944     } CALL_CATCH_EXCEPTION();
36945   }
36946
36947 }
36948
36949
36950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36952   Dali::Toolkit::StyleManager arg2 ;
36953   Dali::StyleChange::Type arg3 ;
36954   Dali::Toolkit::StyleManager *argp2 ;
36955
36956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36957   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
36958   if (!argp2) {
36959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
36960     return ;
36961   }
36962   arg2 = *argp2;
36963   arg3 = (Dali::StyleChange::Type)jarg3;
36964   {
36965     try {
36966       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
36967     } CALL_CATCH_EXCEPTION();
36968   }
36969
36970 }
36971
36972
36973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
36974   unsigned int jresult ;
36975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36976   bool result;
36977
36978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36979   {
36980     try {
36981       result = (bool)(arg1)->OnAccessibilityActivated();
36982     } CALL_CATCH_EXCEPTION(0);
36983   }
36984
36985   jresult = result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
36991   unsigned int jresult ;
36992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36993   bool result;
36994
36995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36996   {
36997     try {
36998       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
36999     } CALL_CATCH_EXCEPTION(0);
37000   }
37001
37002   jresult = result;
37003   return jresult;
37004 }
37005
37006
37007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37008   unsigned int jresult ;
37009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37010   Dali::PanGesture arg2 ;
37011   Dali::PanGesture *argp2 ;
37012   bool result;
37013
37014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37015   argp2 = (Dali::PanGesture *)jarg2;
37016   if (!argp2) {
37017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37018     return 0;
37019   }
37020   arg2 = *argp2;
37021   {
37022     try {
37023       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37024     } CALL_CATCH_EXCEPTION(0);
37025   }
37026
37027   jresult = result;
37028   return jresult;
37029 }
37030
37031
37032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37033   unsigned int jresult ;
37034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37035   Dali::PanGesture arg2 ;
37036   Dali::PanGesture *argp2 ;
37037   bool result;
37038
37039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37040   argp2 = (Dali::PanGesture *)jarg2;
37041   if (!argp2) {
37042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37043     return 0;
37044   }
37045   arg2 = *argp2;
37046   {
37047     try {
37048       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37049     } CALL_CATCH_EXCEPTION(0);
37050   }
37051
37052   jresult = result;
37053   return jresult;
37054 }
37055
37056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37057   unsigned int jresult ;
37058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37059   bool arg2 ;
37060   bool result;
37061
37062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37063   arg2 = jarg2 ? true : false;
37064   {
37065     try {
37066       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37067     } CALL_CATCH_EXCEPTION(0);
37068   }
37069
37070   jresult = result;
37071   return jresult;
37072 }
37073
37074
37075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37076   unsigned int jresult ;
37077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37078   bool arg2 ;
37079   bool result;
37080
37081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37082   arg2 = jarg2 ? true : false;
37083   {
37084     try {
37085       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37086     } CALL_CATCH_EXCEPTION(0);
37087   }
37088
37089   jresult = result;
37090   return jresult;
37091 }
37092
37093
37094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37095   unsigned int jresult ;
37096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37097   bool result;
37098
37099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37100   {
37101     try {
37102       result = (bool)(arg1)->OnAccessibilityZoom();
37103     } CALL_CATCH_EXCEPTION(0);
37104   }
37105
37106   jresult = result;
37107   return jresult;
37108 }
37109
37110
37111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
37112   unsigned int jresult ;
37113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37114   bool result;
37115
37116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37117   {
37118     try {
37119       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37120     } CALL_CATCH_EXCEPTION(0);
37121   }
37122
37123   jresult = result;
37124   return jresult;
37125 }
37126
37127
37128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37130
37131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37132   {
37133     try {
37134       (arg1)->OnKeyInputFocusGained();
37135     } CALL_CATCH_EXCEPTION();
37136   }
37137
37138 }
37139
37140
37141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37143
37144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37145   {
37146     try {
37147       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37148     } CALL_CATCH_EXCEPTION();
37149   }
37150
37151 }
37152
37153
37154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37156
37157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37158   {
37159     try {
37160       (arg1)->OnKeyInputFocusLost();
37161     } CALL_CATCH_EXCEPTION();
37162   }
37163
37164 }
37165
37166
37167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37169
37170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37171   {
37172     try {
37173       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37174     } CALL_CATCH_EXCEPTION();
37175   }
37176
37177 }
37178
37179
37180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37181   void * jresult ;
37182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37183   Dali::Actor arg2 ;
37184   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37185   bool arg4 ;
37186   Dali::Actor *argp2 ;
37187   Dali::Actor result;
37188
37189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37190   argp2 = (Dali::Actor *)jarg2;
37191   if (!argp2) {
37192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37193     return 0;
37194   }
37195   arg2 = *argp2;
37196   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37197   arg4 = jarg4 ? true : false;
37198   {
37199     try {
37200       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37201     } CALL_CATCH_EXCEPTION(0);
37202   }
37203
37204   jresult = new Dali::Actor((const Dali::Actor &)result);
37205   return jresult;
37206 }
37207
37208
37209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37210   void * jresult ;
37211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37212   Dali::Actor arg2 ;
37213   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37214   bool arg4 ;
37215   Dali::Actor *argp2 ;
37216   Dali::Actor result;
37217
37218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37219   argp2 = (Dali::Actor *)jarg2;
37220   if (!argp2) {
37221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37222     return 0;
37223   }
37224   arg2 = *argp2;
37225   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37226   arg4 = jarg4 ? true : false;
37227   {
37228     try {
37229       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37230     } CALL_CATCH_EXCEPTION(0);
37231   }
37232
37233   jresult = new Dali::Actor((const Dali::Actor &)result);
37234   return jresult;
37235 }
37236
37237
37238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37240   Dali::Actor arg2 ;
37241   Dali::Actor *argp2 ;
37242
37243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37244   argp2 = (Dali::Actor *)jarg2;
37245   if (!argp2) {
37246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37247     return ;
37248   }
37249   arg2 = *argp2;
37250   {
37251     try {
37252       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37253     } CALL_CATCH_EXCEPTION();
37254   }
37255
37256 }
37257
37258
37259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37261   Dali::Actor arg2 ;
37262   Dali::Actor *argp2 ;
37263
37264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37265   argp2 = (Dali::Actor *)jarg2;
37266   if (!argp2) {
37267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37268     return ;
37269   }
37270   arg2 = *argp2;
37271   {
37272     try {
37273       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37274     } CALL_CATCH_EXCEPTION();
37275   }
37276
37277 }
37278
37279
37280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37281   unsigned int jresult ;
37282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37283   bool result;
37284
37285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37286   {
37287     try {
37288       result = (bool)(arg1)->OnKeyboardEnter();
37289     } CALL_CATCH_EXCEPTION(0);
37290   }
37291
37292   jresult = result;
37293   return jresult;
37294 }
37295
37296
37297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
37298   unsigned int jresult ;
37299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37300   bool result;
37301
37302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37303   {
37304     try {
37305       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37306     } CALL_CATCH_EXCEPTION(0);
37307   }
37308
37309   jresult = result;
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37316   Dali::PinchGesture *arg2 = 0 ;
37317
37318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37319   arg2 = (Dali::PinchGesture *)jarg2;
37320   if (!arg2) {
37321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37322     return ;
37323   }
37324   {
37325     try {
37326       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37327     } CALL_CATCH_EXCEPTION();
37328   }
37329
37330 }
37331
37332
37333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37335   Dali::PinchGesture *arg2 = 0 ;
37336
37337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37338   arg2 = (Dali::PinchGesture *)jarg2;
37339   if (!arg2) {
37340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37341     return ;
37342   }
37343   {
37344     try {
37345       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37346     } CALL_CATCH_EXCEPTION();
37347   }
37348
37349 }
37350
37351
37352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37353   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37354   Dali::PanGesture *arg2 = 0 ;
37355
37356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37357   arg2 = (Dali::PanGesture *)jarg2;
37358   if (!arg2) {
37359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37360     return ;
37361   }
37362   {
37363     try {
37364       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37365     } CALL_CATCH_EXCEPTION();
37366   }
37367
37368 }
37369
37370
37371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37373   Dali::PanGesture *arg2 = 0 ;
37374
37375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37376   arg2 = (Dali::PanGesture *)jarg2;
37377   if (!arg2) {
37378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37379     return ;
37380   }
37381   {
37382     try {
37383       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37384     } CALL_CATCH_EXCEPTION();
37385   }
37386
37387 }
37388
37389
37390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37391   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37392   Dali::TapGesture *arg2 = 0 ;
37393
37394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37395   arg2 = (Dali::TapGesture *)jarg2;
37396   if (!arg2) {
37397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37398     return ;
37399   }
37400   {
37401     try {
37402       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37403     } CALL_CATCH_EXCEPTION();
37404   }
37405
37406 }
37407
37408
37409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37411   Dali::TapGesture *arg2 = 0 ;
37412
37413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37414   arg2 = (Dali::TapGesture *)jarg2;
37415   if (!arg2) {
37416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37417     return ;
37418   }
37419   {
37420     try {
37421       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37422     } CALL_CATCH_EXCEPTION();
37423   }
37424
37425 }
37426
37427
37428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37430   Dali::LongPressGesture *arg2 = 0 ;
37431
37432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37433   arg2 = (Dali::LongPressGesture *)jarg2;
37434   if (!arg2) {
37435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37436     return ;
37437   }
37438   {
37439     try {
37440       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37441     } CALL_CATCH_EXCEPTION();
37442   }
37443
37444 }
37445
37446
37447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37449   Dali::LongPressGesture *arg2 = 0 ;
37450
37451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37452   arg2 = (Dali::LongPressGesture *)jarg2;
37453   if (!arg2) {
37454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37455     return ;
37456   }
37457   {
37458     try {
37459       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37460     } CALL_CATCH_EXCEPTION();
37461   }
37462
37463 }
37464
37465
37466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37468   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37469   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37470
37471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37472   arg2 = (Dali::SlotObserver *)jarg2;
37473   arg3 = (Dali::CallbackBase *)jarg3;
37474   {
37475     try {
37476       (arg1)->SignalConnected(arg2,arg3);
37477     } CALL_CATCH_EXCEPTION();
37478   }
37479
37480 }
37481
37482
37483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37485   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37486   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37487
37488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37489   arg2 = (Dali::SlotObserver *)jarg2;
37490   arg3 = (Dali::CallbackBase *)jarg3;
37491   {
37492     try {
37493       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37494     } CALL_CATCH_EXCEPTION();
37495   }
37496
37497 }
37498
37499
37500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
37501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37502   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37503   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37504
37505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37506   arg2 = (Dali::SlotObserver *)jarg2;
37507   arg3 = (Dali::CallbackBase *)jarg3;
37508   {
37509     try {
37510       (arg1)->SignalDisconnected(arg2,arg3);
37511     } CALL_CATCH_EXCEPTION();
37512   }
37513
37514 }
37515
37516
37517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37519   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37520   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37521
37522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37523   arg2 = (Dali::SlotObserver *)jarg2;
37524   arg3 = (Dali::CallbackBase *)jarg3;
37525   {
37526     try {
37527       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37528     } CALL_CATCH_EXCEPTION();
37529   }
37530
37531 }
37532
37533 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) {
37534   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37535   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37536   if (director) {
37537     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);
37538   }
37539 }
37540
37541
37542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37543   void * jresult ;
37544   Dali::Toolkit::Control *arg1 = 0 ;
37545   Dali::Toolkit::Internal::Control *result = 0 ;
37546
37547   arg1 = (Dali::Toolkit::Control *)jarg1;
37548   if (!arg1) {
37549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37550     return 0;
37551   }
37552   {
37553     try {
37554       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37555     } CALL_CATCH_EXCEPTION(0);
37556   }
37557
37558   jresult = (void *)result;
37559   return jresult;
37560 }
37561
37562
37563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37564   int jresult ;
37565   int result;
37566
37567   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37568   jresult = (int)result;
37569   return jresult;
37570 }
37571
37572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37573   int jresult ;
37574   int result;
37575
37576   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37577   jresult = (int)result;
37578   return jresult;
37579 }
37580
37581
37582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37583   int jresult ;
37584   int result;
37585
37586   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37587   jresult = (int)result;
37588   return jresult;
37589 }
37590
37591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37592   int jresult ;
37593   int result;
37594
37595   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37596   jresult = (int)result;
37597   return jresult;
37598 }
37599
37600
37601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37602   int jresult ;
37603   int result;
37604
37605   result = (int)Dali::Toolkit::Control::Property::PADDING;
37606   jresult = (int)result;
37607   return jresult;
37608 }
37609
37610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37611   int jresult ;
37612   int result;
37613
37614   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37615   jresult = (int)result;
37616   return jresult;
37617 }
37618
37619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37620   void * jresult ;
37621   Dali::Toolkit::Control::Property *result = 0 ;
37622
37623   {
37624     try {
37625       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37626     } CALL_CATCH_EXCEPTION(0);
37627   }
37628
37629   jresult = (void *)result;
37630   return jresult;
37631 }
37632
37633
37634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37635   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37636
37637   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37638   {
37639     try {
37640       delete arg1;
37641     } CALL_CATCH_EXCEPTION();
37642   }
37643
37644 }
37645
37646
37647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37648   void * jresult ;
37649   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37650
37651   {
37652     try {
37653       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37654     } CALL_CATCH_EXCEPTION(0);
37655   }
37656
37657   jresult = (void *)result;
37658   return jresult;
37659 }
37660
37661
37662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37663   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37664
37665   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37666   {
37667     try {
37668       delete arg1;
37669     } CALL_CATCH_EXCEPTION();
37670   }
37671
37672 }
37673
37674
37675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37676   void * jresult ;
37677   Dali::Toolkit::Control result;
37678
37679   {
37680     try {
37681       result = Dali::Toolkit::Control::New();
37682     } CALL_CATCH_EXCEPTION(0);
37683   }
37684
37685   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37686   return jresult;
37687 }
37688
37689
37690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37691   void * jresult ;
37692   Dali::Toolkit::Control *result = 0 ;
37693
37694   {
37695     try {
37696       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37697     } CALL_CATCH_EXCEPTION(0);
37698   }
37699
37700   jresult = (void *)result;
37701   return jresult;
37702 }
37703
37704
37705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37706   void * jresult ;
37707   Dali::Toolkit::Control *arg1 = 0 ;
37708   Dali::Toolkit::Control *result = 0 ;
37709
37710   arg1 = (Dali::Toolkit::Control *)jarg1;
37711   if (!arg1) {
37712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37713     return 0;
37714   }
37715   {
37716     try {
37717       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37718     } CALL_CATCH_EXCEPTION(0);
37719   }
37720
37721   jresult = (void *)result;
37722   return jresult;
37723 }
37724
37725
37726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
37727   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37728
37729   arg1 = (Dali::Toolkit::Control *)jarg1;
37730   {
37731     try {
37732       delete arg1;
37733     } CALL_CATCH_EXCEPTION();
37734   }
37735
37736 }
37737
37738
37739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
37740   void * jresult ;
37741   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37742   Dali::Toolkit::Control *arg2 = 0 ;
37743   Dali::Toolkit::Control *result = 0 ;
37744
37745   arg1 = (Dali::Toolkit::Control *)jarg1;
37746   arg2 = (Dali::Toolkit::Control *)jarg2;
37747   if (!arg2) {
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 *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
37754     } CALL_CATCH_EXCEPTION(0);
37755   }
37756
37757   jresult = (void *)result;
37758   return jresult;
37759 }
37760
37761
37762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
37763   void * jresult ;
37764   Dali::BaseHandle arg1 ;
37765   Dali::BaseHandle *argp1 ;
37766   Dali::Toolkit::Control result;
37767
37768   argp1 = (Dali::BaseHandle *)jarg1;
37769   if (!argp1) {
37770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37771     return 0;
37772   }
37773   arg1 = *argp1;
37774   {
37775     try {
37776       result = Dali::Toolkit::Control::DownCast(arg1);
37777     } CALL_CATCH_EXCEPTION(0);
37778   }
37779
37780   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37781   return jresult;
37782 }
37783
37784
37785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
37786   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37787
37788   arg1 = (Dali::Toolkit::Control *)jarg1;
37789   {
37790     try {
37791       (arg1)->SetKeyInputFocus();
37792     } CALL_CATCH_EXCEPTION();
37793   }
37794
37795 }
37796
37797
37798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
37799   unsigned int jresult ;
37800   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37801   bool result;
37802
37803   arg1 = (Dali::Toolkit::Control *)jarg1;
37804   {
37805     try {
37806       result = (bool)(arg1)->HasKeyInputFocus();
37807     } CALL_CATCH_EXCEPTION(0);
37808   }
37809
37810   jresult = result;
37811   return jresult;
37812 }
37813
37814
37815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
37816   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37817
37818   arg1 = (Dali::Toolkit::Control *)jarg1;
37819   {
37820     try {
37821       (arg1)->ClearKeyInputFocus();
37822     } CALL_CATCH_EXCEPTION();
37823   }
37824
37825 }
37826
37827
37828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
37829   void * jresult ;
37830   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37831   Dali::PinchGestureDetector result;
37832
37833   arg1 = (Dali::Toolkit::Control *)jarg1;
37834   {
37835     try {
37836       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
37837     } CALL_CATCH_EXCEPTION(0);
37838   }
37839
37840   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
37841   return jresult;
37842 }
37843
37844
37845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
37846   void * jresult ;
37847   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37848   Dali::PanGestureDetector result;
37849
37850   arg1 = (Dali::Toolkit::Control *)jarg1;
37851   {
37852     try {
37853       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
37854     } CALL_CATCH_EXCEPTION(0);
37855   }
37856
37857   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
37858   return jresult;
37859 }
37860
37861
37862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
37863   void * jresult ;
37864   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37865   Dali::TapGestureDetector result;
37866
37867   arg1 = (Dali::Toolkit::Control *)jarg1;
37868   {
37869     try {
37870       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
37871     } CALL_CATCH_EXCEPTION(0);
37872   }
37873
37874   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
37875   return jresult;
37876 }
37877
37878
37879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
37880   void * jresult ;
37881   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37882   Dali::LongPressGestureDetector result;
37883
37884   arg1 = (Dali::Toolkit::Control *)jarg1;
37885   {
37886     try {
37887       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
37888     } CALL_CATCH_EXCEPTION(0);
37889   }
37890
37891   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
37892   return jresult;
37893 }
37894
37895
37896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
37897   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37898   std::string *arg2 = 0 ;
37899
37900   arg1 = (Dali::Toolkit::Control *)jarg1;
37901   if (!jarg2) {
37902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
37903     return ;
37904   }
37905   std::string arg2_str(jarg2);
37906   arg2 = &arg2_str;
37907   {
37908     try {
37909       (arg1)->SetStyleName((std::string const &)*arg2);
37910     } CALL_CATCH_EXCEPTION();
37911   }
37912
37913
37914   //argout typemap for const std::string&
37915
37916 }
37917
37918
37919 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
37920   char * jresult ;
37921   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37922   std::string *result = 0 ;
37923
37924   arg1 = (Dali::Toolkit::Control *)jarg1;
37925   {
37926     try {
37927       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
37928     } CALL_CATCH_EXCEPTION(0);
37929   }
37930
37931   jresult = SWIG_csharp_string_callback(result->c_str());
37932   return jresult;
37933 }
37934
37935
37936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
37937   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37938   Dali::Vector4 *arg2 = 0 ;
37939
37940   arg1 = (Dali::Toolkit::Control *)jarg1;
37941   arg2 = (Dali::Vector4 *)jarg2;
37942   if (!arg2) {
37943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
37944     return ;
37945   }
37946   {
37947     try {
37948       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
37949     } CALL_CATCH_EXCEPTION();
37950   }
37951
37952 }
37953
37954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
37955   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37956
37957   arg1 = (Dali::Toolkit::Control *)jarg1;
37958   {
37959     try {
37960       (arg1)->ClearBackground();
37961     } CALL_CATCH_EXCEPTION();
37962   }
37963
37964 }
37965
37966
37967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
37968   void * jresult ;
37969   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37970   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
37971
37972   arg1 = (Dali::Toolkit::Control *)jarg1;
37973   {
37974     try {
37975       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
37976     } CALL_CATCH_EXCEPTION(0);
37977   }
37978
37979   jresult = (void *)result;
37980   return jresult;
37981 }
37982
37983
37984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
37985   void * jresult ;
37986   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37987   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
37988
37989   arg1 = (Dali::Toolkit::Control *)jarg1;
37990   {
37991     try {
37992       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
37993     } CALL_CATCH_EXCEPTION(0);
37994   }
37995
37996   jresult = (void *)result;
37997   return jresult;
37998 }
37999
38000
38001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
38002   void * jresult ;
38003   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38004   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38005
38006   arg1 = (Dali::Toolkit::Control *)jarg1;
38007   {
38008     try {
38009       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38010     } CALL_CATCH_EXCEPTION(0);
38011   }
38012
38013   jresult = (void *)result;
38014   return jresult;
38015 }
38016
38017
38018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38019   void * jresult ;
38020   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38021   Dali::Toolkit::Control *result = 0 ;
38022
38023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38024   if (!arg1) {
38025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38026     return 0;
38027   }
38028   {
38029     try {
38030       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38031     } CALL_CATCH_EXCEPTION(0);
38032   }
38033
38034   jresult = (void *)result;
38035   return jresult;
38036 }
38037
38038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38039 {
38040   int jresult;
38041   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38042   arg1 = (Dali::Toolkit::Control *)jarg1;
38043
38044   if (!arg1) {
38045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38046     return 0;
38047   }
38048
38049   Dali::Property::Index arg2 = 0 ;
38050   arg2 = (Dali::Property::Index)jarg2;
38051
38052   Toolkit::Visual::ResourceStatus result;
38053   {
38054     try {
38055       result = arg1->GetVisualResourceStatus(arg2);
38056     } CALL_CATCH_EXCEPTION(0);
38057   }
38058
38059   jresult = (int)result;
38060   return jresult;
38061 }
38062
38063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38064 {
38065   void * jresult;
38066   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38067   arg1 = (Dali::Toolkit::Control *)jarg1;
38068
38069   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38070
38071   Dali::Toolkit::TransitionData *arg2 = 0 ;
38072   Dali::Animation result;
38073
38074   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38075   if (!arg2) {
38076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38077     return 0;
38078   }
38079   {
38080     try {
38081       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38082     } CALL_CATCH_EXCEPTION(0);
38083   }
38084
38085   jresult = new Dali::Animation((const Dali::Animation &)result);
38086   return jresult;
38087 }
38088
38089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38090 {
38091   Dali::Toolkit::Control arg1;
38092   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38093
38094   if (!argp1) {
38095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38096   }
38097   arg1 = *argp1;
38098
38099   Dali::Property::Index arg2 = 0 ;
38100   arg2 = (Dali::Property::Index)jarg2;
38101
38102   Dali::Property::Index arg3 = 0 ;
38103   arg3 = (Dali::Property::Index)jarg3;
38104
38105   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38106
38107   {
38108     try {
38109       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38110     } CALL_CATCH_EXCEPTION();
38111   }
38112 }
38113
38114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38115   void * jresult ;
38116   Dali::Toolkit::Control *arg1 = 0 ;
38117   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38118
38119   arg1 = (Dali::Toolkit::Control *)jarg1;
38120   if (!arg1) {
38121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38122     return 0;
38123   }
38124   {
38125     try {
38126       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38127     } CALL_CATCH_EXCEPTION(0);
38128   }
38129
38130   jresult = (void *)result;
38131   return jresult;
38132 }
38133
38134
38135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38136   unsigned int jresult ;
38137   Dali::Toolkit::Control *arg1 = 0 ;
38138   bool result;
38139
38140   arg1 = (Dali::Toolkit::Control *)jarg1;
38141   if (!arg1) {
38142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38143     return 0;
38144   }
38145   {
38146     try {
38147       result = (bool)arg1->IsResourceReady();
38148     } CALL_CATCH_EXCEPTION(0);
38149   }
38150
38151   jresult = result;
38152   return jresult;
38153 }
38154
38155
38156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38157   void * jresult ;
38158   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38159
38160   {
38161     try {
38162       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38163     } CALL_CATCH_EXCEPTION(0);
38164   }
38165
38166   jresult = (void *)result;
38167   return jresult;
38168 }
38169
38170
38171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38172   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38173
38174   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38175   {
38176     try {
38177       delete arg1;
38178     } CALL_CATCH_EXCEPTION();
38179   }
38180
38181 }
38182
38183
38184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38185   void * jresult ;
38186   Dali::Toolkit::KeyInputFocusManager result;
38187
38188   {
38189     try {
38190       result = Dali::Toolkit::KeyInputFocusManager::Get();
38191     } CALL_CATCH_EXCEPTION(0);
38192   }
38193
38194   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38195   return jresult;
38196 }
38197
38198
38199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38200   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38201   Dali::Toolkit::Control arg2 ;
38202   Dali::Toolkit::Control *argp2 ;
38203
38204   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38205   argp2 = (Dali::Toolkit::Control *)jarg2;
38206   if (!argp2) {
38207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38208     return ;
38209   }
38210   arg2 = *argp2;
38211   {
38212     try {
38213       (arg1)->SetFocus(arg2);
38214     } CALL_CATCH_EXCEPTION();
38215   }
38216
38217 }
38218
38219
38220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38221   void * jresult ;
38222   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38223   Dali::Toolkit::Control result;
38224
38225   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38226   {
38227     try {
38228       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38229     } CALL_CATCH_EXCEPTION(0);
38230   }
38231
38232   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38233   return jresult;
38234 }
38235
38236
38237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38238   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38239   Dali::Toolkit::Control arg2 ;
38240   Dali::Toolkit::Control *argp2 ;
38241
38242   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38243   argp2 = (Dali::Toolkit::Control *)jarg2;
38244   if (!argp2) {
38245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38246     return ;
38247   }
38248   arg2 = *argp2;
38249   {
38250     try {
38251       (arg1)->RemoveFocus(arg2);
38252     } CALL_CATCH_EXCEPTION();
38253   }
38254
38255 }
38256
38257
38258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38259   void * jresult ;
38260   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38261   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38262
38263   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38264   {
38265     try {
38266       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38267     } CALL_CATCH_EXCEPTION(0);
38268   }
38269
38270   jresult = (void *)result;
38271   return jresult;
38272 }
38273
38274
38275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38276   void * jresult ;
38277   Dali::Toolkit::Alignment::Padding *result = 0 ;
38278
38279   {
38280     try {
38281       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38282     } CALL_CATCH_EXCEPTION(0);
38283   }
38284
38285   jresult = (void *)result;
38286   return jresult;
38287 }
38288
38289
38290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38291   void * jresult ;
38292   float arg1 ;
38293   float arg2 ;
38294   float arg3 ;
38295   float arg4 ;
38296   Dali::Toolkit::Alignment::Padding *result = 0 ;
38297
38298   arg1 = (float)jarg1;
38299   arg2 = (float)jarg2;
38300   arg3 = (float)jarg3;
38301   arg4 = (float)jarg4;
38302   {
38303     try {
38304       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38305     } CALL_CATCH_EXCEPTION(0);
38306   }
38307
38308   jresult = (void *)result;
38309   return jresult;
38310 }
38311
38312
38313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38314   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38315   float arg2 ;
38316
38317   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38318   arg2 = (float)jarg2;
38319   if (arg1) (arg1)->left = arg2;
38320 }
38321
38322
38323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38324   float jresult ;
38325   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38326   float result;
38327
38328   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38329   result = (float) ((arg1)->left);
38330   jresult = result;
38331   return jresult;
38332 }
38333
38334
38335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38336   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38337   float arg2 ;
38338
38339   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38340   arg2 = (float)jarg2;
38341   if (arg1) (arg1)->right = arg2;
38342 }
38343
38344
38345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38346   float jresult ;
38347   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38348   float result;
38349
38350   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38351   result = (float) ((arg1)->right);
38352   jresult = result;
38353   return jresult;
38354 }
38355
38356
38357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38358   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38359   float arg2 ;
38360
38361   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38362   arg2 = (float)jarg2;
38363   if (arg1) (arg1)->top = arg2;
38364 }
38365
38366
38367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38368   float jresult ;
38369   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38370   float result;
38371
38372   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38373   result = (float) ((arg1)->top);
38374   jresult = result;
38375   return jresult;
38376 }
38377
38378
38379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38380   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38381   float arg2 ;
38382
38383   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38384   arg2 = (float)jarg2;
38385   if (arg1) (arg1)->bottom = arg2;
38386 }
38387
38388
38389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38390   float jresult ;
38391   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38392   float result;
38393
38394   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38395   result = (float) ((arg1)->bottom);
38396   jresult = result;
38397   return jresult;
38398 }
38399
38400
38401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38402   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38403
38404   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38405   {
38406     try {
38407       delete arg1;
38408     } CALL_CATCH_EXCEPTION();
38409   }
38410
38411 }
38412
38413
38414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38415   void * jresult ;
38416   Dali::Toolkit::Alignment *result = 0 ;
38417
38418   {
38419     try {
38420       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38421     } CALL_CATCH_EXCEPTION(0);
38422   }
38423
38424   jresult = (void *)result;
38425   return jresult;
38426 }
38427
38428
38429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38430   void * jresult ;
38431   Dali::Toolkit::Alignment::Type arg1 ;
38432   Dali::Toolkit::Alignment::Type arg2 ;
38433   Dali::Toolkit::Alignment result;
38434
38435   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38436   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38437   {
38438     try {
38439       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38440     } CALL_CATCH_EXCEPTION(0);
38441   }
38442
38443   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38444   return jresult;
38445 }
38446
38447
38448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38449   void * jresult ;
38450   Dali::Toolkit::Alignment::Type arg1 ;
38451   Dali::Toolkit::Alignment result;
38452
38453   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38454   {
38455     try {
38456       result = Dali::Toolkit::Alignment::New(arg1);
38457     } CALL_CATCH_EXCEPTION(0);
38458   }
38459
38460   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38461   return jresult;
38462 }
38463
38464
38465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
38466   void * jresult ;
38467   Dali::Toolkit::Alignment result;
38468
38469   {
38470     try {
38471       result = Dali::Toolkit::Alignment::New();
38472     } CALL_CATCH_EXCEPTION(0);
38473   }
38474
38475   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38476   return jresult;
38477 }
38478
38479
38480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38481   void * jresult ;
38482   Dali::Toolkit::Alignment *arg1 = 0 ;
38483   Dali::Toolkit::Alignment *result = 0 ;
38484
38485   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38486   if (!arg1) {
38487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38488     return 0;
38489   }
38490   {
38491     try {
38492       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38493     } CALL_CATCH_EXCEPTION(0);
38494   }
38495
38496   jresult = (void *)result;
38497   return jresult;
38498 }
38499
38500
38501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38502   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38503
38504   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38505   {
38506     try {
38507       delete arg1;
38508     } CALL_CATCH_EXCEPTION();
38509   }
38510
38511 }
38512
38513
38514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38515   void * jresult ;
38516   Dali::BaseHandle arg1 ;
38517   Dali::BaseHandle *argp1 ;
38518   Dali::Toolkit::Alignment result;
38519
38520   argp1 = (Dali::BaseHandle *)jarg1;
38521   if (!argp1) {
38522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38523     return 0;
38524   }
38525   arg1 = *argp1;
38526   {
38527     try {
38528       result = Dali::Toolkit::Alignment::DownCast(arg1);
38529     } CALL_CATCH_EXCEPTION(0);
38530   }
38531
38532   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38533   return jresult;
38534 }
38535
38536
38537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38538   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38539   Dali::Toolkit::Alignment::Type arg2 ;
38540
38541   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38542   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38543   {
38544     try {
38545       (arg1)->SetAlignmentType(arg2);
38546     } CALL_CATCH_EXCEPTION();
38547   }
38548
38549 }
38550
38551
38552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38553   int jresult ;
38554   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38555   Dali::Toolkit::Alignment::Type result;
38556
38557   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38558   {
38559     try {
38560       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38561     } CALL_CATCH_EXCEPTION(0);
38562   }
38563
38564   jresult = (int)result;
38565   return jresult;
38566 }
38567
38568
38569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38570   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38571   Dali::Toolkit::Alignment::Scaling arg2 ;
38572
38573   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38574   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38575   {
38576     try {
38577       (arg1)->SetScaling(arg2);
38578     } CALL_CATCH_EXCEPTION();
38579   }
38580
38581 }
38582
38583
38584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38585   int jresult ;
38586   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38587   Dali::Toolkit::Alignment::Scaling result;
38588
38589   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38590   {
38591     try {
38592       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38593     } CALL_CATCH_EXCEPTION(0);
38594   }
38595
38596   jresult = (int)result;
38597   return jresult;
38598 }
38599
38600
38601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38602   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38603   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38604
38605   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38606   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38607   if (!arg2) {
38608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38609     return ;
38610   }
38611   {
38612     try {
38613       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38614     } CALL_CATCH_EXCEPTION();
38615   }
38616
38617 }
38618
38619
38620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38621   void * jresult ;
38622   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38623   Dali::Toolkit::Alignment::Padding *result = 0 ;
38624
38625   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38626   {
38627     try {
38628       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38629     } CALL_CATCH_EXCEPTION(0);
38630   }
38631
38632   jresult = (void *)result;
38633   return jresult;
38634 }
38635
38636
38637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38638   void * jresult ;
38639   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38640   Dali::Toolkit::Alignment *arg2 = 0 ;
38641   Dali::Toolkit::Alignment *result = 0 ;
38642
38643   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38644   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38645   if (!arg2) {
38646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38647     return 0;
38648   }
38649   {
38650     try {
38651       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38652     } CALL_CATCH_EXCEPTION(0);
38653   }
38654
38655   jresult = (void *)result;
38656   return jresult;
38657 }
38658
38659
38660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38661   int jresult ;
38662   int result;
38663
38664   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38665   jresult = (int)result;
38666   return jresult;
38667 }
38668
38669
38670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38671   int jresult ;
38672   int result;
38673
38674   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38675   jresult = (int)result;
38676   return jresult;
38677 }
38678
38679
38680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38681   int jresult ;
38682   int result;
38683
38684   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38685   jresult = (int)result;
38686   return jresult;
38687 }
38688
38689
38690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38691   int jresult ;
38692   int result;
38693
38694   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38695   jresult = (int)result;
38696   return jresult;
38697 }
38698
38699
38700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38701   int jresult ;
38702   int result;
38703
38704   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38705   jresult = (int)result;
38706   return jresult;
38707 }
38708
38709
38710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38711   int jresult ;
38712   int result;
38713
38714   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38715   jresult = (int)result;
38716   return jresult;
38717 }
38718
38719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38720   int jresult ;
38721   int result;
38722
38723   result = (int)Dali::Toolkit::Button::Property::LABEL;
38724   jresult = (int)result;
38725   return jresult;
38726 }
38727
38728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
38729   void * jresult ;
38730   Dali::Toolkit::Button::Property *result = 0 ;
38731
38732   {
38733     try {
38734       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
38735     } CALL_CATCH_EXCEPTION(0);
38736   }
38737
38738   jresult = (void *)result;
38739   return jresult;
38740 }
38741
38742
38743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
38744   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
38745
38746   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
38747   {
38748     try {
38749       delete arg1;
38750     } CALL_CATCH_EXCEPTION();
38751   }
38752
38753 }
38754
38755
38756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
38757   void * jresult ;
38758   Dali::Toolkit::Button *result = 0 ;
38759
38760   {
38761     try {
38762       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
38763     } CALL_CATCH_EXCEPTION(0);
38764   }
38765
38766   jresult = (void *)result;
38767   return jresult;
38768 }
38769
38770
38771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
38772   void * jresult ;
38773   Dali::Toolkit::Button *arg1 = 0 ;
38774   Dali::Toolkit::Button *result = 0 ;
38775
38776   arg1 = (Dali::Toolkit::Button *)jarg1;
38777   if (!arg1) {
38778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38779     return 0;
38780   }
38781   {
38782     try {
38783       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
38784     } CALL_CATCH_EXCEPTION(0);
38785   }
38786
38787   jresult = (void *)result;
38788   return jresult;
38789 }
38790
38791
38792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
38793   void * jresult ;
38794   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38795   Dali::Toolkit::Button *arg2 = 0 ;
38796   Dali::Toolkit::Button *result = 0 ;
38797
38798   arg1 = (Dali::Toolkit::Button *)jarg1;
38799   arg2 = (Dali::Toolkit::Button *)jarg2;
38800   if (!arg2) {
38801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38802     return 0;
38803   }
38804   {
38805     try {
38806       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
38807     } CALL_CATCH_EXCEPTION(0);
38808   }
38809
38810   jresult = (void *)result;
38811   return jresult;
38812 }
38813
38814
38815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
38816   void * jresult ;
38817   Dali::BaseHandle arg1 ;
38818   Dali::BaseHandle *argp1 ;
38819   Dali::Toolkit::Button result;
38820
38821   argp1 = (Dali::BaseHandle *)jarg1;
38822   if (!argp1) {
38823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38824     return 0;
38825   }
38826   arg1 = *argp1;
38827   {
38828     try {
38829       result = Dali::Toolkit::Button::DownCast(arg1);
38830     } CALL_CATCH_EXCEPTION(0);
38831   }
38832
38833   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
38834   return jresult;
38835 }
38836
38837
38838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
38839   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38840
38841   arg1 = (Dali::Toolkit::Button *)jarg1;
38842   {
38843     try {
38844       delete arg1;
38845     } CALL_CATCH_EXCEPTION();
38846   }
38847
38848 }
38849
38850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
38851   void * jresult ;
38852   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38853   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38854
38855   arg1 = (Dali::Toolkit::Button *)jarg1;
38856   {
38857     try {
38858       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
38859     } CALL_CATCH_EXCEPTION(0);
38860   }
38861
38862   jresult = (void *)result;
38863   return jresult;
38864 }
38865
38866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
38867   void * jresult ;
38868   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38869   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38870
38871   arg1 = (Dali::Toolkit::Button *)jarg1;
38872   {
38873     try {
38874       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
38875     } CALL_CATCH_EXCEPTION(0);
38876   }
38877
38878   jresult = (void *)result;
38879   return jresult;
38880 }
38881
38882
38883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
38884   void * jresult ;
38885   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38886   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38887
38888   arg1 = (Dali::Toolkit::Button *)jarg1;
38889   {
38890     try {
38891       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
38892     } CALL_CATCH_EXCEPTION(0);
38893   }
38894
38895   jresult = (void *)result;
38896   return jresult;
38897 }
38898
38899
38900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
38901   void * jresult ;
38902   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
38903   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
38904
38905   arg1 = (Dali::Toolkit::Button *)jarg1;
38906   {
38907     try {
38908       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
38909     } CALL_CATCH_EXCEPTION(0);
38910   }
38911
38912   jresult = (void *)result;
38913   return jresult;
38914 }
38915
38916
38917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
38918   void * jresult ;
38919   Dali::Toolkit::CheckBoxButton *result = 0 ;
38920
38921   {
38922     try {
38923       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
38924     } CALL_CATCH_EXCEPTION(0);
38925   }
38926
38927   jresult = (void *)result;
38928   return jresult;
38929 }
38930
38931
38932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
38933   void * jresult ;
38934   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
38935   Dali::Toolkit::CheckBoxButton *result = 0 ;
38936
38937   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
38938   if (!arg1) {
38939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
38940     return 0;
38941   }
38942   {
38943     try {
38944       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
38945     } CALL_CATCH_EXCEPTION(0);
38946   }
38947
38948   jresult = (void *)result;
38949   return jresult;
38950 }
38951
38952
38953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
38954   void * jresult ;
38955   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
38956   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
38957   Dali::Toolkit::CheckBoxButton *result = 0 ;
38958
38959   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
38960   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
38961   if (!arg2) {
38962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
38963     return 0;
38964   }
38965   {
38966     try {
38967       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
38968     } CALL_CATCH_EXCEPTION(0);
38969   }
38970
38971   jresult = (void *)result;
38972   return jresult;
38973 }
38974
38975
38976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
38977   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
38978
38979   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
38980   {
38981     try {
38982       delete arg1;
38983     } CALL_CATCH_EXCEPTION();
38984   }
38985
38986 }
38987
38988
38989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
38990   void * jresult ;
38991   Dali::Toolkit::CheckBoxButton result;
38992
38993   {
38994     try {
38995       result = Dali::Toolkit::CheckBoxButton::New();
38996     } CALL_CATCH_EXCEPTION(0);
38997   }
38998
38999   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39000   return jresult;
39001 }
39002
39003
39004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39005   void * jresult ;
39006   Dali::BaseHandle arg1 ;
39007   Dali::BaseHandle *argp1 ;
39008   Dali::Toolkit::CheckBoxButton result;
39009
39010   argp1 = (Dali::BaseHandle *)jarg1;
39011   if (!argp1) {
39012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39013     return 0;
39014   }
39015   arg1 = *argp1;
39016   {
39017     try {
39018       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39019     } CALL_CATCH_EXCEPTION(0);
39020   }
39021
39022   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39023   return jresult;
39024 }
39025
39026
39027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39028   int jresult ;
39029   int result;
39030
39031   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39032   jresult = (int)result;
39033   return jresult;
39034 }
39035
39036
39037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39038   int jresult ;
39039   int result;
39040
39041   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39042   jresult = (int)result;
39043   return jresult;
39044 }
39045
39046
39047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39048   void * jresult ;
39049   Dali::Toolkit::PushButton::Property *result = 0 ;
39050
39051   {
39052     try {
39053       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39054     } CALL_CATCH_EXCEPTION(0);
39055   }
39056
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39063   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39064
39065   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39066   {
39067     try {
39068       delete arg1;
39069     } CALL_CATCH_EXCEPTION();
39070   }
39071
39072 }
39073
39074
39075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39076   void * jresult ;
39077   Dali::Toolkit::PushButton *result = 0 ;
39078
39079   {
39080     try {
39081       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39082     } CALL_CATCH_EXCEPTION(0);
39083   }
39084
39085   jresult = (void *)result;
39086   return jresult;
39087 }
39088
39089
39090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39091   void * jresult ;
39092   Dali::Toolkit::PushButton *arg1 = 0 ;
39093   Dali::Toolkit::PushButton *result = 0 ;
39094
39095   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39096   if (!arg1) {
39097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39098     return 0;
39099   }
39100   {
39101     try {
39102       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39103     } CALL_CATCH_EXCEPTION(0);
39104   }
39105
39106   jresult = (void *)result;
39107   return jresult;
39108 }
39109
39110
39111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39112   void * jresult ;
39113   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39114   Dali::Toolkit::PushButton *arg2 = 0 ;
39115   Dali::Toolkit::PushButton *result = 0 ;
39116
39117   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39118   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39119   if (!arg2) {
39120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39121     return 0;
39122   }
39123   {
39124     try {
39125       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39126     } CALL_CATCH_EXCEPTION(0);
39127   }
39128
39129   jresult = (void *)result;
39130   return jresult;
39131 }
39132
39133
39134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39135   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39136
39137   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39138   {
39139     try {
39140       delete arg1;
39141     } CALL_CATCH_EXCEPTION();
39142   }
39143
39144 }
39145
39146
39147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39148   void * jresult ;
39149   Dali::Toolkit::PushButton result;
39150
39151   {
39152     try {
39153       result = Dali::Toolkit::PushButton::New();
39154     } CALL_CATCH_EXCEPTION(0);
39155   }
39156
39157   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39158   return jresult;
39159 }
39160
39161
39162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39163   void * jresult ;
39164   Dali::BaseHandle arg1 ;
39165   Dali::BaseHandle *argp1 ;
39166   Dali::Toolkit::PushButton result;
39167
39168   argp1 = (Dali::BaseHandle *)jarg1;
39169   if (!argp1) {
39170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39171     return 0;
39172   }
39173   arg1 = *argp1;
39174   {
39175     try {
39176       result = Dali::Toolkit::PushButton::DownCast(arg1);
39177     } CALL_CATCH_EXCEPTION(0);
39178   }
39179
39180   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39181   return jresult;
39182 }
39183
39184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39185   void * jresult ;
39186   Dali::Toolkit::RadioButton *result = 0 ;
39187
39188   {
39189     try {
39190       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39191     } CALL_CATCH_EXCEPTION(0);
39192   }
39193
39194   jresult = (void *)result;
39195   return jresult;
39196 }
39197
39198
39199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39200   void * jresult ;
39201   Dali::Toolkit::RadioButton *arg1 = 0 ;
39202   Dali::Toolkit::RadioButton *result = 0 ;
39203
39204   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39205   if (!arg1) {
39206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39207     return 0;
39208   }
39209   {
39210     try {
39211       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39212     } CALL_CATCH_EXCEPTION(0);
39213   }
39214
39215   jresult = (void *)result;
39216   return jresult;
39217 }
39218
39219
39220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39221   void * jresult ;
39222   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39223   Dali::Toolkit::RadioButton *arg2 = 0 ;
39224   Dali::Toolkit::RadioButton *result = 0 ;
39225
39226   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39227   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39228   if (!arg2) {
39229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39230     return 0;
39231   }
39232   {
39233     try {
39234       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39235     } CALL_CATCH_EXCEPTION(0);
39236   }
39237
39238   jresult = (void *)result;
39239   return jresult;
39240 }
39241
39242
39243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39244   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39245
39246   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39247   {
39248     try {
39249       delete arg1;
39250     } CALL_CATCH_EXCEPTION();
39251   }
39252
39253 }
39254
39255
39256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39257   void * jresult ;
39258   Dali::Toolkit::RadioButton result;
39259
39260   {
39261     try {
39262       result = Dali::Toolkit::RadioButton::New();
39263     } CALL_CATCH_EXCEPTION(0);
39264   }
39265
39266   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39267   return jresult;
39268 }
39269
39270
39271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39272   void * jresult ;
39273   std::string *arg1 = 0 ;
39274   Dali::Toolkit::RadioButton result;
39275
39276   if (!jarg1) {
39277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39278     return 0;
39279   }
39280   std::string arg1_str(jarg1);
39281   arg1 = &arg1_str;
39282   {
39283     try {
39284       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39285     } CALL_CATCH_EXCEPTION(0);
39286   }
39287
39288   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39289
39290   //argout typemap for const std::string&
39291
39292   return jresult;
39293 }
39294
39295
39296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39297   void * jresult ;
39298   Dali::BaseHandle arg1 ;
39299   Dali::BaseHandle *argp1 ;
39300   Dali::Toolkit::RadioButton result;
39301
39302   argp1 = (Dali::BaseHandle *)jarg1;
39303   if (!argp1) {
39304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39305     return 0;
39306   }
39307   arg1 = *argp1;
39308   {
39309     try {
39310       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39311     } CALL_CATCH_EXCEPTION(0);
39312   }
39313
39314   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39315   return jresult;
39316 }
39317
39318
39319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39320   int jresult ;
39321   int result;
39322
39323   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39324   jresult = (int)result;
39325   return jresult;
39326 }
39327
39328
39329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39330   int jresult ;
39331   int result;
39332
39333   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39334   jresult = (int)result;
39335   return jresult;
39336 }
39337
39338
39339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39340   int jresult ;
39341   int result;
39342
39343   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39344   jresult = (int)result;
39345   return jresult;
39346 }
39347
39348
39349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39350   int jresult ;
39351   int result;
39352
39353   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39354   jresult = (int)result;
39355   return jresult;
39356 }
39357
39358
39359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39360   int jresult ;
39361   int result;
39362
39363   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39364   jresult = (int)result;
39365   return jresult;
39366 }
39367
39368
39369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39370   int jresult ;
39371   int result;
39372
39373   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39374   jresult = (int)result;
39375   return jresult;
39376 }
39377
39378
39379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39380   void * jresult ;
39381   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39382
39383   {
39384     try {
39385       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39386     } CALL_CATCH_EXCEPTION(0);
39387   }
39388
39389   jresult = (void *)result;
39390   return jresult;
39391 }
39392
39393
39394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39395   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39396
39397   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39398   {
39399     try {
39400       delete arg1;
39401     } CALL_CATCH_EXCEPTION();
39402   }
39403
39404 }
39405
39406
39407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39408   int jresult ;
39409   int result;
39410
39411   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39412   jresult = (int)result;
39413   return jresult;
39414 }
39415
39416
39417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39418   int jresult ;
39419   int result;
39420
39421   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39422   jresult = (int)result;
39423   return jresult;
39424 }
39425
39426
39427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39428   int jresult ;
39429   int result;
39430
39431   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39432   jresult = (int)result;
39433   return jresult;
39434 }
39435
39436
39437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39438   void * jresult ;
39439   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39440
39441   {
39442     try {
39443       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39444     } CALL_CATCH_EXCEPTION(0);
39445   }
39446
39447   jresult = (void *)result;
39448   return jresult;
39449 }
39450
39451
39452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39453   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39454
39455   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39456   {
39457     try {
39458       delete arg1;
39459     } CALL_CATCH_EXCEPTION();
39460   }
39461
39462 }
39463
39464
39465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39466   void * jresult ;
39467   Dali::Toolkit::FlexContainer *result = 0 ;
39468
39469   {
39470     try {
39471       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39472     } CALL_CATCH_EXCEPTION(0);
39473   }
39474
39475   jresult = (void *)result;
39476   return jresult;
39477 }
39478
39479
39480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39481   void * jresult ;
39482   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39483   Dali::Toolkit::FlexContainer *result = 0 ;
39484
39485   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39486   if (!arg1) {
39487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39488     return 0;
39489   }
39490   {
39491     try {
39492       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39493     } CALL_CATCH_EXCEPTION(0);
39494   }
39495
39496   jresult = (void *)result;
39497   return jresult;
39498 }
39499
39500
39501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39502   void * jresult ;
39503   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39504   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39505   Dali::Toolkit::FlexContainer *result = 0 ;
39506
39507   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39508   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39509   if (!arg2) {
39510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39511     return 0;
39512   }
39513   {
39514     try {
39515       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39516     } CALL_CATCH_EXCEPTION(0);
39517   }
39518
39519   jresult = (void *)result;
39520   return jresult;
39521 }
39522
39523
39524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39525   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39526
39527   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39528   {
39529     try {
39530       delete arg1;
39531     } CALL_CATCH_EXCEPTION();
39532   }
39533
39534 }
39535
39536
39537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39538   void * jresult ;
39539   Dali::Toolkit::FlexContainer result;
39540
39541   {
39542     try {
39543       result = Dali::Toolkit::FlexContainer::New();
39544     } CALL_CATCH_EXCEPTION(0);
39545   }
39546
39547   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39548   return jresult;
39549 }
39550
39551
39552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39553   void * jresult ;
39554   Dali::BaseHandle arg1 ;
39555   Dali::BaseHandle *argp1 ;
39556   Dali::Toolkit::FlexContainer result;
39557
39558   argp1 = (Dali::BaseHandle *)jarg1;
39559   if (!argp1) {
39560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39561     return 0;
39562   }
39563   arg1 = *argp1;
39564   {
39565     try {
39566       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39567     } CALL_CATCH_EXCEPTION(0);
39568   }
39569
39570   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39571   return jresult;
39572 }
39573
39574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39575   int jresult ;
39576   int result;
39577
39578   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39579   jresult = (int)result;
39580   return jresult;
39581 }
39582
39583
39584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39585   int jresult ;
39586   int result;
39587
39588   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39589   jresult = (int)result;
39590   return jresult;
39591 }
39592
39593
39594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39595   int jresult ;
39596   int result;
39597
39598   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39599   jresult = (int)result;
39600   return jresult;
39601 }
39602
39603
39604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39605   void * jresult ;
39606   Dali::Toolkit::ImageView::Property *result = 0 ;
39607
39608   {
39609     try {
39610       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39611     } CALL_CATCH_EXCEPTION(0);
39612   }
39613
39614   jresult = (void *)result;
39615   return jresult;
39616 }
39617
39618
39619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39620   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39621
39622   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39623   {
39624     try {
39625       delete arg1;
39626     } CALL_CATCH_EXCEPTION();
39627   }
39628
39629 }
39630
39631
39632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39633   void * jresult ;
39634   Dali::Toolkit::ImageView *result = 0 ;
39635
39636   {
39637     try {
39638       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39639     } CALL_CATCH_EXCEPTION(0);
39640   }
39641
39642   jresult = (void *)result;
39643   return jresult;
39644 }
39645
39646
39647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39648   void * jresult ;
39649   Dali::Toolkit::ImageView result;
39650
39651   {
39652     try {
39653       result = Dali::Toolkit::ImageView::New();
39654     } CALL_CATCH_EXCEPTION(0);
39655   }
39656
39657   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39658   return jresult;
39659 }
39660
39661
39662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39663   void * jresult ;
39664   std::string *arg1 = 0 ;
39665   Dali::Toolkit::ImageView result;
39666
39667   if (!jarg1) {
39668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39669     return 0;
39670   }
39671   std::string arg1_str(jarg1);
39672   arg1 = &arg1_str;
39673   {
39674     try {
39675       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39676     } CALL_CATCH_EXCEPTION(0);
39677   }
39678
39679   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39680
39681   //argout typemap for const std::string&
39682
39683   return jresult;
39684 }
39685
39686
39687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39688   void * jresult ;
39689   std::string *arg1 = 0 ;
39690   Dali::ImageDimensions arg2 ;
39691   Dali::ImageDimensions *argp2 ;
39692   Dali::Toolkit::ImageView result;
39693
39694   if (!jarg1) {
39695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39696     return 0;
39697   }
39698   std::string arg1_str(jarg1);
39699   arg1 = &arg1_str;
39700   argp2 = (Dali::ImageDimensions *)jarg2;
39701   if (!argp2) {
39702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39703     return 0;
39704   }
39705   arg2 = *argp2;
39706   {
39707     try {
39708       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39709     } CALL_CATCH_EXCEPTION(0);
39710   }
39711
39712   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39713
39714   //argout typemap for const std::string&
39715
39716   return jresult;
39717 }
39718
39719
39720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39721   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39722
39723   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39724   {
39725     try {
39726       delete arg1;
39727     } CALL_CATCH_EXCEPTION();
39728   }
39729
39730 }
39731
39732
39733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
39734   void * jresult ;
39735   Dali::Toolkit::ImageView *arg1 = 0 ;
39736   Dali::Toolkit::ImageView *result = 0 ;
39737
39738   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39739   if (!arg1) {
39740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39741     return 0;
39742   }
39743   {
39744     try {
39745       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
39746     } CALL_CATCH_EXCEPTION(0);
39747   }
39748
39749   jresult = (void *)result;
39750   return jresult;
39751 }
39752
39753
39754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
39755   void * jresult ;
39756   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39757   Dali::Toolkit::ImageView *arg2 = 0 ;
39758   Dali::Toolkit::ImageView *result = 0 ;
39759
39760   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39761   arg2 = (Dali::Toolkit::ImageView *)jarg2;
39762   if (!arg2) {
39763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39764     return 0;
39765   }
39766   {
39767     try {
39768       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
39769     } CALL_CATCH_EXCEPTION(0);
39770   }
39771
39772   jresult = (void *)result;
39773   return jresult;
39774 }
39775
39776
39777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
39778   void * jresult ;
39779   Dali::BaseHandle arg1 ;
39780   Dali::BaseHandle *argp1 ;
39781   Dali::Toolkit::ImageView result;
39782
39783   argp1 = (Dali::BaseHandle *)jarg1;
39784   if (!argp1) {
39785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39786     return 0;
39787   }
39788   arg1 = *argp1;
39789   {
39790     try {
39791       result = Dali::Toolkit::ImageView::DownCast(arg1);
39792     } CALL_CATCH_EXCEPTION(0);
39793   }
39794
39795   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39796   return jresult;
39797 }
39798
39799
39800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
39801   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39802   std::string *arg2 = 0 ;
39803
39804   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39805   if (!jarg2) {
39806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39807     return ;
39808   }
39809   std::string arg2_str(jarg2);
39810   arg2 = &arg2_str;
39811   {
39812     try {
39813       (arg1)->SetImage((std::string const &)*arg2);
39814     } CALL_CATCH_EXCEPTION();
39815   }
39816
39817
39818   //argout typemap for const std::string&
39819
39820 }
39821
39822
39823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
39824   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39825   std::string *arg2 = 0 ;
39826   Dali::ImageDimensions arg3 ;
39827   Dali::ImageDimensions *argp3 ;
39828
39829   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39830   if (!jarg2) {
39831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39832     return ;
39833   }
39834   std::string arg2_str(jarg2);
39835   arg2 = &arg2_str;
39836   argp3 = (Dali::ImageDimensions *)jarg3;
39837   if (!argp3) {
39838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39839     return ;
39840   }
39841   arg3 = *argp3;
39842   {
39843     try {
39844       (arg1)->SetImage((std::string const &)*arg2,arg3);
39845     } CALL_CATCH_EXCEPTION();
39846   }
39847
39848
39849   //argout typemap for const std::string&
39850
39851 }
39852
39853
39854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
39855   int jresult ;
39856   int result;
39857
39858   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
39859   jresult = (int)result;
39860   return jresult;
39861 }
39862
39863
39864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
39865   int jresult ;
39866   int result;
39867
39868   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
39869   jresult = (int)result;
39870   return jresult;
39871 }
39872
39873
39874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
39875   int jresult ;
39876   int result;
39877
39878   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
39879   jresult = (int)result;
39880   return jresult;
39881 }
39882
39883
39884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
39885   int jresult ;
39886   int result;
39887
39888   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
39889   jresult = (int)result;
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
39895   int jresult ;
39896   int result;
39897
39898   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
39899   jresult = (int)result;
39900   return jresult;
39901 }
39902
39903
39904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
39905   int jresult ;
39906   int result;
39907
39908   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
39909   jresult = (int)result;
39910   return jresult;
39911 }
39912
39913
39914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
39915   int jresult ;
39916   int result;
39917
39918   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
39919   jresult = (int)result;
39920   return jresult;
39921 }
39922
39923
39924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
39925   int jresult ;
39926   int result;
39927
39928   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
39929   jresult = (int)result;
39930   return jresult;
39931 }
39932
39933
39934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
39935   void * jresult ;
39936   Dali::Toolkit::Model3dView::Property *result = 0 ;
39937
39938   {
39939     try {
39940       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
39941     } CALL_CATCH_EXCEPTION(0);
39942   }
39943
39944   jresult = (void *)result;
39945   return jresult;
39946 }
39947
39948
39949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
39950   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
39951
39952   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
39953   {
39954     try {
39955       delete arg1;
39956     } CALL_CATCH_EXCEPTION();
39957   }
39958
39959 }
39960
39961
39962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
39963   void * jresult ;
39964   Dali::Toolkit::Model3dView result;
39965
39966   {
39967     try {
39968       result = Dali::Toolkit::Model3dView::New();
39969     } CALL_CATCH_EXCEPTION(0);
39970   }
39971
39972   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
39973   return jresult;
39974 }
39975
39976
39977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
39978   void * jresult ;
39979   std::string *arg1 = 0 ;
39980   std::string *arg2 = 0 ;
39981   std::string *arg3 = 0 ;
39982   Dali::Toolkit::Model3dView result;
39983
39984   if (!jarg1) {
39985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39986     return 0;
39987   }
39988   std::string arg1_str(jarg1);
39989   arg1 = &arg1_str;
39990   if (!jarg2) {
39991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39992     return 0;
39993   }
39994   std::string arg2_str(jarg2);
39995   arg2 = &arg2_str;
39996   if (!jarg3) {
39997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39998     return 0;
39999   }
40000   std::string arg3_str(jarg3);
40001   arg3 = &arg3_str;
40002   {
40003     try {
40004       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40005     } CALL_CATCH_EXCEPTION(0);
40006   }
40007
40008   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40009
40010   //argout typemap for const std::string&
40011
40012
40013   //argout typemap for const std::string&
40014
40015
40016   //argout typemap for const std::string&
40017
40018   return jresult;
40019 }
40020
40021
40022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40023   void * jresult ;
40024   Dali::Toolkit::Model3dView *result = 0 ;
40025
40026   {
40027     try {
40028       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40029     } CALL_CATCH_EXCEPTION(0);
40030   }
40031
40032   jresult = (void *)result;
40033   return jresult;
40034 }
40035
40036
40037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40038   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40039
40040   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40041   {
40042     try {
40043       delete arg1;
40044     } CALL_CATCH_EXCEPTION();
40045   }
40046
40047 }
40048
40049
40050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40051   void * jresult ;
40052   Dali::Toolkit::Model3dView *arg1 = 0 ;
40053   Dali::Toolkit::Model3dView *result = 0 ;
40054
40055   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40056   if (!arg1) {
40057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40058     return 0;
40059   }
40060   {
40061     try {
40062       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40063     } CALL_CATCH_EXCEPTION(0);
40064   }
40065
40066   jresult = (void *)result;
40067   return jresult;
40068 }
40069
40070
40071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40072   void * jresult ;
40073   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40074   Dali::Toolkit::Model3dView *arg2 = 0 ;
40075   Dali::Toolkit::Model3dView *result = 0 ;
40076
40077   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40078   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40079   if (!arg2) {
40080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40081     return 0;
40082   }
40083   {
40084     try {
40085       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40086     } CALL_CATCH_EXCEPTION(0);
40087   }
40088
40089   jresult = (void *)result;
40090   return jresult;
40091 }
40092
40093
40094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40095   void * jresult ;
40096   Dali::BaseHandle arg1 ;
40097   Dali::BaseHandle *argp1 ;
40098   Dali::Toolkit::Model3dView result;
40099
40100   argp1 = (Dali::BaseHandle *)jarg1;
40101   if (!argp1) {
40102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40103     return 0;
40104   }
40105   arg1 = *argp1;
40106   {
40107     try {
40108       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40109     } CALL_CATCH_EXCEPTION(0);
40110   }
40111
40112   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40113   return jresult;
40114 }
40115
40116
40117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40118   int jresult ;
40119   int result;
40120
40121   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40122   jresult = (int)result;
40123   return jresult;
40124 }
40125
40126
40127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40128   int jresult ;
40129   int result;
40130
40131   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40132   jresult = (int)result;
40133   return jresult;
40134 }
40135
40136
40137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40138   int jresult ;
40139   int result;
40140
40141   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40142   jresult = (int)result;
40143   return jresult;
40144 }
40145
40146
40147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40148   int jresult ;
40149   int result;
40150
40151   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40152   jresult = (int)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40158   int jresult ;
40159   int result;
40160
40161   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40162   jresult = (int)result;
40163   return jresult;
40164 }
40165
40166
40167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40168   int jresult ;
40169   int result;
40170
40171   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40172   jresult = (int)result;
40173   return jresult;
40174 }
40175
40176
40177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40178   int jresult ;
40179   int result;
40180
40181   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40182   jresult = (int)result;
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40188   int jresult ;
40189   int result;
40190
40191   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40192   jresult = (int)result;
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40198   int jresult ;
40199   int result;
40200
40201   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40202   jresult = (int)result;
40203   return jresult;
40204 }
40205
40206
40207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40208   void * jresult ;
40209   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40210
40211   {
40212     try {
40213       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40214     } CALL_CATCH_EXCEPTION(0);
40215   }
40216
40217   jresult = (void *)result;
40218   return jresult;
40219 }
40220
40221
40222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40223   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40224
40225   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40226   {
40227     try {
40228       delete arg1;
40229     } CALL_CATCH_EXCEPTION();
40230   }
40231
40232 }
40233
40234
40235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40236   void * jresult ;
40237   Dali::Toolkit::ScrollBar *result = 0 ;
40238
40239   {
40240     try {
40241       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40242     } CALL_CATCH_EXCEPTION(0);
40243   }
40244
40245   jresult = (void *)result;
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40251   void * jresult ;
40252   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40253   Dali::Toolkit::ScrollBar *result = 0 ;
40254
40255   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40256   if (!arg1) {
40257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40258     return 0;
40259   }
40260   {
40261     try {
40262       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40263     } CALL_CATCH_EXCEPTION(0);
40264   }
40265
40266   jresult = (void *)result;
40267   return jresult;
40268 }
40269
40270
40271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40272   void * jresult ;
40273   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40274   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40275   Dali::Toolkit::ScrollBar *result = 0 ;
40276
40277   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40278   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40279   if (!arg2) {
40280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40281     return 0;
40282   }
40283   {
40284     try {
40285       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40286     } CALL_CATCH_EXCEPTION(0);
40287   }
40288
40289   jresult = (void *)result;
40290   return jresult;
40291 }
40292
40293
40294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40295   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40296
40297   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40298   {
40299     try {
40300       delete arg1;
40301     } CALL_CATCH_EXCEPTION();
40302   }
40303
40304 }
40305
40306
40307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40308   void * jresult ;
40309   Dali::Toolkit::ScrollBar::Direction arg1 ;
40310   Dali::Toolkit::ScrollBar result;
40311
40312   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40313   {
40314     try {
40315       result = Dali::Toolkit::ScrollBar::New(arg1);
40316     } CALL_CATCH_EXCEPTION(0);
40317   }
40318
40319   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40320   return jresult;
40321 }
40322
40323
40324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40325   void * jresult ;
40326   Dali::Toolkit::ScrollBar result;
40327
40328   {
40329     try {
40330       result = Dali::Toolkit::ScrollBar::New();
40331     } CALL_CATCH_EXCEPTION(0);
40332   }
40333
40334   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40335   return jresult;
40336 }
40337
40338
40339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40340   void * jresult ;
40341   Dali::BaseHandle arg1 ;
40342   Dali::BaseHandle *argp1 ;
40343   Dali::Toolkit::ScrollBar result;
40344
40345   argp1 = (Dali::BaseHandle *)jarg1;
40346   if (!argp1) {
40347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40348     return 0;
40349   }
40350   arg1 = *argp1;
40351   {
40352     try {
40353       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40354     } CALL_CATCH_EXCEPTION(0);
40355   }
40356
40357   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40358   return jresult;
40359 }
40360
40361
40362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40363   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40364   Dali::Handle arg2 ;
40365   Dali::Property::Index arg3 ;
40366   Dali::Property::Index arg4 ;
40367   Dali::Property::Index arg5 ;
40368   Dali::Property::Index arg6 ;
40369   Dali::Handle *argp2 ;
40370
40371   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40372   argp2 = (Dali::Handle *)jarg2;
40373   if (!argp2) {
40374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40375     return ;
40376   }
40377   arg2 = *argp2;
40378   arg3 = (Dali::Property::Index)jarg3;
40379   arg4 = (Dali::Property::Index)jarg4;
40380   arg5 = (Dali::Property::Index)jarg5;
40381   arg6 = (Dali::Property::Index)jarg6;
40382   {
40383     try {
40384       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40385     } CALL_CATCH_EXCEPTION();
40386   }
40387
40388 }
40389
40390
40391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40392   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40393   Dali::Actor arg2 ;
40394   Dali::Actor *argp2 ;
40395
40396   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40397   argp2 = (Dali::Actor *)jarg2;
40398   if (!argp2) {
40399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40400     return ;
40401   }
40402   arg2 = *argp2;
40403   {
40404     try {
40405       (arg1)->SetScrollIndicator(arg2);
40406     } CALL_CATCH_EXCEPTION();
40407   }
40408
40409 }
40410
40411
40412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40413   void * jresult ;
40414   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40415   Dali::Actor result;
40416
40417   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40418   {
40419     try {
40420       result = (arg1)->GetScrollIndicator();
40421     } CALL_CATCH_EXCEPTION(0);
40422   }
40423
40424   jresult = new Dali::Actor((const Dali::Actor &)result);
40425   return jresult;
40426 }
40427
40428
40429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40430   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40431   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40432
40433   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40434   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40435   if (!arg2) {
40436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40437     return ;
40438   }
40439   {
40440     try {
40441       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40442     } CALL_CATCH_EXCEPTION();
40443   }
40444
40445 }
40446
40447
40448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40449   void * jresult ;
40450   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40451
40452   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40453   {
40454     try {
40455       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()));
40456     } CALL_CATCH_EXCEPTION(0);
40457   }
40458   return jresult;
40459 }
40460
40461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40462   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40463   Dali::Toolkit::ScrollBar::Direction arg2 ;
40464
40465   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40466   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40467   {
40468     try {
40469       (arg1)->SetScrollDirection(arg2);
40470     } CALL_CATCH_EXCEPTION();
40471   }
40472
40473 }
40474
40475
40476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40477   int jresult ;
40478   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40479   Dali::Toolkit::ScrollBar::Direction result;
40480
40481   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40482   {
40483     try {
40484       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40485     } CALL_CATCH_EXCEPTION(0);
40486   }
40487
40488   jresult = (int)result;
40489   return jresult;
40490 }
40491
40492
40493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40494   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40495   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40496
40497   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40498   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40499   {
40500     try {
40501       (arg1)->SetIndicatorHeightPolicy(arg2);
40502     } CALL_CATCH_EXCEPTION();
40503   }
40504
40505 }
40506
40507
40508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40509   int jresult ;
40510   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40511   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40512
40513   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40514   {
40515     try {
40516       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40517     } CALL_CATCH_EXCEPTION(0);
40518   }
40519
40520   jresult = (int)result;
40521   return jresult;
40522 }
40523
40524
40525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40526   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40527   float arg2 ;
40528
40529   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40530   arg2 = (float)jarg2;
40531   {
40532     try {
40533       (arg1)->SetIndicatorFixedHeight(arg2);
40534     } CALL_CATCH_EXCEPTION();
40535   }
40536
40537 }
40538
40539
40540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40541   float jresult ;
40542   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40543   float result;
40544
40545   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40546   {
40547     try {
40548       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40549     } CALL_CATCH_EXCEPTION(0);
40550   }
40551
40552   jresult = result;
40553   return jresult;
40554 }
40555
40556
40557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40558   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40559   float arg2 ;
40560
40561   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40562   arg2 = (float)jarg2;
40563   {
40564     try {
40565       (arg1)->SetIndicatorShowDuration(arg2);
40566     } CALL_CATCH_EXCEPTION();
40567   }
40568
40569 }
40570
40571
40572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40573   float jresult ;
40574   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40575   float result;
40576
40577   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40578   {
40579     try {
40580       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40581     } CALL_CATCH_EXCEPTION(0);
40582   }
40583
40584   jresult = result;
40585   return jresult;
40586 }
40587
40588
40589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40590   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40591   float arg2 ;
40592
40593   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40594   arg2 = (float)jarg2;
40595   {
40596     try {
40597       (arg1)->SetIndicatorHideDuration(arg2);
40598     } CALL_CATCH_EXCEPTION();
40599   }
40600
40601 }
40602
40603
40604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40605   float jresult ;
40606   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40607   float result;
40608
40609   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40610   {
40611     try {
40612       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40613     } CALL_CATCH_EXCEPTION(0);
40614   }
40615
40616   jresult = result;
40617   return jresult;
40618 }
40619
40620
40621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40622   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40623
40624   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40625   {
40626     try {
40627       (arg1)->ShowIndicator();
40628     } CALL_CATCH_EXCEPTION();
40629   }
40630
40631 }
40632
40633
40634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40635   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40636
40637   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40638   {
40639     try {
40640       (arg1)->HideIndicator();
40641     } CALL_CATCH_EXCEPTION();
40642   }
40643
40644 }
40645
40646
40647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40648   void * jresult ;
40649   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40650   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40651
40652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40653   {
40654     try {
40655       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40656     } CALL_CATCH_EXCEPTION(0);
40657   }
40658
40659   jresult = (void *)result;
40660   return jresult;
40661 }
40662
40663
40664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40665   void * jresult ;
40666   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40667   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40668
40669   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40670   {
40671     try {
40672       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40673     } CALL_CATCH_EXCEPTION(0);
40674   }
40675
40676   jresult = (void *)result;
40677   return jresult;
40678 }
40679
40680
40681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40682   int jresult ;
40683   int result;
40684
40685   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40686   jresult = (int)result;
40687   return jresult;
40688 }
40689
40690
40691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40692   int jresult ;
40693   int result;
40694
40695   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40696   jresult = (int)result;
40697   return jresult;
40698 }
40699
40700
40701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40702   int jresult ;
40703   int result;
40704
40705   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40706   jresult = (int)result;
40707   return jresult;
40708 }
40709
40710
40711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40712   int jresult ;
40713   int result;
40714
40715   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40716   jresult = (int)result;
40717   return jresult;
40718 }
40719
40720
40721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40722   int jresult ;
40723   int result;
40724
40725   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40726   jresult = (int)result;
40727   return jresult;
40728 }
40729
40730
40731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
40732   int jresult ;
40733   int result;
40734
40735   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
40736   jresult = (int)result;
40737   return jresult;
40738 }
40739
40740
40741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
40742   int jresult ;
40743   int result;
40744
40745   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
40746   jresult = (int)result;
40747   return jresult;
40748 }
40749
40750
40751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
40752   int jresult ;
40753   int result;
40754
40755   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
40756   jresult = (int)result;
40757   return jresult;
40758 }
40759
40760
40761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
40762   int jresult ;
40763   int result;
40764
40765   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
40766   jresult = (int)result;
40767   return jresult;
40768 }
40769
40770
40771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
40772   int jresult ;
40773   int result;
40774
40775   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
40776   jresult = (int)result;
40777   return jresult;
40778 }
40779
40780
40781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
40782   int jresult ;
40783   int result;
40784
40785   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
40786   jresult = (int)result;
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
40792   int jresult ;
40793   int result;
40794
40795   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
40796   jresult = (int)result;
40797   return jresult;
40798 }
40799
40800
40801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
40802   int jresult ;
40803   int result;
40804
40805   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
40806   jresult = (int)result;
40807   return jresult;
40808 }
40809
40810
40811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
40812   int jresult ;
40813   int result;
40814
40815   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
40816   jresult = (int)result;
40817   return jresult;
40818 }
40819
40820
40821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
40822   void * jresult ;
40823   Dali::Toolkit::Scrollable::Property *result = 0 ;
40824
40825   {
40826     try {
40827       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
40828     } CALL_CATCH_EXCEPTION(0);
40829   }
40830
40831   jresult = (void *)result;
40832   return jresult;
40833 }
40834
40835
40836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
40837   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
40838
40839   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
40840   {
40841     try {
40842       delete arg1;
40843     } CALL_CATCH_EXCEPTION();
40844   }
40845
40846 }
40847
40848
40849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
40850   void * jresult ;
40851   Dali::Toolkit::Scrollable *result = 0 ;
40852
40853   {
40854     try {
40855       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
40856     } CALL_CATCH_EXCEPTION(0);
40857   }
40858
40859   jresult = (void *)result;
40860   return jresult;
40861 }
40862
40863
40864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
40865   void * jresult ;
40866   Dali::Toolkit::Scrollable *arg1 = 0 ;
40867   Dali::Toolkit::Scrollable *result = 0 ;
40868
40869   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40870   if (!arg1) {
40871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
40872     return 0;
40873   }
40874   {
40875     try {
40876       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
40877     } CALL_CATCH_EXCEPTION(0);
40878   }
40879
40880   jresult = (void *)result;
40881   return jresult;
40882 }
40883
40884
40885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
40886   void * jresult ;
40887   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40888   Dali::Toolkit::Scrollable *arg2 = 0 ;
40889   Dali::Toolkit::Scrollable *result = 0 ;
40890
40891   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40892   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
40893   if (!arg2) {
40894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
40895     return 0;
40896   }
40897   {
40898     try {
40899       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
40900     } CALL_CATCH_EXCEPTION(0);
40901   }
40902
40903   jresult = (void *)result;
40904   return jresult;
40905 }
40906
40907
40908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
40909   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40910
40911   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40912   {
40913     try {
40914       delete arg1;
40915     } CALL_CATCH_EXCEPTION();
40916   }
40917
40918 }
40919
40920
40921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
40922   void * jresult ;
40923   Dali::BaseHandle arg1 ;
40924   Dali::BaseHandle *argp1 ;
40925   Dali::Toolkit::Scrollable result;
40926
40927   argp1 = (Dali::BaseHandle *)jarg1;
40928   if (!argp1) {
40929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40930     return 0;
40931   }
40932   arg1 = *argp1;
40933   {
40934     try {
40935       result = Dali::Toolkit::Scrollable::DownCast(arg1);
40936     } CALL_CATCH_EXCEPTION(0);
40937   }
40938
40939   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
40945   unsigned int jresult ;
40946   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40947   bool result;
40948
40949   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40950   {
40951     try {
40952       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
40953     } CALL_CATCH_EXCEPTION(0);
40954   }
40955
40956   jresult = result;
40957   return jresult;
40958 }
40959
40960
40961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
40962   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40963   bool arg2 ;
40964
40965   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40966   arg2 = jarg2 ? true : false;
40967   {
40968     try {
40969       (arg1)->SetOvershootEnabled(arg2);
40970     } CALL_CATCH_EXCEPTION();
40971   }
40972
40973 }
40974
40975
40976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
40977   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40978   Dali::Vector4 *arg2 = 0 ;
40979
40980   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
40981   arg2 = (Dali::Vector4 *)jarg2;
40982   if (!arg2) {
40983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
40984     return ;
40985   }
40986   {
40987     try {
40988       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
40989     } CALL_CATCH_EXCEPTION();
40990   }
40991
40992 }
40993
40994
40995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
40996   void * jresult ;
40997   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
40998   Dali::Vector4 result;
40999
41000   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41001   {
41002     try {
41003       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41004     } CALL_CATCH_EXCEPTION(0);
41005   }
41006
41007   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41008   return jresult;
41009 }
41010
41011
41012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41013   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41014   float arg2 ;
41015
41016   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41017   arg2 = (float)jarg2;
41018   {
41019     try {
41020       (arg1)->SetOvershootAnimationSpeed(arg2);
41021     } CALL_CATCH_EXCEPTION();
41022   }
41023
41024 }
41025
41026
41027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41028   float jresult ;
41029   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41030   float result;
41031
41032   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41033   {
41034     try {
41035       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41036     } CALL_CATCH_EXCEPTION(0);
41037   }
41038
41039   jresult = result;
41040   return jresult;
41041 }
41042
41043
41044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41045   void * jresult ;
41046   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41047   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41048
41049   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41050   {
41051     try {
41052       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41053     } CALL_CATCH_EXCEPTION(0);
41054   }
41055
41056   jresult = (void *)result;
41057   return jresult;
41058 }
41059
41060
41061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41062   void * jresult ;
41063   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41064   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41065
41066   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41067   {
41068     try {
41069       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41070     } CALL_CATCH_EXCEPTION(0);
41071   }
41072
41073   jresult = (void *)result;
41074   return jresult;
41075 }
41076
41077
41078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41079   void * jresult ;
41080   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41081   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41082
41083   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41084   {
41085     try {
41086       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41087     } CALL_CATCH_EXCEPTION(0);
41088   }
41089
41090   jresult = (void *)result;
41091   return jresult;
41092 }
41093
41094
41095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41096   unsigned int jresult ;
41097   Dali::Toolkit::ControlOrientation::Type arg1 ;
41098   bool result;
41099
41100   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41101   {
41102     try {
41103       result = (bool)Dali::Toolkit::IsVertical(arg1);
41104     } CALL_CATCH_EXCEPTION(0);
41105   }
41106
41107   jresult = result;
41108   return jresult;
41109 }
41110
41111
41112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41113   unsigned int jresult ;
41114   Dali::Toolkit::ControlOrientation::Type arg1 ;
41115   bool result;
41116
41117   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41118   {
41119     try {
41120       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41121     } CALL_CATCH_EXCEPTION(0);
41122   }
41123
41124   jresult = result;
41125   return jresult;
41126 }
41127
41128
41129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41130   void * jresult ;
41131   unsigned int arg1 ;
41132   unsigned int arg2 ;
41133   Dali::Toolkit::ItemRange *result = 0 ;
41134
41135   arg1 = (unsigned int)jarg1;
41136   arg2 = (unsigned int)jarg2;
41137   {
41138     try {
41139       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41140     } CALL_CATCH_EXCEPTION(0);
41141   }
41142
41143   jresult = (void *)result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41149   void * jresult ;
41150   Dali::Toolkit::ItemRange *arg1 = 0 ;
41151   Dali::Toolkit::ItemRange *result = 0 ;
41152
41153   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41154   if (!arg1) {
41155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41156     return 0;
41157   }
41158   {
41159     try {
41160       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41161     } CALL_CATCH_EXCEPTION(0);
41162   }
41163
41164   jresult = (void *)result;
41165   return jresult;
41166 }
41167
41168
41169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41170   void * jresult ;
41171   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41172   Dali::Toolkit::ItemRange *arg2 = 0 ;
41173   Dali::Toolkit::ItemRange *result = 0 ;
41174
41175   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41176   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41177   if (!arg2) {
41178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41179     return 0;
41180   }
41181   {
41182     try {
41183       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41184     } CALL_CATCH_EXCEPTION(0);
41185   }
41186
41187   jresult = (void *)result;
41188   return jresult;
41189 }
41190
41191
41192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41193   unsigned int jresult ;
41194   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41195   unsigned int arg2 ;
41196   bool result;
41197
41198   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41199   arg2 = (unsigned int)jarg2;
41200   {
41201     try {
41202       result = (bool)(arg1)->Within(arg2);
41203     } CALL_CATCH_EXCEPTION(0);
41204   }
41205
41206   jresult = result;
41207   return jresult;
41208 }
41209
41210
41211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41212   void * jresult ;
41213   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41214   Dali::Toolkit::ItemRange *arg2 = 0 ;
41215   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41216
41217   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41218   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41219   if (!arg2) {
41220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41221     return 0;
41222   }
41223   {
41224     try {
41225       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41226     } CALL_CATCH_EXCEPTION(0);
41227   }
41228
41229   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41230   return jresult;
41231 }
41232
41233
41234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41235   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41236   unsigned int arg2 ;
41237
41238   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41239   arg2 = (unsigned int)jarg2;
41240   if (arg1) (arg1)->begin = arg2;
41241 }
41242
41243
41244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41245   unsigned int jresult ;
41246   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41247   unsigned int result;
41248
41249   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41250   result = (unsigned int) ((arg1)->begin);
41251   jresult = result;
41252   return jresult;
41253 }
41254
41255
41256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41257   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41258   unsigned int arg2 ;
41259
41260   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41261   arg2 = (unsigned int)jarg2;
41262   if (arg1) (arg1)->end = arg2;
41263 }
41264
41265
41266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41267   unsigned int jresult ;
41268   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41269   unsigned int result;
41270
41271   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41272   result = (unsigned int) ((arg1)->end);
41273   jresult = result;
41274   return jresult;
41275 }
41276
41277
41278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41279   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41280
41281   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41282   {
41283     try {
41284       delete arg1;
41285     } CALL_CATCH_EXCEPTION();
41286   }
41287
41288 }
41289
41290
41291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41292   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41293
41294   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41295   {
41296     try {
41297       delete arg1;
41298     } CALL_CATCH_EXCEPTION();
41299   }
41300
41301 }
41302
41303
41304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41305   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41306   Dali::Toolkit::ControlOrientation::Type arg2 ;
41307
41308   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41309   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41310   {
41311     try {
41312       (arg1)->SetOrientation(arg2);
41313     } CALL_CATCH_EXCEPTION();
41314   }
41315
41316 }
41317
41318
41319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41320   int jresult ;
41321   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41322   Dali::Toolkit::ControlOrientation::Type result;
41323
41324   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41325   {
41326     try {
41327       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41328     } CALL_CATCH_EXCEPTION(0);
41329   }
41330
41331   jresult = (int)result;
41332   return jresult;
41333 }
41334
41335
41336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41337   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41338   Dali::Property::Map *arg2 = 0 ;
41339
41340   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41341   arg2 = (Dali::Property::Map *)jarg2;
41342   if (!arg2) {
41343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41344     return ;
41345   }
41346   {
41347     try {
41348       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41349     } CALL_CATCH_EXCEPTION();
41350   }
41351
41352 }
41353
41354
41355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41356   void * jresult ;
41357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41358   Dali::Property::Map result;
41359
41360   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41361   {
41362     try {
41363       result = (arg1)->GetLayoutProperties();
41364     } CALL_CATCH_EXCEPTION(0);
41365   }
41366
41367   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41373   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41374   unsigned int arg2 ;
41375   Dali::Vector3 *arg3 = 0 ;
41376   Dali::Vector3 *arg4 = 0 ;
41377
41378   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41379   arg2 = (unsigned int)jarg2;
41380   arg3 = (Dali::Vector3 *)jarg3;
41381   if (!arg3) {
41382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41383     return ;
41384   }
41385   arg4 = (Dali::Vector3 *)jarg4;
41386   if (!arg4) {
41387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41388     return ;
41389   }
41390   {
41391     try {
41392       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41393     } CALL_CATCH_EXCEPTION();
41394   }
41395
41396 }
41397
41398
41399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41400   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41401   Dali::Vector3 *arg2 = 0 ;
41402
41403   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41404   arg2 = (Dali::Vector3 *)jarg2;
41405   if (!arg2) {
41406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41407     return ;
41408   }
41409   {
41410     try {
41411       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41412     } CALL_CATCH_EXCEPTION();
41413   }
41414
41415 }
41416
41417
41418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41419   float jresult ;
41420   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41421   unsigned int arg2 ;
41422   Dali::Vector3 arg3 ;
41423   Dali::Vector3 *argp3 ;
41424   float result;
41425
41426   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41427   arg2 = (unsigned int)jarg2;
41428   argp3 = (Dali::Vector3 *)jarg3;
41429   if (!argp3) {
41430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41431     return 0;
41432   }
41433   arg3 = *argp3;
41434   {
41435     try {
41436       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41437     } CALL_CATCH_EXCEPTION(0);
41438   }
41439
41440   jresult = result;
41441   return jresult;
41442 }
41443
41444
41445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41446   float jresult ;
41447   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41448   float arg2 ;
41449   float result;
41450
41451   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41452   arg2 = (float)jarg2;
41453   {
41454     try {
41455       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41456     } CALL_CATCH_EXCEPTION(0);
41457   }
41458
41459   jresult = result;
41460   return jresult;
41461 }
41462
41463
41464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41465   float jresult ;
41466   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41467   unsigned int arg2 ;
41468   float result;
41469
41470   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41471   arg2 = (unsigned int)jarg2;
41472   {
41473     try {
41474       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41475     } CALL_CATCH_EXCEPTION(0);
41476   }
41477
41478   jresult = result;
41479   return jresult;
41480 }
41481
41482
41483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41484   void * jresult ;
41485   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41486   float arg2 ;
41487   Dali::Vector3 arg3 ;
41488   Dali::Vector3 *argp3 ;
41489   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41490
41491   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41492   arg2 = (float)jarg2;
41493   argp3 = (Dali::Vector3 *)jarg3;
41494   if (!argp3) {
41495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41496     return 0;
41497   }
41498   arg3 = *argp3;
41499   {
41500     try {
41501       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41502     } CALL_CATCH_EXCEPTION(0);
41503   }
41504
41505   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41511   float jresult ;
41512   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41513   int arg2 ;
41514   float arg3 ;
41515   Dali::Vector3 *arg4 = 0 ;
41516   float result;
41517
41518   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41519   arg2 = (int)jarg2;
41520   arg3 = (float)jarg3;
41521   arg4 = (Dali::Vector3 *)jarg4;
41522   if (!arg4) {
41523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41524     return 0;
41525   }
41526   {
41527     try {
41528       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41529     } CALL_CATCH_EXCEPTION(0);
41530   }
41531
41532   jresult = result;
41533   return jresult;
41534 }
41535
41536
41537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41538   unsigned int jresult ;
41539   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41540   Dali::Vector3 arg2 ;
41541   Dali::Vector3 *argp2 ;
41542   unsigned int result;
41543
41544   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41545   argp2 = (Dali::Vector3 *)jarg2;
41546   if (!argp2) {
41547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41548     return 0;
41549   }
41550   arg2 = *argp2;
41551   {
41552     try {
41553       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41554     } CALL_CATCH_EXCEPTION(0);
41555   }
41556
41557   jresult = result;
41558   return jresult;
41559 }
41560
41561
41562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41563   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41564   unsigned int arg2 ;
41565   Dali::Vector3 *arg3 = 0 ;
41566   Dali::Vector3 *arg4 = 0 ;
41567
41568   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41569   arg2 = (unsigned int)jarg2;
41570   arg3 = (Dali::Vector3 *)jarg3;
41571   if (!arg3) {
41572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41573     return ;
41574   }
41575   arg4 = (Dali::Vector3 *)jarg4;
41576   if (!arg4) {
41577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41578     return ;
41579   }
41580   {
41581     try {
41582       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41583     } CALL_CATCH_EXCEPTION();
41584   }
41585
41586 }
41587
41588
41589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41590   void * jresult ;
41591   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41592   Dali::Degree result;
41593
41594   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41595   {
41596     try {
41597       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41598     } CALL_CATCH_EXCEPTION(0);
41599   }
41600
41601   jresult = new Dali::Degree((const Dali::Degree &)result);
41602   return jresult;
41603 }
41604
41605
41606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41607   float jresult ;
41608   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41609   float result;
41610
41611   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41612   {
41613     try {
41614       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41615     } CALL_CATCH_EXCEPTION(0);
41616   }
41617
41618   jresult = result;
41619   return jresult;
41620 }
41621
41622
41623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
41624   float jresult ;
41625   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41626   float result;
41627
41628   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41629   {
41630     try {
41631       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
41632     } CALL_CATCH_EXCEPTION(0);
41633   }
41634
41635   jresult = result;
41636   return jresult;
41637 }
41638
41639
41640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
41641   float jresult ;
41642   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41643   float result;
41644
41645   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41646   {
41647     try {
41648       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
41649     } CALL_CATCH_EXCEPTION(0);
41650   }
41651
41652   jresult = result;
41653   return jresult;
41654 }
41655
41656
41657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41658   int jresult ;
41659   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41660   int arg2 ;
41661   int arg3 ;
41662   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41663   bool arg5 ;
41664   int result;
41665
41666   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41667   arg2 = (int)jarg2;
41668   arg3 = (int)jarg3;
41669   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41670   arg5 = jarg5 ? true : false;
41671   {
41672     try {
41673       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41674     } CALL_CATCH_EXCEPTION(0);
41675   }
41676
41677   jresult = result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41683   float jresult ;
41684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41685   float result;
41686
41687   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41688   {
41689     try {
41690       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41691     } CALL_CATCH_EXCEPTION(0);
41692   }
41693
41694   jresult = result;
41695   return jresult;
41696 }
41697
41698
41699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41700   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41701   Dali::Actor *arg2 = 0 ;
41702   int arg3 ;
41703   Dali::Vector3 *arg4 = 0 ;
41704   Dali::Actor *arg5 = 0 ;
41705
41706   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41707   arg2 = (Dali::Actor *)jarg2;
41708   if (!arg2) {
41709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41710     return ;
41711   }
41712   arg3 = (int)jarg3;
41713   arg4 = (Dali::Vector3 *)jarg4;
41714   if (!arg4) {
41715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41716     return ;
41717   }
41718   arg5 = (Dali::Actor *)jarg5;
41719   if (!arg5) {
41720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41721     return ;
41722   }
41723   {
41724     try {
41725       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41726     } CALL_CATCH_EXCEPTION();
41727   }
41728
41729 }
41730
41731
41732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41733   void * jresult ;
41734   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41735   int arg2 ;
41736   float arg3 ;
41737   Dali::Vector3 *arg4 = 0 ;
41738   Dali::Vector3 result;
41739
41740   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41741   arg2 = (int)jarg2;
41742   arg3 = (float)jarg3;
41743   arg4 = (Dali::Vector3 *)jarg4;
41744   if (!arg4) {
41745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41746     return 0;
41747   }
41748   {
41749     try {
41750       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41751     } CALL_CATCH_EXCEPTION(0);
41752   }
41753
41754   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
41755   return jresult;
41756 }
41757
41758
41759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
41760   void * jresult ;
41761   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
41762   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
41763
41764   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
41765   {
41766     try {
41767       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
41768     } CALL_CATCH_EXCEPTION(0);
41769   }
41770
41771   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
41777   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41778
41779   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41780   {
41781     try {
41782       delete arg1;
41783     } CALL_CATCH_EXCEPTION();
41784   }
41785
41786 }
41787
41788
41789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
41790   unsigned int jresult ;
41791   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41792   unsigned int result;
41793
41794   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41795   {
41796     try {
41797       result = (unsigned int)(arg1)->GetNumberOfItems();
41798     } CALL_CATCH_EXCEPTION(0);
41799   }
41800
41801   jresult = result;
41802   return jresult;
41803 }
41804
41805
41806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
41807   void * jresult ;
41808   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41809   unsigned int arg2 ;
41810   Dali::Actor result;
41811
41812   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41813   arg2 = (unsigned int)jarg2;
41814   {
41815     try {
41816       result = (arg1)->NewItem(arg2);
41817     } CALL_CATCH_EXCEPTION(0);
41818   }
41819
41820   jresult = new Dali::Actor((const Dali::Actor &)result);
41821   return jresult;
41822 }
41823
41824
41825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
41826   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41827   unsigned int arg2 ;
41828   Dali::Actor arg3 ;
41829   Dali::Actor *argp3 ;
41830
41831   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41832   arg2 = (unsigned int)jarg2;
41833   argp3 = (Dali::Actor *)jarg3;
41834   if (!argp3) {
41835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41836     return ;
41837   }
41838   arg3 = *argp3;
41839   {
41840     try {
41841       (arg1)->ItemReleased(arg2,arg3);
41842     } CALL_CATCH_EXCEPTION();
41843   }
41844
41845 }
41846
41847
41848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
41849   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41850   unsigned int arg2 ;
41851   Dali::Actor arg3 ;
41852   Dali::Actor *argp3 ;
41853
41854   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41855   arg2 = (unsigned int)jarg2;
41856   argp3 = (Dali::Actor *)jarg3;
41857   if (!argp3) {
41858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41859     return ;
41860   }
41861   arg3 = *argp3;
41862   {
41863     try {
41864       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
41865     } CALL_CATCH_EXCEPTION();
41866   }
41867
41868 }
41869
41870
41871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
41872   void * jresult ;
41873   Dali::Toolkit::ItemFactory *result = 0 ;
41874
41875   {
41876     try {
41877       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
41878     } CALL_CATCH_EXCEPTION(0);
41879   }
41880
41881   jresult = (void *)result;
41882   return jresult;
41883 }
41884
41885
41886 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) {
41887   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
41888   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
41889   if (director) {
41890     director->swig_connect_director(callback0, callback1, callback2);
41891   }
41892 }
41893
41894
41895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
41896   int jresult ;
41897   int result;
41898
41899   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
41900   jresult = (int)result;
41901   return jresult;
41902 }
41903
41904
41905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
41906   int jresult ;
41907   int result;
41908
41909   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
41910   jresult = (int)result;
41911   return jresult;
41912 }
41913
41914
41915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
41916   int jresult ;
41917   int result;
41918
41919   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
41920   jresult = (int)result;
41921   return jresult;
41922 }
41923
41924
41925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
41926   int jresult ;
41927   int result;
41928
41929   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
41930   jresult = (int)result;
41931   return jresult;
41932 }
41933
41934
41935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
41936   int jresult ;
41937   int result;
41938
41939   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
41940   jresult = (int)result;
41941   return jresult;
41942 }
41943
41944
41945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
41946   int jresult ;
41947   int result;
41948
41949   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
41950   jresult = (int)result;
41951   return jresult;
41952 }
41953
41954
41955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
41956   int jresult ;
41957   int result;
41958
41959   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
41960   jresult = (int)result;
41961   return jresult;
41962 }
41963
41964
41965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
41966   int jresult ;
41967   int result;
41968
41969   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
41970   jresult = (int)result;
41971   return jresult;
41972 }
41973
41974
41975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
41976   int jresult ;
41977   int result;
41978
41979   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
41980   jresult = (int)result;
41981   return jresult;
41982 }
41983
41984
41985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
41986   int jresult ;
41987   int result;
41988
41989   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
41990   jresult = (int)result;
41991   return jresult;
41992 }
41993
41994
41995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
41996   int jresult ;
41997   int result;
41998
41999   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42000   jresult = (int)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42006   void * jresult ;
42007   Dali::Toolkit::ItemView::Property *result = 0 ;
42008
42009   {
42010     try {
42011       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42012     } CALL_CATCH_EXCEPTION(0);
42013   }
42014
42015   jresult = (void *)result;
42016   return jresult;
42017 }
42018
42019
42020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42021   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42022
42023   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42024   {
42025     try {
42026       delete arg1;
42027     } CALL_CATCH_EXCEPTION();
42028   }
42029
42030 }
42031
42032
42033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42034   void * jresult ;
42035   Dali::Toolkit::ItemView *result = 0 ;
42036
42037   {
42038     try {
42039       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42040     } CALL_CATCH_EXCEPTION(0);
42041   }
42042
42043   jresult = (void *)result;
42044   return jresult;
42045 }
42046
42047
42048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42049   void * jresult ;
42050   Dali::Toolkit::ItemView *arg1 = 0 ;
42051   Dali::Toolkit::ItemView *result = 0 ;
42052
42053   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42054   if (!arg1) {
42055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42056     return 0;
42057   }
42058   {
42059     try {
42060       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42061     } CALL_CATCH_EXCEPTION(0);
42062   }
42063
42064   jresult = (void *)result;
42065   return jresult;
42066 }
42067
42068
42069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42070   void * jresult ;
42071   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42072   Dali::Toolkit::ItemView *arg2 = 0 ;
42073   Dali::Toolkit::ItemView *result = 0 ;
42074
42075   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42076   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42077   if (!arg2) {
42078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42079     return 0;
42080   }
42081   {
42082     try {
42083       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42084     } CALL_CATCH_EXCEPTION(0);
42085   }
42086
42087   jresult = (void *)result;
42088   return jresult;
42089 }
42090
42091
42092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42093   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42094
42095   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42096   {
42097     try {
42098       delete arg1;
42099     } CALL_CATCH_EXCEPTION();
42100   }
42101
42102 }
42103
42104
42105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42106   void * jresult ;
42107   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42108   Dali::Toolkit::ItemView result;
42109
42110   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42111   if (!arg1) {
42112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42113     return 0;
42114   }
42115   {
42116     try {
42117       result = Dali::Toolkit::ItemView::New(*arg1);
42118     } CALL_CATCH_EXCEPTION(0);
42119   }
42120
42121   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42122   return jresult;
42123 }
42124
42125
42126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42127   void * jresult ;
42128   Dali::BaseHandle arg1 ;
42129   Dali::BaseHandle *argp1 ;
42130   Dali::Toolkit::ItemView result;
42131
42132   argp1 = (Dali::BaseHandle *)jarg1;
42133   if (!argp1) {
42134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42135     return 0;
42136   }
42137   arg1 = *argp1;
42138   {
42139     try {
42140       result = Dali::Toolkit::ItemView::DownCast(arg1);
42141     } CALL_CATCH_EXCEPTION(0);
42142   }
42143
42144   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42145   return jresult;
42146 }
42147
42148
42149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42150   unsigned int jresult ;
42151   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42152   unsigned int result;
42153
42154   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42155   {
42156     try {
42157       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42158     } CALL_CATCH_EXCEPTION(0);
42159   }
42160
42161   jresult = result;
42162   return jresult;
42163 }
42164
42165
42166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42168   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42169
42170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42171   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42172   if (!arg2) {
42173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42174     return ;
42175   }
42176   {
42177     try {
42178       (arg1)->AddLayout(*arg2);
42179     } CALL_CATCH_EXCEPTION();
42180   }
42181
42182 }
42183
42184
42185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42186   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42187   unsigned int arg2 ;
42188
42189   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42190   arg2 = (unsigned int)jarg2;
42191   {
42192     try {
42193       (arg1)->RemoveLayout(arg2);
42194     } CALL_CATCH_EXCEPTION();
42195   }
42196
42197 }
42198
42199
42200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42201   void * jresult ;
42202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42203   unsigned int arg2 ;
42204   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42205
42206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42207   arg2 = (unsigned int)jarg2;
42208   {
42209     try {
42210       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42211     } CALL_CATCH_EXCEPTION(0);
42212   }
42213
42214   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42215   return jresult;
42216 }
42217
42218
42219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42220   void * jresult ;
42221   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42222   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42223
42224   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42225   {
42226     try {
42227       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42228     } CALL_CATCH_EXCEPTION(0);
42229   }
42230
42231   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42232   return jresult;
42233 }
42234
42235
42236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42237   float jresult ;
42238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42239   Dali::Toolkit::ItemId arg2 ;
42240   float result;
42241
42242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42243   arg2 = (Dali::Toolkit::ItemId)jarg2;
42244   {
42245     try {
42246       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42247     } CALL_CATCH_EXCEPTION(0);
42248   }
42249
42250   jresult = result;
42251   return jresult;
42252 }
42253
42254
42255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42256   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42257   unsigned int arg2 ;
42258   Dali::Vector3 arg3 ;
42259   float arg4 ;
42260   Dali::Vector3 *argp3 ;
42261
42262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42263   arg2 = (unsigned int)jarg2;
42264   argp3 = (Dali::Vector3 *)jarg3;
42265   if (!argp3) {
42266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42267     return ;
42268   }
42269   arg3 = *argp3;
42270   arg4 = (float)jarg4;
42271   {
42272     try {
42273       (arg1)->ActivateLayout(arg2,arg3,arg4);
42274     } CALL_CATCH_EXCEPTION();
42275   }
42276
42277 }
42278
42279
42280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42281   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42282
42283   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42284   {
42285     try {
42286       (arg1)->DeactivateCurrentLayout();
42287     } CALL_CATCH_EXCEPTION();
42288   }
42289
42290 }
42291
42292
42293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42294   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42295   float arg2 ;
42296
42297   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42298   arg2 = (float)jarg2;
42299   {
42300     try {
42301       (arg1)->SetMinimumSwipeSpeed(arg2);
42302     } CALL_CATCH_EXCEPTION();
42303   }
42304
42305 }
42306
42307
42308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42309   float jresult ;
42310   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42311   float result;
42312
42313   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42314   {
42315     try {
42316       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42317     } CALL_CATCH_EXCEPTION(0);
42318   }
42319
42320   jresult = result;
42321   return jresult;
42322 }
42323
42324
42325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42326   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42327   float arg2 ;
42328
42329   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42330   arg2 = (float)jarg2;
42331   {
42332     try {
42333       (arg1)->SetMinimumSwipeDistance(arg2);
42334     } CALL_CATCH_EXCEPTION();
42335   }
42336
42337 }
42338
42339
42340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42341   float jresult ;
42342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42343   float result;
42344
42345   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42346   {
42347     try {
42348       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42349     } CALL_CATCH_EXCEPTION(0);
42350   }
42351
42352   jresult = result;
42353   return jresult;
42354 }
42355
42356
42357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42358   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42359   float arg2 ;
42360
42361   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42362   arg2 = (float)jarg2;
42363   {
42364     try {
42365       (arg1)->SetWheelScrollDistanceStep(arg2);
42366     } CALL_CATCH_EXCEPTION();
42367   }
42368
42369 }
42370
42371
42372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42373   float jresult ;
42374   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42375   float result;
42376
42377   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42378   {
42379     try {
42380       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42381     } CALL_CATCH_EXCEPTION(0);
42382   }
42383
42384   jresult = result;
42385   return jresult;
42386 }
42387
42388
42389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42390   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42391   bool arg2 ;
42392
42393   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42394   arg2 = jarg2 ? true : false;
42395   {
42396     try {
42397       (arg1)->SetAnchoring(arg2);
42398     } CALL_CATCH_EXCEPTION();
42399   }
42400
42401 }
42402
42403 //// ========================= end of part 3 =============================
42404
42405 //// ========================== start part 4 ===============================
42406
42407
42408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42409   unsigned int jresult ;
42410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42411   bool result;
42412
42413   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42414   {
42415     try {
42416       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42417     } CALL_CATCH_EXCEPTION(0);
42418   }
42419
42420   jresult = result;
42421   return jresult;
42422 }
42423
42424
42425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42426   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42427   float arg2 ;
42428
42429   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42430   arg2 = (float)jarg2;
42431   {
42432     try {
42433       (arg1)->SetAnchoringDuration(arg2);
42434     } CALL_CATCH_EXCEPTION();
42435   }
42436
42437 }
42438
42439
42440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42441   float jresult ;
42442   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42443   float result;
42444
42445   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42446   {
42447     try {
42448       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42449     } CALL_CATCH_EXCEPTION(0);
42450   }
42451
42452   jresult = result;
42453   return jresult;
42454 }
42455
42456
42457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42458   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42459   Dali::Toolkit::ItemId arg2 ;
42460   float arg3 ;
42461
42462   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42463   arg2 = (Dali::Toolkit::ItemId)jarg2;
42464   arg3 = (float)jarg3;
42465   {
42466     try {
42467       (arg1)->ScrollToItem(arg2,arg3);
42468     } CALL_CATCH_EXCEPTION();
42469   }
42470
42471 }
42472
42473
42474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42475   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42476   float arg2 ;
42477
42478   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42479   arg2 = (float)jarg2;
42480   {
42481     try {
42482       (arg1)->SetRefreshInterval(arg2);
42483     } CALL_CATCH_EXCEPTION();
42484   }
42485
42486 }
42487
42488
42489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42490   float jresult ;
42491   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42492   float result;
42493
42494   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42495   {
42496     try {
42497       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42498     } CALL_CATCH_EXCEPTION(0);
42499   }
42500
42501   jresult = result;
42502   return jresult;
42503 }
42504
42505
42506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42507   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42508
42509   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42510   {
42511     try {
42512       (arg1)->Refresh();
42513     } CALL_CATCH_EXCEPTION();
42514   }
42515
42516 }
42517
42518
42519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42520   void * jresult ;
42521   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42522   Dali::Toolkit::ItemId arg2 ;
42523   Dali::Actor result;
42524
42525   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42526   arg2 = (Dali::Toolkit::ItemId)jarg2;
42527   {
42528     try {
42529       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42530     } CALL_CATCH_EXCEPTION(0);
42531   }
42532
42533   jresult = new Dali::Actor((const Dali::Actor &)result);
42534   return jresult;
42535 }
42536
42537
42538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42539   unsigned int jresult ;
42540   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42541   Dali::Actor arg2 ;
42542   Dali::Actor *argp2 ;
42543   Dali::Toolkit::ItemId result;
42544
42545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42546   argp2 = (Dali::Actor *)jarg2;
42547   if (!argp2) {
42548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42549     return 0;
42550   }
42551   arg2 = *argp2;
42552   {
42553     try {
42554       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42555     } CALL_CATCH_EXCEPTION(0);
42556   }
42557
42558   jresult = result;
42559   return jresult;
42560 }
42561
42562
42563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42564   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42565   Dali::Toolkit::Item arg2 ;
42566   float arg3 ;
42567   Dali::Toolkit::Item *argp2 ;
42568
42569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42570   argp2 = (Dali::Toolkit::Item *)jarg2;
42571   if (!argp2) {
42572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42573     return ;
42574   }
42575   arg2 = *argp2;
42576   arg3 = (float)jarg3;
42577   {
42578     try {
42579       (arg1)->InsertItem(arg2,arg3);
42580     } CALL_CATCH_EXCEPTION();
42581   }
42582
42583 }
42584
42585
42586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42588   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42589   float arg3 ;
42590
42591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42592   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42593   if (!arg2) {
42594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42595     return ;
42596   }
42597   arg3 = (float)jarg3;
42598   {
42599     try {
42600       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42601     } CALL_CATCH_EXCEPTION();
42602   }
42603
42604 }
42605
42606
42607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42608   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42609   Dali::Toolkit::ItemId arg2 ;
42610   float arg3 ;
42611
42612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42613   arg2 = (Dali::Toolkit::ItemId)jarg2;
42614   arg3 = (float)jarg3;
42615   {
42616     try {
42617       (arg1)->RemoveItem(arg2,arg3);
42618     } CALL_CATCH_EXCEPTION();
42619   }
42620
42621 }
42622
42623
42624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42625   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42626   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42627   float arg3 ;
42628
42629   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42630   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42631   if (!arg2) {
42632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42633     return ;
42634   }
42635   arg3 = (float)jarg3;
42636   {
42637     try {
42638       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42639     } CALL_CATCH_EXCEPTION();
42640   }
42641
42642 }
42643
42644
42645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42646   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42647   Dali::Toolkit::Item arg2 ;
42648   float arg3 ;
42649   Dali::Toolkit::Item *argp2 ;
42650
42651   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42652   argp2 = (Dali::Toolkit::Item *)jarg2;
42653   if (!argp2) {
42654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42655     return ;
42656   }
42657   arg2 = *argp2;
42658   arg3 = (float)jarg3;
42659   {
42660     try {
42661       (arg1)->ReplaceItem(arg2,arg3);
42662     } CALL_CATCH_EXCEPTION();
42663   }
42664
42665 }
42666
42667
42668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42670   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42671   float arg3 ;
42672
42673   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42674   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42675   if (!arg2) {
42676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42677     return ;
42678   }
42679   arg3 = (float)jarg3;
42680   {
42681     try {
42682       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42683     } CALL_CATCH_EXCEPTION();
42684   }
42685
42686 }
42687
42688
42689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42691   Dali::Vector3 *arg2 = 0 ;
42692
42693   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42694   arg2 = (Dali::Vector3 *)jarg2;
42695   if (!arg2) {
42696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42697     return ;
42698   }
42699   {
42700     try {
42701       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42702     } CALL_CATCH_EXCEPTION();
42703   }
42704
42705 }
42706
42707
42708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42709   void * jresult ;
42710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42711   Dali::Vector3 result;
42712
42713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42714   {
42715     try {
42716       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42717     } CALL_CATCH_EXCEPTION(0);
42718   }
42719
42720   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42721   return jresult;
42722 }
42723
42724
42725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(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)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
42738     } CALL_CATCH_EXCEPTION();
42739   }
42740
42741 }
42742
42743
42744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(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)->GetItemsAnchorPoint();
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_GetItemsRange(void * jarg1, void * jarg2) {
42762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42763   Dali::Toolkit::ItemRange *arg2 = 0 ;
42764
42765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42766   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42767   if (!arg2) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
42769     return ;
42770   }
42771   {
42772     try {
42773       (arg1)->GetItemsRange(*arg2);
42774     } CALL_CATCH_EXCEPTION();
42775   }
42776
42777 }
42778
42779
42780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
42781   void * jresult ;
42782   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42783   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
42784
42785   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42786   {
42787     try {
42788       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
42789     } CALL_CATCH_EXCEPTION(0);
42790   }
42791
42792   jresult = (void *)result;
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
42798   Dali::Vector3 *arg1 = 0 ;
42799   PropertyInputContainer *arg2 = 0 ;
42800
42801   arg1 = (Dali::Vector3 *)jarg1;
42802   if (!arg1) {
42803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42804     return ;
42805   }
42806   arg2 = (PropertyInputContainer *)jarg2;
42807   if (!arg2) {
42808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
42809     return ;
42810   }
42811   {
42812     try {
42813       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
42814     } CALL_CATCH_EXCEPTION();
42815   }
42816
42817 }
42818
42819
42820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
42821   Dali::Vector3 *arg1 = 0 ;
42822   PropertyInputContainer *arg2 = 0 ;
42823
42824   arg1 = (Dali::Vector3 *)jarg1;
42825   if (!arg1) {
42826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42827     return ;
42828   }
42829   arg2 = (PropertyInputContainer *)jarg2;
42830   if (!arg2) {
42831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
42832     return ;
42833   }
42834   {
42835     try {
42836       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
42837     } CALL_CATCH_EXCEPTION();
42838   }
42839
42840 }
42841
42842
42843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
42844   void * jresult ;
42845   Dali::Toolkit::ScrollViewEffect *result = 0 ;
42846
42847   {
42848     try {
42849       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
42850     } CALL_CATCH_EXCEPTION(0);
42851   }
42852
42853   jresult = (void *)result;
42854   return jresult;
42855 }
42856
42857
42858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
42859   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
42860
42861   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
42862   {
42863     try {
42864       delete arg1;
42865     } CALL_CATCH_EXCEPTION();
42866   }
42867
42868 }
42869
42870
42871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
42872   void * jresult ;
42873   Dali::Path arg1 ;
42874   Dali::Vector3 *arg2 = 0 ;
42875   Dali::Property::Index arg3 ;
42876   Dali::Vector3 *arg4 = 0 ;
42877   unsigned int arg5 ;
42878   Dali::Path *argp1 ;
42879   Dali::Toolkit::ScrollViewPagePathEffect result;
42880
42881   argp1 = (Dali::Path *)jarg1;
42882   if (!argp1) {
42883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
42884     return 0;
42885   }
42886   arg1 = *argp1;
42887   arg2 = (Dali::Vector3 *)jarg2;
42888   if (!arg2) {
42889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42890     return 0;
42891   }
42892   arg3 = (Dali::Property::Index)jarg3;
42893   arg4 = (Dali::Vector3 *)jarg4;
42894   if (!arg4) {
42895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42896     return 0;
42897   }
42898   arg5 = (unsigned int)jarg5;
42899   {
42900     try {
42901       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
42902     } CALL_CATCH_EXCEPTION(0);
42903   }
42904
42905   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
42906   return jresult;
42907 }
42908
42909
42910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
42911   void * jresult ;
42912   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
42913
42914   {
42915     try {
42916       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
42917     } CALL_CATCH_EXCEPTION(0);
42918   }
42919
42920   jresult = (void *)result;
42921   return jresult;
42922 }
42923
42924
42925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
42926   void * jresult ;
42927   Dali::BaseHandle arg1 ;
42928   Dali::BaseHandle *argp1 ;
42929   Dali::Toolkit::ScrollViewPagePathEffect result;
42930
42931   argp1 = (Dali::BaseHandle *)jarg1;
42932   if (!argp1) {
42933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42934     return 0;
42935   }
42936   arg1 = *argp1;
42937   {
42938     try {
42939       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
42940     } CALL_CATCH_EXCEPTION(0);
42941   }
42942
42943   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
42949   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
42950   Dali::Actor arg2 ;
42951   unsigned int arg3 ;
42952   Dali::Actor *argp2 ;
42953
42954   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
42955   argp2 = (Dali::Actor *)jarg2;
42956   if (!argp2) {
42957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42958     return ;
42959   }
42960   arg2 = *argp2;
42961   arg3 = (unsigned int)jarg3;
42962   {
42963     try {
42964       (arg1)->ApplyToPage(arg2,arg3);
42965     } CALL_CATCH_EXCEPTION();
42966   }
42967
42968 }
42969
42970
42971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
42972   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
42973
42974   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
42975   {
42976     try {
42977       delete arg1;
42978     } CALL_CATCH_EXCEPTION();
42979   }
42980
42981 }
42982
42983
42984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
42985   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
42986   Dali::Toolkit::ClampState arg2 ;
42987
42988   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
42989   arg2 = (Dali::Toolkit::ClampState)jarg2;
42990   if (arg1) (arg1)->x = arg2;
42991 }
42992
42993
42994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
42995   int jresult ;
42996   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
42997   Dali::Toolkit::ClampState result;
42998
42999   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43000   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43001   jresult = (int)result;
43002   return jresult;
43003 }
43004
43005
43006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43007   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43008   Dali::Toolkit::ClampState arg2 ;
43009
43010   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43011   arg2 = (Dali::Toolkit::ClampState)jarg2;
43012   if (arg1) (arg1)->y = arg2;
43013 }
43014
43015
43016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43017   int jresult ;
43018   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43019   Dali::Toolkit::ClampState result;
43020
43021   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43022   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43023   jresult = (int)result;
43024   return jresult;
43025 }
43026
43027
43028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43029   void * jresult ;
43030   Dali::Toolkit::ClampState2D *result = 0 ;
43031
43032   {
43033     try {
43034       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43035     } CALL_CATCH_EXCEPTION(0);
43036   }
43037
43038   jresult = (void *)result;
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43044   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43045
43046   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43047   {
43048     try {
43049       delete arg1;
43050     } CALL_CATCH_EXCEPTION();
43051   }
43052
43053 }
43054
43055
43056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43057   void * jresult ;
43058   float arg1 ;
43059   float arg2 ;
43060   bool arg3 ;
43061   Dali::Toolkit::RulerDomain *result = 0 ;
43062
43063   arg1 = (float)jarg1;
43064   arg2 = (float)jarg2;
43065   arg3 = jarg3 ? true : false;
43066   {
43067     try {
43068       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43069     } CALL_CATCH_EXCEPTION(0);
43070   }
43071
43072   jresult = (void *)result;
43073   return jresult;
43074 }
43075
43076
43077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43078   void * jresult ;
43079   float arg1 ;
43080   float arg2 ;
43081   Dali::Toolkit::RulerDomain *result = 0 ;
43082
43083   arg1 = (float)jarg1;
43084   arg2 = (float)jarg2;
43085   {
43086     try {
43087       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43088     } CALL_CATCH_EXCEPTION(0);
43089   }
43090
43091   jresult = (void *)result;
43092   return jresult;
43093 }
43094
43095
43096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43097   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43098   float arg2 ;
43099
43100   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43101   arg2 = (float)jarg2;
43102   if (arg1) (arg1)->min = arg2;
43103 }
43104
43105
43106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43107   float jresult ;
43108   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43109   float result;
43110
43111   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43112   result = (float) ((arg1)->min);
43113   jresult = result;
43114   return jresult;
43115 }
43116
43117
43118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43119   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43120   float arg2 ;
43121
43122   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43123   arg2 = (float)jarg2;
43124   if (arg1) (arg1)->max = arg2;
43125 }
43126
43127
43128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43129   float jresult ;
43130   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43131   float result;
43132
43133   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43134   result = (float) ((arg1)->max);
43135   jresult = result;
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43141   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43142   bool arg2 ;
43143
43144   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43145   arg2 = jarg2 ? true : false;
43146   if (arg1) (arg1)->enabled = arg2;
43147 }
43148
43149
43150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43151   unsigned int jresult ;
43152   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43153   bool result;
43154
43155   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43156   result = (bool) ((arg1)->enabled);
43157   jresult = result;
43158   return jresult;
43159 }
43160
43161
43162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43163   float jresult ;
43164   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43165   float arg2 ;
43166   float arg3 ;
43167   float arg4 ;
43168   float result;
43169
43170   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43171   arg2 = (float)jarg2;
43172   arg3 = (float)jarg3;
43173   arg4 = (float)jarg4;
43174   {
43175     try {
43176       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43177     } CALL_CATCH_EXCEPTION(0);
43178   }
43179
43180   jresult = result;
43181   return jresult;
43182 }
43183
43184
43185 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43186   float jresult ;
43187   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43188   float arg2 ;
43189   float arg3 ;
43190   float result;
43191
43192   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43193   arg2 = (float)jarg2;
43194   arg3 = (float)jarg3;
43195   {
43196     try {
43197       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43198     } CALL_CATCH_EXCEPTION(0);
43199   }
43200
43201   jresult = result;
43202   return jresult;
43203 }
43204
43205
43206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43207   float jresult ;
43208   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43209   float arg2 ;
43210   float result;
43211
43212   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43213   arg2 = (float)jarg2;
43214   {
43215     try {
43216       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43217     } CALL_CATCH_EXCEPTION(0);
43218   }
43219
43220   jresult = result;
43221   return jresult;
43222 }
43223
43224
43225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43226   float jresult ;
43227   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43228   float arg2 ;
43229   float arg3 ;
43230   float arg4 ;
43231   Dali::Toolkit::ClampState *arg5 = 0 ;
43232   float result;
43233
43234   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43235   arg2 = (float)jarg2;
43236   arg3 = (float)jarg3;
43237   arg4 = (float)jarg4;
43238   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43239   if (!arg5) {
43240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43241     return 0;
43242   }
43243   {
43244     try {
43245       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43246     } CALL_CATCH_EXCEPTION(0);
43247   }
43248
43249   jresult = result;
43250   return jresult;
43251 }
43252
43253
43254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43255   float jresult ;
43256   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43257   float result;
43258
43259   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43260   {
43261     try {
43262       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43263     } CALL_CATCH_EXCEPTION(0);
43264   }
43265
43266   jresult = result;
43267   return jresult;
43268 }
43269
43270
43271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43272   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43273
43274   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43275   {
43276     try {
43277       delete arg1;
43278     } CALL_CATCH_EXCEPTION();
43279   }
43280
43281 }
43282
43283
43284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43285   float jresult ;
43286   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43287   float arg2 ;
43288   float arg3 ;
43289   float result;
43290
43291   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43292   arg2 = (float)jarg2;
43293   arg3 = (float)jarg3;
43294   {
43295     try {
43296       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43297     } CALL_CATCH_EXCEPTION(0);
43298   }
43299
43300   jresult = result;
43301   return jresult;
43302 }
43303
43304
43305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43306   float jresult ;
43307   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43308   float arg2 ;
43309   float result;
43310
43311   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43312   arg2 = (float)jarg2;
43313   {
43314     try {
43315       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43316     } CALL_CATCH_EXCEPTION(0);
43317   }
43318
43319   jresult = result;
43320   return jresult;
43321 }
43322
43323
43324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43325   float jresult ;
43326   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43327   unsigned int arg2 ;
43328   unsigned int *arg3 = 0 ;
43329   bool arg4 ;
43330   float result;
43331
43332   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43333   arg2 = (unsigned int)jarg2;
43334   arg3 = (unsigned int *)jarg3;
43335   arg4 = jarg4 ? true : false;
43336   {
43337     try {
43338       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43339     } CALL_CATCH_EXCEPTION(0);
43340   }
43341
43342   jresult = result;
43343   return jresult;
43344 }
43345
43346
43347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43348   unsigned int jresult ;
43349   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43350   float arg2 ;
43351   bool arg3 ;
43352   unsigned int result;
43353
43354   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43355   arg2 = (float)jarg2;
43356   arg3 = jarg3 ? true : false;
43357   {
43358     try {
43359       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43360     } CALL_CATCH_EXCEPTION(0);
43361   }
43362
43363   jresult = result;
43364   return jresult;
43365 }
43366
43367
43368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43369   unsigned int jresult ;
43370   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43371   unsigned int result;
43372
43373   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43374   {
43375     try {
43376       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43377     } CALL_CATCH_EXCEPTION(0);
43378   }
43379
43380   jresult = result;
43381   return jresult;
43382 }
43383
43384
43385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43386   int jresult ;
43387   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43388   Dali::Toolkit::Ruler::RulerType result;
43389
43390   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43391   {
43392     try {
43393       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43394     } CALL_CATCH_EXCEPTION(0);
43395   }
43396
43397   jresult = (int)result;
43398   return jresult;
43399 }
43400
43401
43402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43403   unsigned int jresult ;
43404   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43405   bool result;
43406
43407   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43408   {
43409     try {
43410       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43411     } CALL_CATCH_EXCEPTION(0);
43412   }
43413
43414   jresult = result;
43415   return jresult;
43416 }
43417
43418
43419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43420   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43421
43422   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43423   {
43424     try {
43425       (arg1)->Enable();
43426     } CALL_CATCH_EXCEPTION();
43427   }
43428
43429 }
43430
43431
43432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43433   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43434
43435   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43436   {
43437     try {
43438       (arg1)->Disable();
43439     } CALL_CATCH_EXCEPTION();
43440   }
43441
43442 }
43443
43444
43445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43446   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43447   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43448   Dali::Toolkit::RulerDomain *argp2 ;
43449
43450   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43451   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43452   if (!argp2) {
43453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43454     return ;
43455   }
43456   arg2 = *argp2;
43457   {
43458     try {
43459       (arg1)->SetDomain(arg2);
43460     } CALL_CATCH_EXCEPTION();
43461   }
43462
43463 }
43464
43465
43466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43467   void * jresult ;
43468   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43469   Dali::Toolkit::RulerDomain *result = 0 ;
43470
43471   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43472   {
43473     try {
43474       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43475     } CALL_CATCH_EXCEPTION(0);
43476   }
43477
43478   jresult = (void *)result;
43479   return jresult;
43480 }
43481
43482
43483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43484   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43485
43486   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43487   {
43488     try {
43489       (arg1)->DisableDomain();
43490     } CALL_CATCH_EXCEPTION();
43491   }
43492
43493 }
43494
43495
43496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43497   float jresult ;
43498   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43499   float arg2 ;
43500   float arg3 ;
43501   float arg4 ;
43502   float result;
43503
43504   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43505   arg2 = (float)jarg2;
43506   arg3 = (float)jarg3;
43507   arg4 = (float)jarg4;
43508   {
43509     try {
43510       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43511     } CALL_CATCH_EXCEPTION(0);
43512   }
43513
43514   jresult = result;
43515   return jresult;
43516 }
43517
43518
43519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43520   float jresult ;
43521   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43522   float arg2 ;
43523   float arg3 ;
43524   float result;
43525
43526   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43527   arg2 = (float)jarg2;
43528   arg3 = (float)jarg3;
43529   {
43530     try {
43531       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43532     } CALL_CATCH_EXCEPTION(0);
43533   }
43534
43535   jresult = result;
43536   return jresult;
43537 }
43538
43539
43540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43541   float jresult ;
43542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43543   float arg2 ;
43544   float result;
43545
43546   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43547   arg2 = (float)jarg2;
43548   {
43549     try {
43550       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43551     } CALL_CATCH_EXCEPTION(0);
43552   }
43553
43554   jresult = result;
43555   return jresult;
43556 }
43557
43558
43559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43560   float jresult ;
43561   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43562   float arg2 ;
43563   float arg3 ;
43564   float arg4 ;
43565   Dali::Toolkit::ClampState *arg5 = 0 ;
43566   float result;
43567
43568   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43569   arg2 = (float)jarg2;
43570   arg3 = (float)jarg3;
43571   arg4 = (float)jarg4;
43572   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43573   if (!arg5) {
43574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43575     return 0;
43576   }
43577   {
43578     try {
43579       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43580     } CALL_CATCH_EXCEPTION(0);
43581   }
43582
43583   jresult = result;
43584   return jresult;
43585 }
43586
43587
43588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43589   float jresult ;
43590   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43591   float arg2 ;
43592   float arg3 ;
43593   float arg4 ;
43594   float arg5 ;
43595   float result;
43596
43597   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43598   arg2 = (float)jarg2;
43599   arg3 = (float)jarg3;
43600   arg4 = (float)jarg4;
43601   arg5 = (float)jarg5;
43602   {
43603     try {
43604       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43605     } CALL_CATCH_EXCEPTION(0);
43606   }
43607
43608   jresult = result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43614   float jresult ;
43615   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43616   float arg2 ;
43617   float arg3 ;
43618   float arg4 ;
43619   float result;
43620
43621   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43622   arg2 = (float)jarg2;
43623   arg3 = (float)jarg3;
43624   arg4 = (float)jarg4;
43625   {
43626     try {
43627       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43628     } CALL_CATCH_EXCEPTION(0);
43629   }
43630
43631   jresult = result;
43632   return jresult;
43633 }
43634
43635
43636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43637   float jresult ;
43638   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43639   float arg2 ;
43640   float arg3 ;
43641   float result;
43642
43643   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43644   arg2 = (float)jarg2;
43645   arg3 = (float)jarg3;
43646   {
43647     try {
43648       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43649     } CALL_CATCH_EXCEPTION(0);
43650   }
43651
43652   jresult = result;
43653   return jresult;
43654 }
43655
43656
43657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43658   float jresult ;
43659   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43660   float arg2 ;
43661   float result;
43662
43663   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43664   arg2 = (float)jarg2;
43665   {
43666     try {
43667       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43668     } CALL_CATCH_EXCEPTION(0);
43669   }
43670
43671   jresult = result;
43672   return jresult;
43673 }
43674
43675
43676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43677   float jresult ;
43678   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43679   float arg2 ;
43680   float arg3 ;
43681   float arg4 ;
43682   float arg5 ;
43683   Dali::Toolkit::ClampState *arg6 = 0 ;
43684   float result;
43685
43686   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43687   arg2 = (float)jarg2;
43688   arg3 = (float)jarg3;
43689   arg4 = (float)jarg4;
43690   arg5 = (float)jarg5;
43691   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43692   if (!arg6) {
43693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43694     return 0;
43695   }
43696   {
43697     try {
43698       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43699     } CALL_CATCH_EXCEPTION(0);
43700   }
43701
43702   jresult = result;
43703   return jresult;
43704 }
43705
43706
43707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43708   void * jresult ;
43709   Dali::Toolkit::DefaultRuler *result = 0 ;
43710
43711   {
43712     try {
43713       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43714     } CALL_CATCH_EXCEPTION(0);
43715   }
43716
43717   jresult = (void *)result;
43718   return jresult;
43719 }
43720
43721
43722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43723   float jresult ;
43724   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43725   float arg2 ;
43726   float arg3 ;
43727   float result;
43728
43729   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43730   arg2 = (float)jarg2;
43731   arg3 = (float)jarg3;
43732   {
43733     try {
43734       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
43735     } CALL_CATCH_EXCEPTION(0);
43736   }
43737
43738   jresult = result;
43739   return jresult;
43740 }
43741
43742
43743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43744   float jresult ;
43745   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43746   unsigned int arg2 ;
43747   unsigned int *arg3 = 0 ;
43748   bool arg4 ;
43749   float result;
43750
43751   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43752   arg2 = (unsigned int)jarg2;
43753   arg3 = (unsigned int *)jarg3;
43754   arg4 = jarg4 ? true : false;
43755   {
43756     try {
43757       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43758     } CALL_CATCH_EXCEPTION(0);
43759   }
43760
43761   jresult = result;
43762   return jresult;
43763 }
43764
43765
43766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43767   unsigned int jresult ;
43768   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43769   float arg2 ;
43770   bool arg3 ;
43771   unsigned int result;
43772
43773   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43774   arg2 = (float)jarg2;
43775   arg3 = jarg3 ? true : false;
43776   {
43777     try {
43778       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43779     } CALL_CATCH_EXCEPTION(0);
43780   }
43781
43782   jresult = result;
43783   return jresult;
43784 }
43785
43786
43787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
43788   unsigned int jresult ;
43789   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43790   unsigned int result;
43791
43792   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43793   {
43794     try {
43795       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
43796     } CALL_CATCH_EXCEPTION(0);
43797   }
43798
43799   jresult = result;
43800   return jresult;
43801 }
43802
43803
43804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
43805   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43806
43807   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43808   {
43809     try {
43810       delete arg1;
43811     } CALL_CATCH_EXCEPTION();
43812   }
43813
43814 }
43815
43816
43817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
43818   void * jresult ;
43819   float arg1 ;
43820   Dali::Toolkit::FixedRuler *result = 0 ;
43821
43822   arg1 = (float)jarg1;
43823   {
43824     try {
43825       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
43826     } CALL_CATCH_EXCEPTION(0);
43827   }
43828
43829   jresult = (void *)result;
43830   return jresult;
43831 }
43832
43833
43834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
43835   void * jresult ;
43836   Dali::Toolkit::FixedRuler *result = 0 ;
43837
43838   {
43839     try {
43840       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
43841     } CALL_CATCH_EXCEPTION(0);
43842   }
43843
43844   jresult = (void *)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43850   float jresult ;
43851   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43852   float arg2 ;
43853   float arg3 ;
43854   float result;
43855
43856   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43857   arg2 = (float)jarg2;
43858   arg3 = (float)jarg3;
43859   {
43860     try {
43861       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
43862     } CALL_CATCH_EXCEPTION(0);
43863   }
43864
43865   jresult = result;
43866   return jresult;
43867 }
43868
43869
43870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43871   float jresult ;
43872   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43873   unsigned int arg2 ;
43874   unsigned int *arg3 = 0 ;
43875   bool arg4 ;
43876   float result;
43877
43878   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43879   arg2 = (unsigned int)jarg2;
43880   arg3 = (unsigned int *)jarg3;
43881   arg4 = jarg4 ? true : false;
43882   {
43883     try {
43884       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43885     } CALL_CATCH_EXCEPTION(0);
43886   }
43887
43888   jresult = result;
43889   return jresult;
43890 }
43891
43892
43893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43894   unsigned int jresult ;
43895   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43896   float arg2 ;
43897   bool arg3 ;
43898   unsigned int result;
43899
43900   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43901   arg2 = (float)jarg2;
43902   arg3 = jarg3 ? true : false;
43903   {
43904     try {
43905       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43906     } CALL_CATCH_EXCEPTION(0);
43907   }
43908
43909   jresult = result;
43910   return jresult;
43911 }
43912
43913
43914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
43915   unsigned int jresult ;
43916   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43917   unsigned int result;
43918
43919   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43920   {
43921     try {
43922       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
43923     } CALL_CATCH_EXCEPTION(0);
43924   }
43925
43926   jresult = result;
43927   return jresult;
43928 }
43929
43930
43931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
43932   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
43933
43934   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
43935   {
43936     try {
43937       delete arg1;
43938     } CALL_CATCH_EXCEPTION();
43939   }
43940
43941 }
43942
43943
43944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
43945   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43946   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
43947
43948   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43949   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
43950   if (arg1) (arg1)->scale = *arg2;
43951 }
43952
43953
43954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
43955   void * jresult ;
43956   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43957   Dali::Toolkit::ClampState2D *result = 0 ;
43958
43959   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43960   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
43961   jresult = (void *)result;
43962   return jresult;
43963 }
43964
43965
43966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
43967   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43968   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
43969
43970   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43971   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
43972   if (arg1) (arg1)->position = *arg2;
43973 }
43974
43975
43976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
43977   void * jresult ;
43978   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43979   Dali::Toolkit::ClampState2D *result = 0 ;
43980
43981   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43982   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
43983   jresult = (void *)result;
43984   return jresult;
43985 }
43986
43987
43988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
43989   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
43990   Dali::Toolkit::ClampState arg2 ;
43991
43992   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
43993   arg2 = (Dali::Toolkit::ClampState)jarg2;
43994   if (arg1) (arg1)->rotation = arg2;
43995 }
43996
43997
43998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
43999   int jresult ;
44000   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44001   Dali::Toolkit::ClampState result;
44002
44003   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44004   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44005   jresult = (int)result;
44006   return jresult;
44007 }
44008
44009
44010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44011   void * jresult ;
44012   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44013
44014   {
44015     try {
44016       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44017     } CALL_CATCH_EXCEPTION(0);
44018   }
44019
44020   jresult = (void *)result;
44021   return jresult;
44022 }
44023
44024
44025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44026   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44027
44028   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44029   {
44030     try {
44031       delete arg1;
44032     } CALL_CATCH_EXCEPTION();
44033   }
44034
44035 }
44036
44037
44038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44039   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44040   Dali::Toolkit::SnapType arg2 ;
44041
44042   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44043   arg2 = (Dali::Toolkit::SnapType)jarg2;
44044   if (arg1) (arg1)->type = arg2;
44045 }
44046
44047
44048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44049   int jresult ;
44050   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44051   Dali::Toolkit::SnapType result;
44052
44053   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44054   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44055   jresult = (int)result;
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44061   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44062   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44063
44064   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44065   arg2 = (Dali::Vector2 *)jarg2;
44066   if (arg1) (arg1)->position = *arg2;
44067 }
44068
44069
44070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44071   void * jresult ;
44072   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44073   Dali::Vector2 *result = 0 ;
44074
44075   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44076   result = (Dali::Vector2 *)& ((arg1)->position);
44077   jresult = (void *)result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44083   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44084   float arg2 ;
44085
44086   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44087   arg2 = (float)jarg2;
44088   if (arg1) (arg1)->duration = arg2;
44089 }
44090
44091
44092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44093   float jresult ;
44094   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44095   float result;
44096
44097   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44098   result = (float) ((arg1)->duration);
44099   jresult = result;
44100   return jresult;
44101 }
44102
44103
44104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44105   void * jresult ;
44106   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44107
44108   {
44109     try {
44110       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44111     } CALL_CATCH_EXCEPTION(0);
44112   }
44113
44114   jresult = (void *)result;
44115   return jresult;
44116 }
44117
44118
44119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44120   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44121
44122   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44123   {
44124     try {
44125       delete arg1;
44126     } CALL_CATCH_EXCEPTION();
44127   }
44128
44129 }
44130
44131
44132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44133   int jresult ;
44134   int result;
44135
44136   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44137   jresult = (int)result;
44138   return jresult;
44139 }
44140
44141
44142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44143   int jresult ;
44144   int result;
44145
44146   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44147   jresult = (int)result;
44148   return jresult;
44149 }
44150
44151
44152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44153   int jresult ;
44154   int result;
44155
44156   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44157   jresult = (int)result;
44158   return jresult;
44159 }
44160
44161
44162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44163   int jresult ;
44164   int result;
44165
44166   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44167   jresult = (int)result;
44168   return jresult;
44169 }
44170
44171
44172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44173   int jresult ;
44174   int result;
44175
44176   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44177   jresult = (int)result;
44178   return jresult;
44179 }
44180
44181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44182   int jresult ;
44183   int result;
44184
44185   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44186   jresult = (int)result;
44187   return jresult;
44188 }
44189
44190
44191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44192   int jresult ;
44193   int result;
44194
44195   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44196   jresult = (int)result;
44197   return jresult;
44198 }
44199
44200
44201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44202   int jresult ;
44203   int result;
44204
44205   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44206   jresult = (int)result;
44207   return jresult;
44208 }
44209
44210
44211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44212   int jresult ;
44213   int result;
44214
44215   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44216   jresult = (int)result;
44217   return jresult;
44218 }
44219
44220
44221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44222   int jresult ;
44223   int result;
44224
44225   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44226   jresult = (int)result;
44227   return jresult;
44228 }
44229
44230
44231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44232   int jresult ;
44233   int result;
44234
44235   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44236   jresult = (int)result;
44237   return jresult;
44238 }
44239
44240
44241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44242   int jresult ;
44243   int result;
44244
44245   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44246   jresult = (int)result;
44247   return jresult;
44248 }
44249
44250
44251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44252   int jresult ;
44253   int result;
44254
44255   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44256   jresult = (int)result;
44257   return jresult;
44258 }
44259
44260
44261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44262   int jresult ;
44263   int result;
44264
44265   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44266   jresult = (int)result;
44267   return jresult;
44268 }
44269
44270
44271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44272   int jresult ;
44273   int result;
44274
44275   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44276   jresult = (int)result;
44277   return jresult;
44278 }
44279
44280
44281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44282   int jresult ;
44283   int result;
44284
44285   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44286   jresult = (int)result;
44287   return jresult;
44288 }
44289
44290
44291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44292   int jresult ;
44293   int result;
44294
44295   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44296   jresult = (int)result;
44297   return jresult;
44298 }
44299
44300
44301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44302   int jresult ;
44303   int result;
44304
44305   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44306   jresult = (int)result;
44307   return jresult;
44308 }
44309
44310
44311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44312   int jresult ;
44313   int result;
44314
44315   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44316   jresult = (int)result;
44317   return jresult;
44318 }
44319
44320
44321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44322   int jresult ;
44323   int result;
44324
44325   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44326   jresult = (int)result;
44327   return jresult;
44328 }
44329
44330
44331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44332   int jresult ;
44333   int result;
44334
44335   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44336   jresult = (int)result;
44337   return jresult;
44338 }
44339
44340
44341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44342   int jresult ;
44343   int result;
44344
44345   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44346   jresult = (int)result;
44347   return jresult;
44348 }
44349
44350
44351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44352   int jresult ;
44353   int result;
44354
44355   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44356   jresult = (int)result;
44357   return jresult;
44358 }
44359
44360
44361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44362   int jresult ;
44363   int result;
44364
44365   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44366   jresult = (int)result;
44367   return jresult;
44368 }
44369
44370
44371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44372   int jresult ;
44373   int result;
44374
44375   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44376   jresult = (int)result;
44377   return jresult;
44378 }
44379
44380
44381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44382   int jresult ;
44383   int result;
44384
44385   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44386   jresult = (int)result;
44387   return jresult;
44388 }
44389
44390
44391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44392   void * jresult ;
44393   Dali::Toolkit::ScrollView::Property *result = 0 ;
44394
44395   {
44396     try {
44397       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44398     } CALL_CATCH_EXCEPTION(0);
44399   }
44400
44401   jresult = (void *)result;
44402   return jresult;
44403 }
44404
44405
44406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44407   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44408
44409   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44410   {
44411     try {
44412       delete arg1;
44413     } CALL_CATCH_EXCEPTION();
44414   }
44415
44416 }
44417
44418
44419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44420   void * jresult ;
44421   Dali::Toolkit::ScrollView *result = 0 ;
44422
44423   {
44424     try {
44425       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44426     } CALL_CATCH_EXCEPTION(0);
44427   }
44428
44429   jresult = (void *)result;
44430   return jresult;
44431 }
44432
44433
44434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44435   void * jresult ;
44436   Dali::Toolkit::ScrollView *arg1 = 0 ;
44437   Dali::Toolkit::ScrollView *result = 0 ;
44438
44439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44440   if (!arg1) {
44441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44442     return 0;
44443   }
44444   {
44445     try {
44446       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44447     } CALL_CATCH_EXCEPTION(0);
44448   }
44449
44450   jresult = (void *)result;
44451   return jresult;
44452 }
44453
44454
44455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44456   void * jresult ;
44457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44458   Dali::Toolkit::ScrollView *arg2 = 0 ;
44459   Dali::Toolkit::ScrollView *result = 0 ;
44460
44461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44462   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44463   if (!arg2) {
44464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44465     return 0;
44466   }
44467   {
44468     try {
44469       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44470     } CALL_CATCH_EXCEPTION(0);
44471   }
44472
44473   jresult = (void *)result;
44474   return jresult;
44475 }
44476
44477
44478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44479   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44480
44481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44482   {
44483     try {
44484       delete arg1;
44485     } CALL_CATCH_EXCEPTION();
44486   }
44487
44488 }
44489
44490
44491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44492   void * jresult ;
44493   Dali::Toolkit::ScrollView result;
44494
44495   {
44496     try {
44497       result = Dali::Toolkit::ScrollView::New();
44498     } CALL_CATCH_EXCEPTION(0);
44499   }
44500
44501   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44502   return jresult;
44503 }
44504
44505
44506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44507   void * jresult ;
44508   Dali::BaseHandle arg1 ;
44509   Dali::BaseHandle *argp1 ;
44510   Dali::Toolkit::ScrollView result;
44511
44512   argp1 = (Dali::BaseHandle *)jarg1;
44513   if (!argp1) {
44514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44515     return 0;
44516   }
44517   arg1 = *argp1;
44518   {
44519     try {
44520       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44521     } CALL_CATCH_EXCEPTION(0);
44522   }
44523
44524   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44525   return jresult;
44526 }
44527
44528
44529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44530   void * jresult ;
44531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44532   Dali::AlphaFunction result;
44533
44534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44535   {
44536     try {
44537       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44538     } CALL_CATCH_EXCEPTION(0);
44539   }
44540
44541   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44548   Dali::AlphaFunction arg2 ;
44549   Dali::AlphaFunction *argp2 ;
44550
44551   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44552   argp2 = (Dali::AlphaFunction *)jarg2;
44553   if (!argp2) {
44554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44555     return ;
44556   }
44557   arg2 = *argp2;
44558   {
44559     try {
44560       (arg1)->SetScrollSnapAlphaFunction(arg2);
44561     } CALL_CATCH_EXCEPTION();
44562   }
44563
44564 }
44565
44566
44567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44568   void * jresult ;
44569   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44570   Dali::AlphaFunction result;
44571
44572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44573   {
44574     try {
44575       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44576     } CALL_CATCH_EXCEPTION(0);
44577   }
44578
44579   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44580   return jresult;
44581 }
44582
44583
44584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44585   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44586   Dali::AlphaFunction arg2 ;
44587   Dali::AlphaFunction *argp2 ;
44588
44589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44590   argp2 = (Dali::AlphaFunction *)jarg2;
44591   if (!argp2) {
44592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44593     return ;
44594   }
44595   arg2 = *argp2;
44596   {
44597     try {
44598       (arg1)->SetScrollFlickAlphaFunction(arg2);
44599     } CALL_CATCH_EXCEPTION();
44600   }
44601
44602 }
44603
44604
44605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44606   float jresult ;
44607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44608   float result;
44609
44610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44611   {
44612     try {
44613       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44614     } CALL_CATCH_EXCEPTION(0);
44615   }
44616
44617   jresult = result;
44618   return jresult;
44619 }
44620
44621
44622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44624   float arg2 ;
44625
44626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44627   arg2 = (float)jarg2;
44628   {
44629     try {
44630       (arg1)->SetScrollSnapDuration(arg2);
44631     } CALL_CATCH_EXCEPTION();
44632   }
44633
44634 }
44635
44636
44637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44638   float jresult ;
44639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44640   float result;
44641
44642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44643   {
44644     try {
44645       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44646     } CALL_CATCH_EXCEPTION(0);
44647   }
44648
44649   jresult = result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44656   float arg2 ;
44657
44658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44659   arg2 = (float)jarg2;
44660   {
44661     try {
44662       (arg1)->SetScrollFlickDuration(arg2);
44663     } CALL_CATCH_EXCEPTION();
44664   }
44665
44666 }
44667
44668
44669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44671   Dali::Toolkit::RulerPtr arg2 ;
44672   Dali::Toolkit::RulerPtr *argp2 ;
44673
44674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44675   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44676   if (!argp2) {
44677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44678     return ;
44679   }
44680   arg2 = *argp2;
44681   {
44682     try {
44683       (arg1)->SetRulerX(arg2);
44684     } CALL_CATCH_EXCEPTION();
44685   }
44686
44687 }
44688
44689
44690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44692   Dali::Toolkit::RulerPtr arg2 ;
44693   Dali::Toolkit::RulerPtr *argp2 ;
44694
44695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44696   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44697   if (!argp2) {
44698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44699     return ;
44700   }
44701   arg2 = *argp2;
44702   {
44703     try {
44704       (arg1)->SetRulerY(arg2);
44705     } CALL_CATCH_EXCEPTION();
44706   }
44707
44708 }
44709
44710
44711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44712   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44713   bool arg2 ;
44714
44715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44716   arg2 = jarg2 ? true : false;
44717   {
44718     try {
44719       (arg1)->SetScrollSensitive(arg2);
44720     } CALL_CATCH_EXCEPTION();
44721   }
44722
44723 }
44724
44725
44726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
44727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44728   float arg2 ;
44729   float arg3 ;
44730
44731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44732   arg2 = (float)jarg2;
44733   arg3 = (float)jarg3;
44734   {
44735     try {
44736       (arg1)->SetMaxOvershoot(arg2,arg3);
44737     } CALL_CATCH_EXCEPTION();
44738   }
44739
44740 }
44741
44742
44743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
44744   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44745   Dali::AlphaFunction arg2 ;
44746   Dali::AlphaFunction *argp2 ;
44747
44748   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44749   argp2 = (Dali::AlphaFunction *)jarg2;
44750   if (!argp2) {
44751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44752     return ;
44753   }
44754   arg2 = *argp2;
44755   {
44756     try {
44757       (arg1)->SetSnapOvershootAlphaFunction(arg2);
44758     } CALL_CATCH_EXCEPTION();
44759   }
44760
44761 }
44762
44763
44764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
44765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44766   float arg2 ;
44767
44768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44769   arg2 = (float)jarg2;
44770   {
44771     try {
44772       (arg1)->SetSnapOvershootDuration(arg2);
44773     } CALL_CATCH_EXCEPTION();
44774   }
44775
44776 }
44777
44778
44779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
44780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44781   bool arg2 ;
44782
44783   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44784   arg2 = jarg2 ? true : false;
44785   {
44786     try {
44787       (arg1)->SetActorAutoSnap(arg2);
44788     } CALL_CATCH_EXCEPTION();
44789   }
44790
44791 }
44792
44793
44794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
44795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44796   bool arg2 ;
44797
44798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44799   arg2 = jarg2 ? true : false;
44800   {
44801     try {
44802       (arg1)->SetWrapMode(arg2);
44803     } CALL_CATCH_EXCEPTION();
44804   }
44805
44806 }
44807
44808
44809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
44810   int jresult ;
44811   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44812   int result;
44813
44814   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44815   {
44816     try {
44817       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
44818     } CALL_CATCH_EXCEPTION(0);
44819   }
44820
44821   jresult = result;
44822   return jresult;
44823 }
44824
44825
44826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
44827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44828   int arg2 ;
44829
44830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44831   arg2 = (int)jarg2;
44832   {
44833     try {
44834       (arg1)->SetScrollUpdateDistance(arg2);
44835     } CALL_CATCH_EXCEPTION();
44836   }
44837
44838 }
44839
44840
44841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
44842   unsigned int jresult ;
44843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44844   bool result;
44845
44846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44847   {
44848     try {
44849       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
44850     } CALL_CATCH_EXCEPTION(0);
44851   }
44852
44853   jresult = result;
44854   return jresult;
44855 }
44856
44857
44858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
44859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44860   bool arg2 ;
44861
44862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44863   arg2 = jarg2 ? true : false;
44864   {
44865     try {
44866       (arg1)->SetAxisAutoLock(arg2);
44867     } CALL_CATCH_EXCEPTION();
44868   }
44869
44870 }
44871
44872
44873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
44874   float jresult ;
44875   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44876   float result;
44877
44878   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44879   {
44880     try {
44881       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
44882     } CALL_CATCH_EXCEPTION(0);
44883   }
44884
44885   jresult = result;
44886   return jresult;
44887 }
44888
44889
44890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
44891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44892   float arg2 ;
44893
44894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44895   arg2 = (float)jarg2;
44896   {
44897     try {
44898       (arg1)->SetAxisAutoLockGradient(arg2);
44899     } CALL_CATCH_EXCEPTION();
44900   }
44901
44902 }
44903
44904
44905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
44906   float jresult ;
44907   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44908   float result;
44909
44910   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44911   {
44912     try {
44913       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
44914     } CALL_CATCH_EXCEPTION(0);
44915   }
44916
44917   jresult = result;
44918   return jresult;
44919 }
44920
44921
44922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
44923   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44924   float arg2 ;
44925
44926   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44927   arg2 = (float)jarg2;
44928   {
44929     try {
44930       (arg1)->SetFrictionCoefficient(arg2);
44931     } CALL_CATCH_EXCEPTION();
44932   }
44933
44934 }
44935
44936
44937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
44938   float jresult ;
44939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44940   float result;
44941
44942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44943   {
44944     try {
44945       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
44946     } CALL_CATCH_EXCEPTION(0);
44947   }
44948
44949   jresult = result;
44950   return jresult;
44951 }
44952
44953
44954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
44955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44956   float arg2 ;
44957
44958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44959   arg2 = (float)jarg2;
44960   {
44961     try {
44962       (arg1)->SetFlickSpeedCoefficient(arg2);
44963     } CALL_CATCH_EXCEPTION();
44964   }
44965
44966 }
44967
44968
44969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
44970   void * jresult ;
44971   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44972   Dali::Vector2 result;
44973
44974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44975   {
44976     try {
44977       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
44978     } CALL_CATCH_EXCEPTION(0);
44979   }
44980
44981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
44982   return jresult;
44983 }
44984
44985
44986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
44987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44988   Dali::Vector2 *arg2 = 0 ;
44989
44990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44991   arg2 = (Dali::Vector2 *)jarg2;
44992   if (!arg2) {
44993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44994     return ;
44995   }
44996   {
44997     try {
44998       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
44999     } CALL_CATCH_EXCEPTION();
45000   }
45001
45002 }
45003
45004
45005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45006   float jresult ;
45007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45008   float result;
45009
45010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45011   {
45012     try {
45013       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45014     } CALL_CATCH_EXCEPTION(0);
45015   }
45016
45017   jresult = result;
45018   return jresult;
45019 }
45020
45021
45022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45024   float arg2 ;
45025
45026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45027   arg2 = (float)jarg2;
45028   {
45029     try {
45030       (arg1)->SetMinimumSpeedForFlick(arg2);
45031     } CALL_CATCH_EXCEPTION();
45032   }
45033
45034 }
45035
45036
45037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45038   float jresult ;
45039   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45040   float result;
45041
45042   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45043   {
45044     try {
45045       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45046     } CALL_CATCH_EXCEPTION(0);
45047   }
45048
45049   jresult = result;
45050   return jresult;
45051 }
45052
45053
45054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45056   float arg2 ;
45057
45058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45059   arg2 = (float)jarg2;
45060   {
45061     try {
45062       (arg1)->SetMaxFlickSpeed(arg2);
45063     } CALL_CATCH_EXCEPTION();
45064   }
45065
45066 }
45067
45068
45069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45070   void * jresult ;
45071   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45072   Dali::Vector2 result;
45073
45074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45075   {
45076     try {
45077       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45078     } CALL_CATCH_EXCEPTION(0);
45079   }
45080
45081   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45082   return jresult;
45083 }
45084
45085
45086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45087   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45088   Dali::Vector2 arg2 ;
45089   Dali::Vector2 *argp2 ;
45090
45091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45092   argp2 = (Dali::Vector2 *)jarg2;
45093   if (!argp2) {
45094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45095     return ;
45096   }
45097   arg2 = *argp2;
45098   {
45099     try {
45100       (arg1)->SetWheelScrollDistanceStep(arg2);
45101     } CALL_CATCH_EXCEPTION();
45102   }
45103
45104 }
45105
45106
45107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45108   void * jresult ;
45109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45110   Dali::Vector2 result;
45111
45112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45113   {
45114     try {
45115       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45116     } CALL_CATCH_EXCEPTION(0);
45117   }
45118
45119   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45120   return jresult;
45121 }
45122
45123
45124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45125   unsigned int jresult ;
45126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45127   unsigned int result;
45128
45129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45130   {
45131     try {
45132       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45133     } CALL_CATCH_EXCEPTION(0);
45134   }
45135
45136   jresult = result;
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45143   Dali::Vector2 *arg2 = 0 ;
45144
45145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45146   arg2 = (Dali::Vector2 *)jarg2;
45147   if (!arg2) {
45148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45149     return ;
45150   }
45151   {
45152     try {
45153       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45154     } CALL_CATCH_EXCEPTION();
45155   }
45156
45157 }
45158
45159
45160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45161   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45162   Dali::Vector2 *arg2 = 0 ;
45163   float arg3 ;
45164
45165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45166   arg2 = (Dali::Vector2 *)jarg2;
45167   if (!arg2) {
45168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45169     return ;
45170   }
45171   arg3 = (float)jarg3;
45172   {
45173     try {
45174       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45175     } CALL_CATCH_EXCEPTION();
45176   }
45177
45178 }
45179
45180
45181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45183   Dali::Vector2 *arg2 = 0 ;
45184   float arg3 ;
45185   Dali::AlphaFunction arg4 ;
45186   Dali::AlphaFunction *argp4 ;
45187
45188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45189   arg2 = (Dali::Vector2 *)jarg2;
45190   if (!arg2) {
45191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45192     return ;
45193   }
45194   arg3 = (float)jarg3;
45195   argp4 = (Dali::AlphaFunction *)jarg4;
45196   if (!argp4) {
45197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45198     return ;
45199   }
45200   arg4 = *argp4;
45201   {
45202     try {
45203       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45204     } CALL_CATCH_EXCEPTION();
45205   }
45206
45207 }
45208
45209
45210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45211   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45212   Dali::Vector2 *arg2 = 0 ;
45213   float arg3 ;
45214   Dali::Toolkit::DirectionBias arg4 ;
45215   Dali::Toolkit::DirectionBias arg5 ;
45216
45217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45218   arg2 = (Dali::Vector2 *)jarg2;
45219   if (!arg2) {
45220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45221     return ;
45222   }
45223   arg3 = (float)jarg3;
45224   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45225   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45226   {
45227     try {
45228       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45229     } CALL_CATCH_EXCEPTION();
45230   }
45231
45232 }
45233
45234
45235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45237   Dali::Vector2 *arg2 = 0 ;
45238   float arg3 ;
45239   Dali::AlphaFunction arg4 ;
45240   Dali::Toolkit::DirectionBias arg5 ;
45241   Dali::Toolkit::DirectionBias arg6 ;
45242   Dali::AlphaFunction *argp4 ;
45243
45244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45245   arg2 = (Dali::Vector2 *)jarg2;
45246   if (!arg2) {
45247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45248     return ;
45249   }
45250   arg3 = (float)jarg3;
45251   argp4 = (Dali::AlphaFunction *)jarg4;
45252   if (!argp4) {
45253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45254     return ;
45255   }
45256   arg4 = *argp4;
45257   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45258   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45259   {
45260     try {
45261       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45262     } CALL_CATCH_EXCEPTION();
45263   }
45264
45265 }
45266
45267
45268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45270   unsigned int arg2 ;
45271
45272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45273   arg2 = (unsigned int)jarg2;
45274   {
45275     try {
45276       (arg1)->ScrollTo(arg2);
45277     } CALL_CATCH_EXCEPTION();
45278   }
45279
45280 }
45281
45282
45283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45285   unsigned int arg2 ;
45286   float arg3 ;
45287
45288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45289   arg2 = (unsigned int)jarg2;
45290   arg3 = (float)jarg3;
45291   {
45292     try {
45293       (arg1)->ScrollTo(arg2,arg3);
45294     } CALL_CATCH_EXCEPTION();
45295   }
45296
45297 }
45298
45299
45300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45302   unsigned int arg2 ;
45303   float arg3 ;
45304   Dali::Toolkit::DirectionBias arg4 ;
45305
45306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45307   arg2 = (unsigned int)jarg2;
45308   arg3 = (float)jarg3;
45309   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45310   {
45311     try {
45312       (arg1)->ScrollTo(arg2,arg3,arg4);
45313     } CALL_CATCH_EXCEPTION();
45314   }
45315
45316 }
45317
45318
45319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45321   Dali::Actor *arg2 = 0 ;
45322
45323   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45324   arg2 = (Dali::Actor *)jarg2;
45325   if (!arg2) {
45326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45327     return ;
45328   }
45329   {
45330     try {
45331       (arg1)->ScrollTo(*arg2);
45332     } CALL_CATCH_EXCEPTION();
45333   }
45334
45335 }
45336
45337
45338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45340   Dali::Actor *arg2 = 0 ;
45341   float arg3 ;
45342
45343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45344   arg2 = (Dali::Actor *)jarg2;
45345   if (!arg2) {
45346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45347     return ;
45348   }
45349   arg3 = (float)jarg3;
45350   {
45351     try {
45352       (arg1)->ScrollTo(*arg2,arg3);
45353     } CALL_CATCH_EXCEPTION();
45354   }
45355
45356 }
45357
45358
45359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45360   unsigned int jresult ;
45361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45362   bool result;
45363
45364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45365   {
45366     try {
45367       result = (bool)(arg1)->ScrollToSnapPoint();
45368     } CALL_CATCH_EXCEPTION(0);
45369   }
45370
45371   jresult = result;
45372   return jresult;
45373 }
45374
45375
45376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45377   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45378   Dali::Constraint arg2 ;
45379   Dali::Constraint *argp2 ;
45380
45381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45382   argp2 = (Dali::Constraint *)jarg2;
45383   if (!argp2) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45385     return ;
45386   }
45387   arg2 = *argp2;
45388   {
45389     try {
45390       (arg1)->ApplyConstraintToChildren(arg2);
45391     } CALL_CATCH_EXCEPTION();
45392   }
45393
45394 }
45395
45396
45397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45399
45400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45401   {
45402     try {
45403       (arg1)->RemoveConstraintsFromChildren();
45404     } CALL_CATCH_EXCEPTION();
45405   }
45406
45407 }
45408
45409
45410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45412   Dali::Toolkit::ScrollViewEffect arg2 ;
45413   Dali::Toolkit::ScrollViewEffect *argp2 ;
45414
45415   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45416   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45417   if (!argp2) {
45418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45419     return ;
45420   }
45421   arg2 = *argp2;
45422   {
45423     try {
45424       (arg1)->ApplyEffect(arg2);
45425     } CALL_CATCH_EXCEPTION();
45426   }
45427
45428 }
45429
45430
45431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45433   Dali::Toolkit::ScrollViewEffect arg2 ;
45434   Dali::Toolkit::ScrollViewEffect *argp2 ;
45435
45436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45437   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45438   if (!argp2) {
45439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45440     return ;
45441   }
45442   arg2 = *argp2;
45443   {
45444     try {
45445       (arg1)->RemoveEffect(arg2);
45446     } CALL_CATCH_EXCEPTION();
45447   }
45448
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45454
45455   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45456   {
45457     try {
45458       (arg1)->RemoveAllEffects();
45459     } CALL_CATCH_EXCEPTION();
45460   }
45461
45462 }
45463
45464
45465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45467   Dali::Actor arg2 ;
45468   Dali::Actor *argp2 ;
45469
45470   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45471   argp2 = (Dali::Actor *)jarg2;
45472   if (!argp2) {
45473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45474     return ;
45475   }
45476   arg2 = *argp2;
45477   {
45478     try {
45479       (arg1)->BindActor(arg2);
45480     } CALL_CATCH_EXCEPTION();
45481   }
45482
45483 }
45484
45485
45486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45488   Dali::Actor arg2 ;
45489   Dali::Actor *argp2 ;
45490
45491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45492   argp2 = (Dali::Actor *)jarg2;
45493   if (!argp2) {
45494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45495     return ;
45496   }
45497   arg2 = *argp2;
45498   {
45499     try {
45500       (arg1)->UnbindActor(arg2);
45501     } CALL_CATCH_EXCEPTION();
45502   }
45503
45504 }
45505
45506
45507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45508   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45509   Dali::Radian arg2 ;
45510   Dali::Radian arg3 ;
45511   Dali::Radian *argp2 ;
45512   Dali::Radian *argp3 ;
45513
45514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45515   argp2 = (Dali::Radian *)jarg2;
45516   if (!argp2) {
45517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45518     return ;
45519   }
45520   arg2 = *argp2;
45521   argp3 = (Dali::Radian *)jarg3;
45522   if (!argp3) {
45523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45524     return ;
45525   }
45526   arg3 = *argp3;
45527   {
45528     try {
45529       (arg1)->SetScrollingDirection(arg2,arg3);
45530     } CALL_CATCH_EXCEPTION();
45531   }
45532
45533 }
45534
45535
45536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45538   Dali::Radian arg2 ;
45539   Dali::Radian *argp2 ;
45540
45541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45542   argp2 = (Dali::Radian *)jarg2;
45543   if (!argp2) {
45544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45545     return ;
45546   }
45547   arg2 = *argp2;
45548   {
45549     try {
45550       (arg1)->SetScrollingDirection(arg2);
45551     } CALL_CATCH_EXCEPTION();
45552   }
45553
45554 }
45555
45556
45557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45559   Dali::Radian arg2 ;
45560   Dali::Radian *argp2 ;
45561
45562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45563   argp2 = (Dali::Radian *)jarg2;
45564   if (!argp2) {
45565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45566     return ;
45567   }
45568   arg2 = *argp2;
45569   {
45570     try {
45571       (arg1)->RemoveScrollingDirection(arg2);
45572     } CALL_CATCH_EXCEPTION();
45573   }
45574
45575 }
45576
45577
45578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45579   void * jresult ;
45580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45581   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45582
45583   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45584   {
45585     try {
45586       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45587     } CALL_CATCH_EXCEPTION(0);
45588   }
45589
45590   jresult = (void *)result;
45591   return jresult;
45592 }
45593
45594
45595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45596   int jresult ;
45597   int result;
45598
45599   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45600   jresult = (int)result;
45601   return jresult;
45602 }
45603
45604
45605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45606   int jresult ;
45607   int result;
45608
45609   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45610   jresult = (int)result;
45611   return jresult;
45612 }
45613
45614
45615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45616   int jresult ;
45617   int result;
45618
45619   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45620   jresult = (int)result;
45621   return jresult;
45622 }
45623
45624
45625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45626   int jresult ;
45627   int result;
45628
45629   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45630   jresult = (int)result;
45631   return jresult;
45632 }
45633
45634
45635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45636   int jresult ;
45637   int result;
45638
45639   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45640   jresult = (int)result;
45641   return jresult;
45642 }
45643
45644
45645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45646   void * jresult ;
45647   Dali::Toolkit::TableView::Property *result = 0 ;
45648
45649   {
45650     try {
45651       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45652     } CALL_CATCH_EXCEPTION(0);
45653   }
45654
45655   jresult = (void *)result;
45656   return jresult;
45657 }
45658
45659
45660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45661   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45662
45663   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45664   {
45665     try {
45666       delete arg1;
45667     } CALL_CATCH_EXCEPTION();
45668   }
45669
45670 }
45671
45672
45673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45674   int jresult ;
45675   int result;
45676
45677   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45678   jresult = (int)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45684   int jresult ;
45685   int result;
45686
45687   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45688   jresult = (int)result;
45689   return jresult;
45690 }
45691
45692
45693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45694   int jresult ;
45695   int result;
45696
45697   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45698   jresult = (int)result;
45699   return jresult;
45700 }
45701
45702
45703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45704   int jresult ;
45705   int result;
45706
45707   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45708   jresult = (int)result;
45709   return jresult;
45710 }
45711
45712
45713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45714   int jresult ;
45715   int result;
45716
45717   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45718   jresult = (int)result;
45719   return jresult;
45720 }
45721
45722
45723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45724   void * jresult ;
45725   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45726
45727   {
45728     try {
45729       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
45730     } CALL_CATCH_EXCEPTION(0);
45731   }
45732
45733   jresult = (void *)result;
45734   return jresult;
45735 }
45736
45737
45738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
45739   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
45740
45741   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
45742   {
45743     try {
45744       delete arg1;
45745     } CALL_CATCH_EXCEPTION();
45746   }
45747
45748 }
45749
45750
45751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
45752   void * jresult ;
45753   unsigned int arg1 ;
45754   unsigned int arg2 ;
45755   unsigned int arg3 ;
45756   unsigned int arg4 ;
45757   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45758
45759   arg1 = (unsigned int)jarg1;
45760   arg2 = (unsigned int)jarg2;
45761   arg3 = (unsigned int)jarg3;
45762   arg4 = (unsigned int)jarg4;
45763   {
45764     try {
45765       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
45766     } CALL_CATCH_EXCEPTION(0);
45767   }
45768
45769   jresult = (void *)result;
45770   return jresult;
45771 }
45772
45773
45774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
45775   void * jresult ;
45776   unsigned int arg1 ;
45777   unsigned int arg2 ;
45778   unsigned int arg3 ;
45779   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45780
45781   arg1 = (unsigned int)jarg1;
45782   arg2 = (unsigned int)jarg2;
45783   arg3 = (unsigned int)jarg3;
45784   {
45785     try {
45786       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
45787     } CALL_CATCH_EXCEPTION(0);
45788   }
45789
45790   jresult = (void *)result;
45791   return jresult;
45792 }
45793
45794
45795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
45796   void * jresult ;
45797   unsigned int arg1 ;
45798   unsigned int arg2 ;
45799   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45800
45801   arg1 = (unsigned int)jarg1;
45802   arg2 = (unsigned int)jarg2;
45803   {
45804     try {
45805       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
45806     } CALL_CATCH_EXCEPTION(0);
45807   }
45808
45809   jresult = (void *)result;
45810   return jresult;
45811 }
45812
45813
45814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
45815   void * jresult ;
45816   unsigned int arg1 ;
45817   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45818
45819   arg1 = (unsigned int)jarg1;
45820   {
45821     try {
45822       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
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_4() {
45832   void * jresult ;
45833   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45834
45835   {
45836     try {
45837       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
45838     } CALL_CATCH_EXCEPTION(0);
45839   }
45840
45841   jresult = (void *)result;
45842   return jresult;
45843 }
45844
45845
45846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
45847   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45848   unsigned int arg2 ;
45849
45850   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45851   arg2 = (unsigned int)jarg2;
45852   if (arg1) (arg1)->rowIndex = arg2;
45853 }
45854
45855
45856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
45857   unsigned int jresult ;
45858   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45859   unsigned int result;
45860
45861   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45862   result = (unsigned int) ((arg1)->rowIndex);
45863   jresult = result;
45864   return jresult;
45865 }
45866
45867
45868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
45869   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45870   unsigned int arg2 ;
45871
45872   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45873   arg2 = (unsigned int)jarg2;
45874   if (arg1) (arg1)->columnIndex = arg2;
45875 }
45876
45877
45878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
45879   unsigned int jresult ;
45880   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45881   unsigned int result;
45882
45883   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45884   result = (unsigned int) ((arg1)->columnIndex);
45885   jresult = result;
45886   return jresult;
45887 }
45888
45889
45890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
45891   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45892   unsigned int arg2 ;
45893
45894   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45895   arg2 = (unsigned int)jarg2;
45896   if (arg1) (arg1)->rowSpan = arg2;
45897 }
45898
45899
45900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
45901   unsigned int jresult ;
45902   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45903   unsigned int result;
45904
45905   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45906   result = (unsigned int) ((arg1)->rowSpan);
45907   jresult = result;
45908   return jresult;
45909 }
45910
45911
45912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
45913   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45914   unsigned int arg2 ;
45915
45916   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45917   arg2 = (unsigned int)jarg2;
45918   if (arg1) (arg1)->columnSpan = arg2;
45919 }
45920
45921
45922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
45923   unsigned int jresult ;
45924   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45925   unsigned int result;
45926
45927   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45928   result = (unsigned int) ((arg1)->columnSpan);
45929   jresult = result;
45930   return jresult;
45931 }
45932
45933
45934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
45935   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
45936
45937   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
45938   {
45939     try {
45940       delete arg1;
45941     } CALL_CATCH_EXCEPTION();
45942   }
45943
45944 }
45945
45946
45947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
45948   void * jresult ;
45949   Dali::Toolkit::TableView *result = 0 ;
45950
45951   {
45952     try {
45953       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
45954     } CALL_CATCH_EXCEPTION(0);
45955   }
45956
45957   jresult = (void *)result;
45958   return jresult;
45959 }
45960
45961
45962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
45963   void * jresult ;
45964   Dali::Toolkit::TableView *arg1 = 0 ;
45965   Dali::Toolkit::TableView *result = 0 ;
45966
45967   arg1 = (Dali::Toolkit::TableView *)jarg1;
45968   if (!arg1) {
45969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
45970     return 0;
45971   }
45972   {
45973     try {
45974       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
45975     } CALL_CATCH_EXCEPTION(0);
45976   }
45977
45978   jresult = (void *)result;
45979   return jresult;
45980 }
45981
45982
45983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
45984   void * jresult ;
45985   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
45986   Dali::Toolkit::TableView *arg2 = 0 ;
45987   Dali::Toolkit::TableView *result = 0 ;
45988
45989   arg1 = (Dali::Toolkit::TableView *)jarg1;
45990   arg2 = (Dali::Toolkit::TableView *)jarg2;
45991   if (!arg2) {
45992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
45993     return 0;
45994   }
45995   {
45996     try {
45997       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
45998     } CALL_CATCH_EXCEPTION(0);
45999   }
46000
46001   jresult = (void *)result;
46002   return jresult;
46003 }
46004
46005
46006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46007   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46008
46009   arg1 = (Dali::Toolkit::TableView *)jarg1;
46010   {
46011     try {
46012       delete arg1;
46013     } CALL_CATCH_EXCEPTION();
46014   }
46015
46016 }
46017
46018
46019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46020   void * jresult ;
46021   unsigned int arg1 ;
46022   unsigned int arg2 ;
46023   Dali::Toolkit::TableView result;
46024
46025   arg1 = (unsigned int)jarg1;
46026   arg2 = (unsigned int)jarg2;
46027   {
46028     try {
46029       result = Dali::Toolkit::TableView::New(arg1,arg2);
46030     } CALL_CATCH_EXCEPTION(0);
46031   }
46032
46033   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46034   return jresult;
46035 }
46036
46037
46038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46039   void * jresult ;
46040   Dali::BaseHandle arg1 ;
46041   Dali::BaseHandle *argp1 ;
46042   Dali::Toolkit::TableView result;
46043
46044   argp1 = (Dali::BaseHandle *)jarg1;
46045   if (!argp1) {
46046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46047     return 0;
46048   }
46049   arg1 = *argp1;
46050   {
46051     try {
46052       result = Dali::Toolkit::TableView::DownCast(arg1);
46053     } CALL_CATCH_EXCEPTION(0);
46054   }
46055
46056   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46062   unsigned int jresult ;
46063   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46064   Dali::Actor arg2 ;
46065   Dali::Toolkit::TableView::CellPosition arg3 ;
46066   Dali::Actor *argp2 ;
46067   Dali::Toolkit::TableView::CellPosition *argp3 ;
46068   bool result;
46069
46070   arg1 = (Dali::Toolkit::TableView *)jarg1;
46071   argp2 = (Dali::Actor *)jarg2;
46072   if (!argp2) {
46073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46074     return 0;
46075   }
46076   arg2 = *argp2;
46077   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46078   if (!argp3) {
46079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46080     return 0;
46081   }
46082   arg3 = *argp3;
46083   {
46084     try {
46085       result = (bool)(arg1)->AddChild(arg2,arg3);
46086     } CALL_CATCH_EXCEPTION(0);
46087   }
46088
46089   jresult = result;
46090   return jresult;
46091 }
46092
46093
46094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46095   void * jresult ;
46096   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46097   Dali::Toolkit::TableView::CellPosition arg2 ;
46098   Dali::Toolkit::TableView::CellPosition *argp2 ;
46099   Dali::Actor result;
46100
46101   arg1 = (Dali::Toolkit::TableView *)jarg1;
46102   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46103   if (!argp2) {
46104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46105     return 0;
46106   }
46107   arg2 = *argp2;
46108   {
46109     try {
46110       result = (arg1)->GetChildAt(arg2);
46111     } CALL_CATCH_EXCEPTION(0);
46112   }
46113
46114   jresult = new Dali::Actor((const Dali::Actor &)result);
46115   return jresult;
46116 }
46117
46118
46119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46120   void * jresult ;
46121   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46122   Dali::Toolkit::TableView::CellPosition arg2 ;
46123   Dali::Toolkit::TableView::CellPosition *argp2 ;
46124   Dali::Actor result;
46125
46126   arg1 = (Dali::Toolkit::TableView *)jarg1;
46127   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46128   if (!argp2) {
46129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46130     return 0;
46131   }
46132   arg2 = *argp2;
46133   {
46134     try {
46135       result = (arg1)->RemoveChildAt(arg2);
46136     } CALL_CATCH_EXCEPTION(0);
46137   }
46138
46139   jresult = new Dali::Actor((const Dali::Actor &)result);
46140   return jresult;
46141 }
46142
46143
46144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46145   unsigned int jresult ;
46146   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46147   Dali::Actor arg2 ;
46148   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46149   Dali::Actor *argp2 ;
46150   bool result;
46151
46152   arg1 = (Dali::Toolkit::TableView *)jarg1;
46153   argp2 = (Dali::Actor *)jarg2;
46154   if (!argp2) {
46155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46156     return 0;
46157   }
46158   arg2 = *argp2;
46159   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46160   if (!arg3) {
46161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46162     return 0;
46163   }
46164   {
46165     try {
46166       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46167     } CALL_CATCH_EXCEPTION(0);
46168   }
46169
46170   jresult = result;
46171   return jresult;
46172 }
46173
46174
46175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46176   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46177   unsigned int arg2 ;
46178
46179   arg1 = (Dali::Toolkit::TableView *)jarg1;
46180   arg2 = (unsigned int)jarg2;
46181   {
46182     try {
46183       (arg1)->InsertRow(arg2);
46184     } CALL_CATCH_EXCEPTION();
46185   }
46186
46187 }
46188
46189
46190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46192   unsigned int arg2 ;
46193
46194   arg1 = (Dali::Toolkit::TableView *)jarg1;
46195   arg2 = (unsigned int)jarg2;
46196   {
46197     try {
46198       (arg1)->DeleteRow(arg2);
46199     } CALL_CATCH_EXCEPTION();
46200   }
46201
46202 }
46203
46204
46205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46206   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46207   unsigned int arg2 ;
46208   std::vector< Dali::Actor > *arg3 = 0 ;
46209
46210   arg1 = (Dali::Toolkit::TableView *)jarg1;
46211   arg2 = (unsigned int)jarg2;
46212   arg3 = (std::vector< Dali::Actor > *)jarg3;
46213   if (!arg3) {
46214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46215     return ;
46216   }
46217   {
46218     try {
46219       (arg1)->DeleteRow(arg2,*arg3);
46220     } CALL_CATCH_EXCEPTION();
46221   }
46222
46223 }
46224
46225
46226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(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)->InsertColumn(arg2);
46235     } CALL_CATCH_EXCEPTION();
46236   }
46237
46238 }
46239
46240
46241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46242   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46243   unsigned int arg2 ;
46244
46245   arg1 = (Dali::Toolkit::TableView *)jarg1;
46246   arg2 = (unsigned int)jarg2;
46247   {
46248     try {
46249       (arg1)->DeleteColumn(arg2);
46250     } CALL_CATCH_EXCEPTION();
46251   }
46252
46253 }
46254
46255
46256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46257   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46258   unsigned int arg2 ;
46259   std::vector< Dali::Actor > *arg3 = 0 ;
46260
46261   arg1 = (Dali::Toolkit::TableView *)jarg1;
46262   arg2 = (unsigned int)jarg2;
46263   arg3 = (std::vector< Dali::Actor > *)jarg3;
46264   if (!arg3) {
46265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46266     return ;
46267   }
46268   {
46269     try {
46270       (arg1)->DeleteColumn(arg2,*arg3);
46271     } CALL_CATCH_EXCEPTION();
46272   }
46273
46274 }
46275
46276
46277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46279   unsigned int arg2 ;
46280   unsigned int arg3 ;
46281
46282   arg1 = (Dali::Toolkit::TableView *)jarg1;
46283   arg2 = (unsigned int)jarg2;
46284   arg3 = (unsigned int)jarg3;
46285   {
46286     try {
46287       (arg1)->Resize(arg2,arg3);
46288     } CALL_CATCH_EXCEPTION();
46289   }
46290
46291 }
46292
46293
46294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46295   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46296   unsigned int arg2 ;
46297   unsigned int arg3 ;
46298   std::vector< Dali::Actor > *arg4 = 0 ;
46299
46300   arg1 = (Dali::Toolkit::TableView *)jarg1;
46301   arg2 = (unsigned int)jarg2;
46302   arg3 = (unsigned int)jarg3;
46303   arg4 = (std::vector< Dali::Actor > *)jarg4;
46304   if (!arg4) {
46305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46306     return ;
46307   }
46308   {
46309     try {
46310       (arg1)->Resize(arg2,arg3,*arg4);
46311     } CALL_CATCH_EXCEPTION();
46312   }
46313
46314 }
46315
46316
46317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46318   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46319   Dali::Size arg2 ;
46320   Dali::Size *argp2 ;
46321
46322   arg1 = (Dali::Toolkit::TableView *)jarg1;
46323   argp2 = (Dali::Size *)jarg2;
46324   if (!argp2) {
46325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46326     return ;
46327   }
46328   arg2 = *argp2;
46329   {
46330     try {
46331       (arg1)->SetCellPadding(arg2);
46332     } CALL_CATCH_EXCEPTION();
46333   }
46334
46335 }
46336
46337
46338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46339   void * jresult ;
46340   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46341   Dali::Size result;
46342
46343   arg1 = (Dali::Toolkit::TableView *)jarg1;
46344   {
46345     try {
46346       result = (arg1)->GetCellPadding();
46347     } CALL_CATCH_EXCEPTION(0);
46348   }
46349
46350   jresult = new Dali::Size((const Dali::Size &)result);
46351   return jresult;
46352 }
46353
46354
46355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46356   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46357   unsigned int arg2 ;
46358
46359   arg1 = (Dali::Toolkit::TableView *)jarg1;
46360   arg2 = (unsigned int)jarg2;
46361   {
46362     try {
46363       (arg1)->SetFitHeight(arg2);
46364     } CALL_CATCH_EXCEPTION();
46365   }
46366
46367 }
46368
46369
46370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46371   unsigned int jresult ;
46372   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46373   unsigned int arg2 ;
46374   bool result;
46375
46376   arg1 = (Dali::Toolkit::TableView *)jarg1;
46377   arg2 = (unsigned int)jarg2;
46378   {
46379     try {
46380       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46381     } CALL_CATCH_EXCEPTION(0);
46382   }
46383
46384   jresult = result;
46385   return jresult;
46386 }
46387
46388
46389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46390   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46391   unsigned int arg2 ;
46392
46393   arg1 = (Dali::Toolkit::TableView *)jarg1;
46394   arg2 = (unsigned int)jarg2;
46395   {
46396     try {
46397       (arg1)->SetFitWidth(arg2);
46398     } CALL_CATCH_EXCEPTION();
46399   }
46400
46401 }
46402
46403
46404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46405   unsigned int jresult ;
46406   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46407   unsigned int arg2 ;
46408   bool result;
46409
46410   arg1 = (Dali::Toolkit::TableView *)jarg1;
46411   arg2 = (unsigned int)jarg2;
46412   {
46413     try {
46414       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46415     } CALL_CATCH_EXCEPTION(0);
46416   }
46417
46418   jresult = result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46424   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46425   unsigned int arg2 ;
46426   float arg3 ;
46427
46428   arg1 = (Dali::Toolkit::TableView *)jarg1;
46429   arg2 = (unsigned int)jarg2;
46430   arg3 = (float)jarg3;
46431   {
46432     try {
46433       (arg1)->SetFixedHeight(arg2,arg3);
46434     } CALL_CATCH_EXCEPTION();
46435   }
46436
46437 }
46438
46439
46440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46441   float jresult ;
46442   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46443   unsigned int arg2 ;
46444   float result;
46445
46446   arg1 = (Dali::Toolkit::TableView *)jarg1;
46447   arg2 = (unsigned int)jarg2;
46448   {
46449     try {
46450       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46451     } CALL_CATCH_EXCEPTION(0);
46452   }
46453
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(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)->SetRelativeHeight(arg2,arg3);
46470     } CALL_CATCH_EXCEPTION();
46471   }
46472
46473 }
46474
46475
46476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(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)->GetRelativeHeight(arg2);
46487     } CALL_CATCH_EXCEPTION(0);
46488   }
46489
46490   jresult = result;
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(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)->SetFixedWidth(arg2,arg3);
46506     } CALL_CATCH_EXCEPTION();
46507   }
46508
46509 }
46510
46511
46512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(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)->GetFixedWidth(arg2);
46523     } CALL_CATCH_EXCEPTION(0);
46524   }
46525
46526   jresult = result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(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)->SetRelativeWidth(arg2,arg3);
46542     } CALL_CATCH_EXCEPTION();
46543   }
46544
46545 }
46546
46547
46548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(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)->GetRelativeWidth(arg2);
46559     } CALL_CATCH_EXCEPTION(0);
46560   }
46561
46562   jresult = result;
46563   return jresult;
46564 }
46565
46566
46567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46568   unsigned int jresult ;
46569   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46570   unsigned int result;
46571
46572   arg1 = (Dali::Toolkit::TableView *)jarg1;
46573   {
46574     try {
46575       result = (unsigned int)(arg1)->GetRows();
46576     } CALL_CATCH_EXCEPTION(0);
46577   }
46578
46579   jresult = result;
46580   return jresult;
46581 }
46582
46583
46584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
46585   unsigned int jresult ;
46586   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46587   unsigned int result;
46588
46589   arg1 = (Dali::Toolkit::TableView *)jarg1;
46590   {
46591     try {
46592       result = (unsigned int)(arg1)->GetColumns();
46593     } CALL_CATCH_EXCEPTION(0);
46594   }
46595
46596   jresult = result;
46597   return jresult;
46598 }
46599
46600
46601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46602   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46603   Dali::Toolkit::TableView::CellPosition arg2 ;
46604   Dali::HorizontalAlignment::Type arg3 ;
46605   Dali::VerticalAlignment::Type arg4 ;
46606   Dali::Toolkit::TableView::CellPosition *argp2 ;
46607
46608   arg1 = (Dali::Toolkit::TableView *)jarg1;
46609   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46610   if (!argp2) {
46611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46612     return ;
46613   }
46614   arg2 = *argp2;
46615   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46616   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46617   {
46618     try {
46619       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46620     } CALL_CATCH_EXCEPTION();
46621   }
46622
46623 }
46624
46625
46626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46627   unsigned int jresult ;
46628   unsigned int result;
46629
46630   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46631   jresult = result;
46632   return jresult;
46633 }
46634
46635
46636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46637   int jresult ;
46638   int result;
46639
46640   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46641   jresult = (int)result;
46642   return jresult;
46643 }
46644
46645
46646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46647   int jresult ;
46648   int result;
46649
46650   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46651   jresult = (int)result;
46652   return jresult;
46653 }
46654
46655
46656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46657   int jresult ;
46658   int result;
46659
46660   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46661   jresult = (int)result;
46662   return jresult;
46663 }
46664
46665
46666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46667   int jresult ;
46668   int result;
46669
46670   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46671   jresult = (int)result;
46672   return jresult;
46673 }
46674
46675
46676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46677   int jresult ;
46678   int result;
46679
46680   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46681   jresult = (int)result;
46682   return jresult;
46683 }
46684
46685
46686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46687   int jresult ;
46688   int result;
46689
46690   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46691   jresult = (int)result;
46692   return jresult;
46693 }
46694
46695
46696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46697   int jresult ;
46698   int result;
46699
46700   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46701   jresult = (int)result;
46702   return jresult;
46703 }
46704
46705
46706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46707   int jresult ;
46708   int result;
46709
46710   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46711   jresult = (int)result;
46712   return jresult;
46713 }
46714
46715
46716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46717   int jresult ;
46718   int result;
46719
46720   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46721   jresult = (int)result;
46722   return jresult;
46723 }
46724
46725
46726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
46727   int jresult ;
46728   int result;
46729
46730   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
46731   jresult = (int)result;
46732   return jresult;
46733 }
46734
46735
46736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
46737   int jresult ;
46738   int result;
46739
46740   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
46741   jresult = (int)result;
46742   return jresult;
46743 }
46744
46745
46746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
46747   int jresult ;
46748   int result;
46749
46750   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
46751   jresult = (int)result;
46752   return jresult;
46753 }
46754
46755
46756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
46757   int jresult ;
46758   int result;
46759
46760   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
46761   jresult = (int)result;
46762   return jresult;
46763 }
46764
46765
46766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
46767   int jresult ;
46768   int result;
46769
46770   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
46771   jresult = (int)result;
46772   return jresult;
46773 }
46774
46775
46776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
46777   int jresult ;
46778   int result;
46779
46780   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
46781   jresult = (int)result;
46782   return jresult;
46783 }
46784
46785
46786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
46787   int jresult ;
46788   int result;
46789
46790   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
46791   jresult = (int)result;
46792   return jresult;
46793 }
46794
46795
46796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
46797   int jresult ;
46798   int result;
46799
46800   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
46801   jresult = (int)result;
46802   return jresult;
46803 }
46804
46805
46806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
46807   int jresult ;
46808   int result;
46809
46810   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
46811   jresult = (int)result;
46812   return jresult;
46813 }
46814
46815
46816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
46817   void * jresult ;
46818   Dali::Toolkit::TextLabel::Property *result = 0 ;
46819
46820   {
46821     try {
46822       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
46823     } CALL_CATCH_EXCEPTION(0);
46824   }
46825
46826   jresult = (void *)result;
46827   return jresult;
46828 }
46829
46830
46831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
46832   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
46833
46834   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
46835   {
46836     try {
46837       delete arg1;
46838     } CALL_CATCH_EXCEPTION();
46839   }
46840
46841 }
46842
46843
46844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
46845   void * jresult ;
46846   Dali::Toolkit::TextLabel result;
46847
46848   {
46849     try {
46850       result = Dali::Toolkit::TextLabel::New();
46851     } CALL_CATCH_EXCEPTION(0);
46852   }
46853
46854   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
46855   return jresult;
46856 }
46857
46858
46859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
46860   void * jresult ;
46861   std::string *arg1 = 0 ;
46862   Dali::Toolkit::TextLabel result;
46863
46864   if (!jarg1) {
46865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46866     return 0;
46867   }
46868   std::string arg1_str(jarg1);
46869   arg1 = &arg1_str;
46870   {
46871     try {
46872       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
46873     } CALL_CATCH_EXCEPTION(0);
46874   }
46875
46876   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
46877
46878   //argout typemap for const std::string&
46879
46880   return jresult;
46881 }
46882
46883
46884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
46885   void * jresult ;
46886   Dali::Toolkit::TextLabel *result = 0 ;
46887
46888   {
46889     try {
46890       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
46891     } CALL_CATCH_EXCEPTION(0);
46892   }
46893
46894   jresult = (void *)result;
46895   return jresult;
46896 }
46897
46898
46899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
46900   void * jresult ;
46901   Dali::Toolkit::TextLabel *arg1 = 0 ;
46902   Dali::Toolkit::TextLabel *result = 0 ;
46903
46904   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46905   if (!arg1) {
46906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
46907     return 0;
46908   }
46909   {
46910     try {
46911       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
46912     } CALL_CATCH_EXCEPTION(0);
46913   }
46914
46915   jresult = (void *)result;
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
46921   void * jresult ;
46922   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
46923   Dali::Toolkit::TextLabel *arg2 = 0 ;
46924   Dali::Toolkit::TextLabel *result = 0 ;
46925
46926   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46927   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
46928   if (!arg2) {
46929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
46930     return 0;
46931   }
46932   {
46933     try {
46934       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
46935     } CALL_CATCH_EXCEPTION(0);
46936   }
46937
46938   jresult = (void *)result;
46939   return jresult;
46940 }
46941
46942
46943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
46944   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
46945
46946   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
46947   {
46948     try {
46949       delete arg1;
46950     } CALL_CATCH_EXCEPTION();
46951   }
46952
46953 }
46954
46955
46956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
46957   void * jresult ;
46958   Dali::BaseHandle arg1 ;
46959   Dali::BaseHandle *argp1 ;
46960   Dali::Toolkit::TextLabel result;
46961
46962   argp1 = (Dali::BaseHandle *)jarg1;
46963   if (!argp1) {
46964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46965     return 0;
46966   }
46967   arg1 = *argp1;
46968   {
46969     try {
46970       result = Dali::Toolkit::TextLabel::DownCast(arg1);
46971     } CALL_CATCH_EXCEPTION(0);
46972   }
46973
46974   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
46975   return jresult;
46976 }
46977
46978
46979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
46980   void * jresult ;
46981   Dali::Toolkit::AccessibilityManager *result = 0 ;
46982
46983   {
46984     try {
46985       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
46986     } CALL_CATCH_EXCEPTION(0);
46987   }
46988
46989   jresult = (void *)result;
46990   return jresult;
46991 }
46992
46993
46994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
46995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
46996
46997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
46998   {
46999     try {
47000       delete arg1;
47001     } CALL_CATCH_EXCEPTION();
47002   }
47003
47004 }
47005
47006
47007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47008   void * jresult ;
47009   Dali::Toolkit::AccessibilityManager result;
47010
47011   {
47012     try {
47013       result = Dali::Toolkit::AccessibilityManager::Get();
47014     } CALL_CATCH_EXCEPTION(0);
47015   }
47016
47017   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47023   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47024   Dali::Actor arg2 ;
47025   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47026   std::string *arg4 = 0 ;
47027   Dali::Actor *argp2 ;
47028
47029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47030   argp2 = (Dali::Actor *)jarg2;
47031   if (!argp2) {
47032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47033     return ;
47034   }
47035   arg2 = *argp2;
47036   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47037   if (!jarg4) {
47038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47039     return ;
47040   }
47041   std::string arg4_str(jarg4);
47042   arg4 = &arg4_str;
47043   {
47044     try {
47045       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47046     } CALL_CATCH_EXCEPTION();
47047   }
47048
47049
47050   //argout typemap for const std::string&
47051
47052 }
47053
47054
47055 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47056   char * jresult ;
47057   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47058   Dali::Actor arg2 ;
47059   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47060   Dali::Actor *argp2 ;
47061   std::string result;
47062
47063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47064   argp2 = (Dali::Actor *)jarg2;
47065   if (!argp2) {
47066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47067     return 0;
47068   }
47069   arg2 = *argp2;
47070   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47071   {
47072     try {
47073       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47074     } CALL_CATCH_EXCEPTION(0);
47075   }
47076
47077   jresult = SWIG_csharp_string_callback((&result)->c_str());
47078   return jresult;
47079 }
47080
47081
47082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47084   Dali::Actor arg2 ;
47085   unsigned int arg3 ;
47086   Dali::Actor *argp2 ;
47087
47088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47089   argp2 = (Dali::Actor *)jarg2;
47090   if (!argp2) {
47091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47092     return ;
47093   }
47094   arg2 = *argp2;
47095   arg3 = (unsigned int)jarg3;
47096   {
47097     try {
47098       (arg1)->SetFocusOrder(arg2,arg3);
47099     } CALL_CATCH_EXCEPTION();
47100   }
47101
47102 }
47103
47104
47105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47106   unsigned int jresult ;
47107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47108   Dali::Actor arg2 ;
47109   Dali::Actor *argp2 ;
47110   unsigned int result;
47111
47112   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47113   argp2 = (Dali::Actor *)jarg2;
47114   if (!argp2) {
47115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47116     return 0;
47117   }
47118   arg2 = *argp2;
47119   {
47120     try {
47121       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47122     } CALL_CATCH_EXCEPTION(0);
47123   }
47124
47125   jresult = result;
47126   return jresult;
47127 }
47128
47129
47130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47131   unsigned int jresult ;
47132   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47133   unsigned int result;
47134
47135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47136   {
47137     try {
47138       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47139     } CALL_CATCH_EXCEPTION(0);
47140   }
47141
47142   jresult = result;
47143   return jresult;
47144 }
47145
47146
47147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47148   void * jresult ;
47149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47150   unsigned int arg2 ;
47151   Dali::Actor result;
47152
47153   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47154   arg2 = (unsigned int)jarg2;
47155   {
47156     try {
47157       result = (arg1)->GetActorByFocusOrder(arg2);
47158     } CALL_CATCH_EXCEPTION(0);
47159   }
47160
47161   jresult = new Dali::Actor((const Dali::Actor &)result);
47162   return jresult;
47163 }
47164
47165
47166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47167   unsigned int jresult ;
47168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47169   Dali::Actor arg2 ;
47170   Dali::Actor *argp2 ;
47171   bool result;
47172
47173   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47174   argp2 = (Dali::Actor *)jarg2;
47175   if (!argp2) {
47176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47177     return 0;
47178   }
47179   arg2 = *argp2;
47180   {
47181     try {
47182       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47183     } CALL_CATCH_EXCEPTION(0);
47184   }
47185
47186   jresult = result;
47187   return jresult;
47188 }
47189
47190
47191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47192   void * jresult ;
47193   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47194   Dali::Actor result;
47195
47196   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47197   {
47198     try {
47199       result = (arg1)->GetCurrentFocusActor();
47200     } CALL_CATCH_EXCEPTION(0);
47201   }
47202
47203   jresult = new Dali::Actor((const Dali::Actor &)result);
47204   return jresult;
47205 }
47206
47207
47208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47209   void * jresult ;
47210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47211   Dali::Actor result;
47212
47213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47214   {
47215     try {
47216       result = (arg1)->GetCurrentFocusGroup();
47217     } CALL_CATCH_EXCEPTION(0);
47218   }
47219
47220   jresult = new Dali::Actor((const Dali::Actor &)result);
47221   return jresult;
47222 }
47223
47224
47225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47226   unsigned int jresult ;
47227   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47228   unsigned int result;
47229
47230   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47231   {
47232     try {
47233       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47234     } CALL_CATCH_EXCEPTION(0);
47235   }
47236
47237   jresult = result;
47238   return jresult;
47239 }
47240
47241
47242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47243   unsigned int jresult ;
47244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47245   bool result;
47246
47247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47248   {
47249     try {
47250       result = (bool)(arg1)->MoveFocusForward();
47251     } CALL_CATCH_EXCEPTION(0);
47252   }
47253
47254   jresult = result;
47255   return jresult;
47256 }
47257
47258
47259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
47260   unsigned int jresult ;
47261   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47262   bool result;
47263
47264   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47265   {
47266     try {
47267       result = (bool)(arg1)->MoveFocusBackward();
47268     } CALL_CATCH_EXCEPTION(0);
47269   }
47270
47271   jresult = result;
47272   return jresult;
47273 }
47274
47275
47276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47278
47279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47280   {
47281     try {
47282       (arg1)->ClearFocus();
47283     } CALL_CATCH_EXCEPTION();
47284   }
47285
47286 }
47287
47288
47289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47291
47292   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47293   {
47294     try {
47295       (arg1)->Reset();
47296     } CALL_CATCH_EXCEPTION();
47297   }
47298
47299 }
47300
47301
47302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47304   Dali::Actor arg2 ;
47305   bool arg3 ;
47306   Dali::Actor *argp2 ;
47307
47308   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47309   argp2 = (Dali::Actor *)jarg2;
47310   if (!argp2) {
47311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47312     return ;
47313   }
47314   arg2 = *argp2;
47315   arg3 = jarg3 ? true : false;
47316   {
47317     try {
47318       (arg1)->SetFocusGroup(arg2,arg3);
47319     } CALL_CATCH_EXCEPTION();
47320   }
47321
47322 }
47323
47324
47325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
47326   unsigned int jresult ;
47327   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47328   Dali::Actor arg2 ;
47329   Dali::Actor *argp2 ;
47330   bool result;
47331
47332   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47333   argp2 = (Dali::Actor *)jarg2;
47334   if (!argp2) {
47335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47336     return 0;
47337   }
47338   arg2 = *argp2;
47339   {
47340     try {
47341       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47342     } CALL_CATCH_EXCEPTION(0);
47343   }
47344
47345   jresult = result;
47346   return jresult;
47347 }
47348
47349
47350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47352   bool arg2 ;
47353
47354   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47355   arg2 = jarg2 ? true : false;
47356   {
47357     try {
47358       (arg1)->SetGroupMode(arg2);
47359     } CALL_CATCH_EXCEPTION();
47360   }
47361
47362 }
47363
47364
47365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47366   unsigned int jresult ;
47367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47368   bool result;
47369
47370   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47371   {
47372     try {
47373       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47374     } CALL_CATCH_EXCEPTION(0);
47375   }
47376
47377   jresult = result;
47378   return jresult;
47379 }
47380
47381
47382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47383   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47384   bool arg2 ;
47385
47386   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47387   arg2 = jarg2 ? true : false;
47388   {
47389     try {
47390       (arg1)->SetWrapMode(arg2);
47391     } CALL_CATCH_EXCEPTION();
47392   }
47393
47394 }
47395
47396
47397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47398   unsigned int jresult ;
47399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47400   bool result;
47401
47402   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47403   {
47404     try {
47405       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47406     } CALL_CATCH_EXCEPTION(0);
47407   }
47408
47409   jresult = result;
47410   return jresult;
47411 }
47412
47413
47414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47416   Dali::Actor arg2 ;
47417   Dali::Actor *argp2 ;
47418
47419   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47420   argp2 = (Dali::Actor *)jarg2;
47421   if (!argp2) {
47422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47423     return ;
47424   }
47425   arg2 = *argp2;
47426   {
47427     try {
47428       (arg1)->SetFocusIndicatorActor(arg2);
47429     } CALL_CATCH_EXCEPTION();
47430   }
47431
47432 }
47433
47434
47435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47436   void * jresult ;
47437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47438   Dali::Actor result;
47439
47440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47441   {
47442     try {
47443       result = (arg1)->GetFocusIndicatorActor();
47444     } CALL_CATCH_EXCEPTION(0);
47445   }
47446
47447   jresult = new Dali::Actor((const Dali::Actor &)result);
47448   return jresult;
47449 }
47450
47451
47452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47453   void * jresult ;
47454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47455   Dali::Actor arg2 ;
47456   Dali::Actor *argp2 ;
47457   Dali::Actor result;
47458
47459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47460   argp2 = (Dali::Actor *)jarg2;
47461   if (!argp2) {
47462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47463     return 0;
47464   }
47465   arg2 = *argp2;
47466   {
47467     try {
47468       result = (arg1)->GetFocusGroup(arg2);
47469     } CALL_CATCH_EXCEPTION(0);
47470   }
47471
47472   jresult = new Dali::Actor((const Dali::Actor &)result);
47473   return jresult;
47474 }
47475
47476
47477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47478   void * jresult ;
47479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47480   Dali::Vector2 result;
47481
47482   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47483   {
47484     try {
47485       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47486     } CALL_CATCH_EXCEPTION(0);
47487   }
47488
47489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47490   return jresult;
47491 }
47492
47493
47494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47495   void * jresult ;
47496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47497   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47498
47499   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47500   {
47501     try {
47502       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47503     } CALL_CATCH_EXCEPTION(0);
47504   }
47505
47506   jresult = (void *)result;
47507   return jresult;
47508 }
47509
47510
47511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47512   void * jresult ;
47513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47514   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47515
47516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47517   {
47518     try {
47519       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47520     } CALL_CATCH_EXCEPTION(0);
47521   }
47522
47523   jresult = (void *)result;
47524   return jresult;
47525 }
47526
47527
47528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47529   void * jresult ;
47530   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47531   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47532
47533   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47534   {
47535     try {
47536       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47537     } CALL_CATCH_EXCEPTION(0);
47538   }
47539
47540   jresult = (void *)result;
47541   return jresult;
47542 }
47543
47544
47545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47546   void * jresult ;
47547   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47548   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47549
47550   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47551   {
47552     try {
47553       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47554     } CALL_CATCH_EXCEPTION(0);
47555   }
47556
47557   jresult = (void *)result;
47558   return jresult;
47559 }
47560
47561
47562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
47563   void * jresult ;
47564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47565   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47566
47567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47568   {
47569     try {
47570       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
47571     } CALL_CATCH_EXCEPTION(0);
47572   }
47573
47574   jresult = (void *)result;
47575   return jresult;
47576 }
47577
47578
47579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
47580   void * jresult ;
47581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47582   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47583
47584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47585   {
47586     try {
47587       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
47588     } CALL_CATCH_EXCEPTION(0);
47589   }
47590
47591   jresult = (void *)result;
47592   return jresult;
47593 }
47594
47595
47596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
47597   void * jresult ;
47598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47599   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47600
47601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47602   {
47603     try {
47604       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
47605     } CALL_CATCH_EXCEPTION(0);
47606   }
47607
47608   jresult = (void *)result;
47609   return jresult;
47610 }
47611
47612
47613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
47614   void * jresult ;
47615   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47616   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47617
47618   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47619   {
47620     try {
47621       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
47622     } CALL_CATCH_EXCEPTION(0);
47623   }
47624
47625   jresult = (void *)result;
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
47631   void * jresult ;
47632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47633   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47634
47635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47636   {
47637     try {
47638       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
47639     } CALL_CATCH_EXCEPTION(0);
47640   }
47641
47642   jresult = (void *)result;
47643   return jresult;
47644 }
47645
47646
47647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
47648   void * jresult ;
47649   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47650   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47651
47652   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47653   {
47654     try {
47655       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
47656     } CALL_CATCH_EXCEPTION(0);
47657   }
47658
47659   jresult = (void *)result;
47660   return jresult;
47661 }
47662
47663
47664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
47665   void * jresult ;
47666   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47667   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47668
47669   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47670   {
47671     try {
47672       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
47673     } CALL_CATCH_EXCEPTION(0);
47674   }
47675
47676   jresult = (void *)result;
47677   return jresult;
47678 }
47679
47680
47681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
47682   void * jresult ;
47683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47684   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47685
47686   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47687   {
47688     try {
47689       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
47690     } CALL_CATCH_EXCEPTION(0);
47691   }
47692
47693   jresult = (void *)result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
47699   void * jresult ;
47700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47701   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47702
47703   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47704   {
47705     try {
47706       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
47707     } CALL_CATCH_EXCEPTION(0);
47708   }
47709
47710   jresult = (void *)result;
47711   return jresult;
47712 }
47713
47714
47715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
47716   void * jresult ;
47717   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47718   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47719
47720   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47721   {
47722     try {
47723       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
47724     } CALL_CATCH_EXCEPTION(0);
47725   }
47726
47727   jresult = (void *)result;
47728   return jresult;
47729 }
47730
47731
47732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
47733   void * jresult ;
47734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47735   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47736
47737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47738   {
47739     try {
47740       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
47741     } CALL_CATCH_EXCEPTION(0);
47742   }
47743
47744   jresult = (void *)result;
47745   return jresult;
47746 }
47747
47748
47749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
47750   void * jresult ;
47751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47753
47754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47755   {
47756     try {
47757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
47758     } CALL_CATCH_EXCEPTION(0);
47759   }
47760
47761   jresult = (void *)result;
47762   return jresult;
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
47767   void * jresult ;
47768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47769   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47770
47771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47772   {
47773     try {
47774       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
47775     } CALL_CATCH_EXCEPTION(0);
47776   }
47777
47778   jresult = (void *)result;
47779   return jresult;
47780 }
47781
47782
47783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
47784   void * jresult ;
47785   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47786   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47787
47788   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47789   {
47790     try {
47791       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
47792     } CALL_CATCH_EXCEPTION(0);
47793   }
47794
47795   jresult = (void *)result;
47796   return jresult;
47797 }
47798
47799
47800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
47801   void * jresult ;
47802   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47803   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47804
47805   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47806   {
47807     try {
47808       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
47809     } CALL_CATCH_EXCEPTION(0);
47810   }
47811
47812   jresult = (void *)result;
47813   return jresult;
47814 }
47815
47816
47817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
47818   void * jresult ;
47819   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47820   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47821
47822   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47823   {
47824     try {
47825       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
47826     } CALL_CATCH_EXCEPTION(0);
47827   }
47828
47829   jresult = (void *)result;
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
47835   void * jresult ;
47836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47837   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47838
47839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47840   {
47841     try {
47842       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
47843     } CALL_CATCH_EXCEPTION(0);
47844   }
47845
47846   jresult = (void *)result;
47847   return jresult;
47848 }
47849
47850
47851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
47852   void * jresult ;
47853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47854   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47855
47856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47857   {
47858     try {
47859       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
47860     } CALL_CATCH_EXCEPTION(0);
47861   }
47862
47863   jresult = (void *)result;
47864   return jresult;
47865 }
47866
47867
47868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
47869   void * jresult ;
47870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47871   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47872
47873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47874   {
47875     try {
47876       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
47877     } CALL_CATCH_EXCEPTION(0);
47878   }
47879
47880   jresult = (void *)result;
47881   return jresult;
47882 }
47883
47884
47885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
47886   void * jresult ;
47887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47888   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47889
47890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47891   {
47892     try {
47893       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
47894     } CALL_CATCH_EXCEPTION(0);
47895   }
47896
47897   jresult = (void *)result;
47898   return jresult;
47899 }
47900
47901
47902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
47903   void * jresult ;
47904   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47905   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47906
47907   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47908   {
47909     try {
47910       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
47911     } CALL_CATCH_EXCEPTION(0);
47912   }
47913
47914   jresult = (void *)result;
47915   return jresult;
47916 }
47917
47918
47919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
47920   void * jresult ;
47921   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47922   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47923
47924   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47925   {
47926     try {
47927       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
47928     } CALL_CATCH_EXCEPTION(0);
47929   }
47930
47931   jresult = (void *)result;
47932   return jresult;
47933 }
47934
47935
47936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
47937   void * jresult ;
47938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47939   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47940
47941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47942   {
47943     try {
47944       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
47945     } CALL_CATCH_EXCEPTION(0);
47946   }
47947
47948   jresult = (void *)result;
47949   return jresult;
47950 }
47951
47952
47953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
47954   void * jresult ;
47955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47956   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47957
47958   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47959   {
47960     try {
47961       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
47962     } CALL_CATCH_EXCEPTION(0);
47963   }
47964
47965   jresult = (void *)result;
47966   return jresult;
47967 }
47968
47969
47970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
47971   void * jresult ;
47972   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47973   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
47974
47975   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47976   {
47977     try {
47978       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
47979     } CALL_CATCH_EXCEPTION(0);
47980   }
47981
47982   jresult = (void *)result;
47983   return jresult;
47984 }
47985
47986
47987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
47988   void * jresult ;
47989   Dali::Toolkit::StyleManager *result = 0 ;
47990
47991   {
47992     try {
47993       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
47994     } CALL_CATCH_EXCEPTION(0);
47995   }
47996
47997   jresult = (void *)result;
47998   return jresult;
47999 }
48000
48001
48002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48003   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48004
48005   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48006   {
48007     try {
48008       delete arg1;
48009     } CALL_CATCH_EXCEPTION();
48010   }
48011
48012 }
48013
48014
48015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48016   void * jresult ;
48017   Dali::Toolkit::StyleManager result;
48018
48019   {
48020     try {
48021       result = Dali::Toolkit::StyleManager::Get();
48022     } CALL_CATCH_EXCEPTION(0);
48023   }
48024
48025   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48031   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48032   std::string *arg2 = 0 ;
48033
48034   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48035   if (!jarg2) {
48036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48037     return ;
48038   }
48039   std::string arg2_str(jarg2);
48040   arg2 = &arg2_str;
48041   {
48042     try {
48043       (arg1)->ApplyTheme((std::string const &)*arg2);
48044     } CALL_CATCH_EXCEPTION();
48045   }
48046
48047
48048   //argout typemap for const std::string&
48049
48050 }
48051
48052
48053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48054   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48055
48056   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48057   {
48058     try {
48059       (arg1)->ApplyDefaultTheme();
48060     } CALL_CATCH_EXCEPTION();
48061   }
48062
48063 }
48064
48065
48066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48067   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48068   std::string *arg2 = 0 ;
48069   Dali::Property::Value *arg3 = 0 ;
48070
48071   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48072   if (!jarg2) {
48073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48074     return ;
48075   }
48076   std::string arg2_str(jarg2);
48077   arg2 = &arg2_str;
48078   arg3 = (Dali::Property::Value *)jarg3;
48079   if (!arg3) {
48080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48081     return ;
48082   }
48083   {
48084     try {
48085       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48086     } CALL_CATCH_EXCEPTION();
48087   }
48088
48089
48090   //argout typemap for const std::string&
48091
48092 }
48093
48094
48095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48096   unsigned int jresult ;
48097   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48098   std::string *arg2 = 0 ;
48099   Dali::Property::Value *arg3 = 0 ;
48100   bool result;
48101
48102   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48103   if (!jarg2) {
48104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48105     return 0;
48106   }
48107   std::string arg2_str(jarg2);
48108   arg2 = &arg2_str;
48109   arg3 = (Dali::Property::Value *)jarg3;
48110   if (!arg3) {
48111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48112     return 0;
48113   }
48114   {
48115     try {
48116       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48117     } CALL_CATCH_EXCEPTION(0);
48118   }
48119
48120   jresult = result;
48121
48122   //argout typemap for const std::string&
48123
48124   return jresult;
48125 }
48126
48127
48128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48129   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48130   Dali::Toolkit::Control arg2 ;
48131   std::string *arg3 = 0 ;
48132   std::string *arg4 = 0 ;
48133   Dali::Toolkit::Control *argp2 ;
48134
48135   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48136   argp2 = (Dali::Toolkit::Control *)jarg2;
48137   if (!argp2) {
48138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48139     return ;
48140   }
48141   arg2 = *argp2;
48142   if (!jarg3) {
48143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48144     return ;
48145   }
48146   std::string arg3_str(jarg3);
48147   arg3 = &arg3_str;
48148   if (!jarg4) {
48149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48150     return ;
48151   }
48152   std::string arg4_str(jarg4);
48153   arg4 = &arg4_str;
48154   {
48155     try {
48156       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48157     } CALL_CATCH_EXCEPTION();
48158   }
48159
48160
48161   //argout typemap for const std::string&
48162
48163
48164   //argout typemap for const std::string&
48165
48166 }
48167
48168
48169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48170   void * jresult ;
48171   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48172   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48173
48174   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48175   {
48176     try {
48177       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48178     } CALL_CATCH_EXCEPTION(0);
48179   }
48180
48181   jresult = (void *)result;
48182   return jresult;
48183 }
48184
48185
48186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48187   int jresult ;
48188   int result;
48189
48190   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48191   jresult = (int)result;
48192   return jresult;
48193 }
48194
48195
48196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48197   int jresult ;
48198   int result;
48199
48200   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48201   jresult = (int)result;
48202   return jresult;
48203 }
48204
48205
48206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48207   int jresult ;
48208   int result;
48209
48210   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48211   jresult = (int)result;
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48217   int jresult ;
48218   int result;
48219
48220   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48221   jresult = (int)result;
48222   return jresult;
48223 }
48224
48225
48226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48227   int jresult ;
48228   int result;
48229
48230   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48231   jresult = (int)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48237   int jresult ;
48238   int result;
48239
48240   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48241   jresult = (int)result;
48242   return jresult;
48243 }
48244
48245
48246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48247   int jresult ;
48248   int result;
48249
48250   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48251   jresult = (int)result;
48252   return jresult;
48253 }
48254
48255
48256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48257   int jresult ;
48258   int result;
48259
48260   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48261   jresult = (int)result;
48262   return jresult;
48263 }
48264
48265
48266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48267   int jresult ;
48268   int result;
48269
48270   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48271   jresult = (int)result;
48272   return jresult;
48273 }
48274
48275
48276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48277   int jresult ;
48278   int result;
48279
48280   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48281   jresult = (int)result;
48282   return jresult;
48283 }
48284
48285
48286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48287   int jresult ;
48288   int result;
48289
48290   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48291   jresult = (int)result;
48292   return jresult;
48293 }
48294
48295
48296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48297   int jresult ;
48298   int result;
48299
48300   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48301   jresult = (int)result;
48302   return jresult;
48303 }
48304
48305
48306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48307   int jresult ;
48308   int result;
48309
48310   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48311   jresult = (int)result;
48312   return jresult;
48313 }
48314
48315
48316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48317   int jresult ;
48318   int result;
48319
48320   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48321   jresult = (int)result;
48322   return jresult;
48323 }
48324
48325
48326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48327   int jresult ;
48328   int result;
48329
48330   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48331   jresult = (int)result;
48332   return jresult;
48333 }
48334
48335
48336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48337   void * jresult ;
48338   Dali::Toolkit::Slider::Property *result = 0 ;
48339
48340   {
48341     try {
48342       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48343     } CALL_CATCH_EXCEPTION(0);
48344   }
48345
48346   jresult = (void *)result;
48347   return jresult;
48348 }
48349
48350
48351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48352   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48353
48354   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48355   {
48356     try {
48357       delete arg1;
48358     } CALL_CATCH_EXCEPTION();
48359   }
48360
48361 }
48362
48363
48364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48365   void * jresult ;
48366   Dali::Toolkit::Slider result;
48367
48368   {
48369     try {
48370       result = Dali::Toolkit::Slider::New();
48371     } CALL_CATCH_EXCEPTION(0);
48372   }
48373
48374   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48375   return jresult;
48376 }
48377
48378
48379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48380   void * jresult ;
48381   Dali::Toolkit::Slider *result = 0 ;
48382
48383   {
48384     try {
48385       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48386     } CALL_CATCH_EXCEPTION(0);
48387   }
48388
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48395   void * jresult ;
48396   Dali::Toolkit::Slider *arg1 = 0 ;
48397   Dali::Toolkit::Slider *result = 0 ;
48398
48399   arg1 = (Dali::Toolkit::Slider *)jarg1;
48400   if (!arg1) {
48401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48402     return 0;
48403   }
48404   {
48405     try {
48406       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48407     } CALL_CATCH_EXCEPTION(0);
48408   }
48409
48410   jresult = (void *)result;
48411   return jresult;
48412 }
48413
48414
48415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48416   void * jresult ;
48417   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48418   Dali::Toolkit::Slider *arg2 = 0 ;
48419   Dali::Toolkit::Slider *result = 0 ;
48420
48421   arg1 = (Dali::Toolkit::Slider *)jarg1;
48422   arg2 = (Dali::Toolkit::Slider *)jarg2;
48423   if (!arg2) {
48424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48425     return 0;
48426   }
48427   {
48428     try {
48429       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48430     } CALL_CATCH_EXCEPTION(0);
48431   }
48432
48433   jresult = (void *)result;
48434   return jresult;
48435 }
48436
48437
48438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48439   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48440
48441   arg1 = (Dali::Toolkit::Slider *)jarg1;
48442   {
48443     try {
48444       delete arg1;
48445     } CALL_CATCH_EXCEPTION();
48446   }
48447
48448 }
48449
48450
48451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48452   void * jresult ;
48453   Dali::BaseHandle arg1 ;
48454   Dali::BaseHandle *argp1 ;
48455   Dali::Toolkit::Slider result;
48456
48457   argp1 = (Dali::BaseHandle *)jarg1;
48458   if (!argp1) {
48459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48460     return 0;
48461   }
48462   arg1 = *argp1;
48463   {
48464     try {
48465       result = Dali::Toolkit::Slider::DownCast(arg1);
48466     } CALL_CATCH_EXCEPTION(0);
48467   }
48468
48469   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48470   return jresult;
48471 }
48472
48473
48474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48475   void * jresult ;
48476   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48477   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48478
48479   arg1 = (Dali::Toolkit::Slider *)jarg1;
48480   {
48481     try {
48482       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48483     } CALL_CATCH_EXCEPTION(0);
48484   }
48485
48486   jresult = (void *)result;
48487   return jresult;
48488 }
48489
48490
48491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
48492   void * jresult ;
48493   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48494   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48495
48496   arg1 = (Dali::Toolkit::Slider *)jarg1;
48497   {
48498     try {
48499       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
48500     } CALL_CATCH_EXCEPTION(0);
48501   }
48502
48503   jresult = (void *)result;
48504   return jresult;
48505 }
48506
48507
48508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48509   void * jresult ;
48510   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48511   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48512
48513   arg1 = (Dali::Toolkit::Slider *)jarg1;
48514   {
48515     try {
48516       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48517     } CALL_CATCH_EXCEPTION(0);
48518   }
48519
48520   jresult = (void *)result;
48521   return jresult;
48522 }
48523
48524
48525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48526   int jresult ;
48527   int result;
48528
48529   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48530   jresult = (int)result;
48531   return jresult;
48532 }
48533
48534
48535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48536   int jresult ;
48537   int result;
48538
48539   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48540   jresult = (int)result;
48541   return jresult;
48542 }
48543
48544
48545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48546   int jresult ;
48547   int result;
48548
48549   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48550   jresult = (int)result;
48551   return jresult;
48552 }
48553
48554
48555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48556   int jresult ;
48557   int result;
48558
48559   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48560   jresult = (int)result;
48561   return jresult;
48562 }
48563
48564
48565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48566   int result;
48567
48568   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48569
48570   return result;
48571 }
48572
48573
48574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48575   void * jresult ;
48576   Dali::Toolkit::VideoView::Property *result = 0 ;
48577
48578   {
48579     try {
48580       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48581     } CALL_CATCH_EXCEPTION(0);
48582   }
48583
48584   jresult = (void *)result;
48585   return jresult;
48586 }
48587
48588
48589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48590   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48591
48592   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48593   {
48594     try {
48595       delete arg1;
48596     } CALL_CATCH_EXCEPTION();
48597   }
48598
48599 }
48600
48601
48602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48603   void * jresult ;
48604   Dali::Toolkit::VideoView result;
48605
48606   {
48607     try {
48608       result = Dali::Toolkit::VideoView::New();
48609     } CALL_CATCH_EXCEPTION(0);
48610   }
48611
48612   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48613   return jresult;
48614 }
48615
48616
48617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48618   void * jresult ;
48619   std::string *arg1 = 0 ;
48620   Dali::Toolkit::VideoView result;
48621
48622   if (!jarg1) {
48623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48624     return 0;
48625   }
48626   std::string arg1_str(jarg1);
48627   arg1 = &arg1_str;
48628   {
48629     try {
48630       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48631     } CALL_CATCH_EXCEPTION(0);
48632   }
48633
48634   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48635
48636   //argout typemap for const std::string&
48637
48638   return jresult;
48639 }
48640
48641
48642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48643   void * jresult ;
48644   Dali::Toolkit::VideoView result;
48645   {
48646     try {
48647       result = Dali::Toolkit::VideoView::New(swCodec);
48648     } CALL_CATCH_EXCEPTION(0);
48649   }
48650
48651   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48652
48653   //argout typemap for const std::string&
48654
48655   return jresult;
48656 }
48657
48658
48659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
48660   void * jresult ;
48661   std::string *arg1 = 0 ;
48662   Dali::Toolkit::VideoView result;
48663
48664   if (!jarg1) {
48665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48666     return 0;
48667   }
48668   std::string arg1_str(jarg1);
48669   arg1 = &arg1_str;
48670   {
48671     try {
48672       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48673     } CALL_CATCH_EXCEPTION(0);
48674   }
48675
48676   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48677
48678   //argout typemap for const std::string&
48679
48680   return jresult;
48681 }
48682
48683
48684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48685   void * jresult ;
48686   Dali::Toolkit::VideoView *result = 0 ;
48687
48688   {
48689     try {
48690       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48691     } CALL_CATCH_EXCEPTION(0);
48692   }
48693
48694   jresult = (void *)result;
48695   return jresult;
48696 }
48697
48698
48699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48700   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48701
48702   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48703   {
48704     try {
48705       delete arg1;
48706     } CALL_CATCH_EXCEPTION();
48707   }
48708
48709 }
48710
48711
48712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48713   void * jresult ;
48714   Dali::Toolkit::VideoView *arg1 = 0 ;
48715   Dali::Toolkit::VideoView *result = 0 ;
48716
48717   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48718   if (!arg1) {
48719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48720     return 0;
48721   }
48722   {
48723     try {
48724       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48725     } CALL_CATCH_EXCEPTION(0);
48726   }
48727
48728   jresult = (void *)result;
48729   return jresult;
48730 }
48731
48732
48733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
48734   void * jresult ;
48735   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48736   Dali::Toolkit::VideoView *arg2 = 0 ;
48737   Dali::Toolkit::VideoView *result = 0 ;
48738
48739   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48740   arg2 = (Dali::Toolkit::VideoView *)jarg2;
48741   if (!arg2) {
48742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48743     return 0;
48744   }
48745   {
48746     try {
48747       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
48748     } CALL_CATCH_EXCEPTION(0);
48749   }
48750
48751   jresult = (void *)result;
48752   return jresult;
48753 }
48754
48755
48756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
48757   void * jresult ;
48758   Dali::BaseHandle arg1 ;
48759   Dali::BaseHandle *argp1 ;
48760   Dali::Toolkit::VideoView result;
48761
48762   argp1 = (Dali::BaseHandle *)jarg1;
48763   if (!argp1) {
48764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48765     return 0;
48766   }
48767   arg1 = *argp1;
48768   {
48769     try {
48770       result = Dali::Toolkit::VideoView::DownCast(arg1);
48771     } CALL_CATCH_EXCEPTION(0);
48772   }
48773
48774   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48775   return jresult;
48776 }
48777
48778
48779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
48780   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48781
48782   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48783   {
48784     try {
48785       (arg1)->Play();
48786     } CALL_CATCH_EXCEPTION();
48787   }
48788
48789 }
48790
48791
48792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
48793   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48794
48795   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48796   {
48797     try {
48798       (arg1)->Pause();
48799     } CALL_CATCH_EXCEPTION();
48800   }
48801
48802 }
48803
48804
48805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
48806   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48807
48808   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48809   {
48810     try {
48811       (arg1)->Stop();
48812     } CALL_CATCH_EXCEPTION();
48813   }
48814
48815 }
48816
48817
48818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
48819   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48820   int arg2 ;
48821
48822   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48823   arg2 = (int)jarg2;
48824   {
48825     try {
48826       (arg1)->Forward(arg2);
48827     } CALL_CATCH_EXCEPTION();
48828   }
48829
48830 }
48831
48832
48833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
48834   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48835   int arg2 ;
48836
48837   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48838   arg2 = (int)jarg2;
48839   {
48840     try {
48841       (arg1)->Backward(arg2);
48842     } CALL_CATCH_EXCEPTION();
48843   }
48844
48845 }
48846
48847
48848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
48849   void * jresult ;
48850   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48851   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
48852
48853   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48854   {
48855     try {
48856       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
48857     } CALL_CATCH_EXCEPTION(0);
48858   }
48859
48860   jresult = (void *)result;
48861   return jresult;
48862 }
48863
48864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
48865 {
48866   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
48867   if( arg1 == nullptr )
48868   {
48869     DALI_LOG_ERROR("VideoView is nullptr!");
48870     return nullptr;
48871   }
48872   void * ret = nullptr;
48873   {
48874     try{
48875
48876       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
48877       ret = Dali::AnyCast< void * >( result );
48878
48879     } CALL_CATCH_EXCEPTION(0);
48880   }
48881   return ret;
48882 }
48883
48884
48885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
48886   int jresult ;
48887   int result;
48888
48889   result = (int)Dali::Toolkit::Popup::Property::TITLE;
48890   jresult = (int)result;
48891   return jresult;
48892 }
48893
48894
48895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
48896   int jresult ;
48897   int result;
48898
48899   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
48900   jresult = (int)result;
48901   return jresult;
48902 }
48903
48904
48905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
48906   int jresult ;
48907   int result;
48908
48909   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
48910   jresult = (int)result;
48911   return jresult;
48912 }
48913
48914
48915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
48916   int jresult ;
48917   int result;
48918
48919   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
48920   jresult = (int)result;
48921   return jresult;
48922 }
48923
48924
48925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
48926   int jresult ;
48927   int result;
48928
48929   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
48930   jresult = (int)result;
48931   return jresult;
48932 }
48933
48934
48935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
48936   int jresult ;
48937   int result;
48938
48939   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
48940   jresult = (int)result;
48941   return jresult;
48942 }
48943
48944
48945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
48946   int jresult ;
48947   int result;
48948
48949   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
48950   jresult = (int)result;
48951   return jresult;
48952 }
48953
48954
48955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
48956   int jresult ;
48957   int result;
48958
48959   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
48960   jresult = (int)result;
48961   return jresult;
48962 }
48963
48964
48965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
48966   int jresult ;
48967   int result;
48968
48969   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
48970   jresult = (int)result;
48971   return jresult;
48972 }
48973
48974
48975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
48976   int jresult ;
48977   int result;
48978
48979   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
48980   jresult = (int)result;
48981   return jresult;
48982 }
48983
48984
48985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
48986   int jresult ;
48987   int result;
48988
48989   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
48990   jresult = (int)result;
48991   return jresult;
48992 }
48993
48994
48995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
48996   int jresult ;
48997   int result;
48998
48999   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49000   jresult = (int)result;
49001   return jresult;
49002 }
49003
49004
49005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49006   int jresult ;
49007   int result;
49008
49009   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49010   jresult = (int)result;
49011   return jresult;
49012 }
49013
49014
49015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49016   int jresult ;
49017   int result;
49018
49019   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49020   jresult = (int)result;
49021   return jresult;
49022 }
49023
49024
49025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49026   int jresult ;
49027   int result;
49028
49029   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49030   jresult = (int)result;
49031   return jresult;
49032 }
49033
49034
49035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49036   int jresult ;
49037   int result;
49038
49039   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49040   jresult = (int)result;
49041   return jresult;
49042 }
49043
49044
49045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49046   int jresult ;
49047   int result;
49048
49049   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49050   jresult = (int)result;
49051   return jresult;
49052 }
49053
49054
49055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49056   int jresult ;
49057   int result;
49058
49059   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49060   jresult = (int)result;
49061   return jresult;
49062 }
49063
49064
49065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49066   int jresult ;
49067   int result;
49068
49069   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49070   jresult = (int)result;
49071   return jresult;
49072 }
49073
49074
49075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49076   int jresult ;
49077   int result;
49078
49079   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49080   jresult = (int)result;
49081   return jresult;
49082 }
49083
49084
49085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49086   int jresult ;
49087   int result;
49088
49089   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49090   jresult = (int)result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49096   void * jresult ;
49097   Dali::Toolkit::Popup::Property *result = 0 ;
49098
49099   {
49100     try {
49101       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49102     } CALL_CATCH_EXCEPTION(0);
49103   }
49104
49105   jresult = (void *)result;
49106   return jresult;
49107 }
49108
49109
49110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49111   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49112
49113   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49114   {
49115     try {
49116       delete arg1;
49117     } CALL_CATCH_EXCEPTION();
49118   }
49119
49120 }
49121
49122
49123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49124   void * jresult ;
49125   Dali::Toolkit::Popup *result = 0 ;
49126
49127   {
49128     try {
49129       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49130     } CALL_CATCH_EXCEPTION(0);
49131   }
49132
49133   jresult = (void *)result;
49134   return jresult;
49135 }
49136
49137
49138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49139   void * jresult ;
49140   Dali::Toolkit::Popup result;
49141
49142   {
49143     try {
49144       result = Dali::Toolkit::Popup::New();
49145     } CALL_CATCH_EXCEPTION(0);
49146   }
49147
49148   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49149   return jresult;
49150 }
49151
49152
49153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49155
49156   arg1 = (Dali::Toolkit::Popup *)jarg1;
49157   {
49158     try {
49159       delete arg1;
49160     } CALL_CATCH_EXCEPTION();
49161   }
49162
49163 }
49164
49165
49166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49167   void * jresult ;
49168   Dali::Toolkit::Popup *arg1 = 0 ;
49169   Dali::Toolkit::Popup *result = 0 ;
49170
49171   arg1 = (Dali::Toolkit::Popup *)jarg1;
49172   if (!arg1) {
49173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49174     return 0;
49175   }
49176   {
49177     try {
49178       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49179     } CALL_CATCH_EXCEPTION(0);
49180   }
49181
49182   jresult = (void *)result;
49183   return jresult;
49184 }
49185
49186
49187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49188   void * jresult ;
49189   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49190   Dali::Toolkit::Popup *arg2 = 0 ;
49191   Dali::Toolkit::Popup *result = 0 ;
49192
49193   arg1 = (Dali::Toolkit::Popup *)jarg1;
49194   arg2 = (Dali::Toolkit::Popup *)jarg2;
49195   if (!arg2) {
49196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49197     return 0;
49198   }
49199   {
49200     try {
49201       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49202     } CALL_CATCH_EXCEPTION(0);
49203   }
49204
49205   jresult = (void *)result;
49206   return jresult;
49207 }
49208
49209
49210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49211   void * jresult ;
49212   Dali::BaseHandle arg1 ;
49213   Dali::BaseHandle *argp1 ;
49214   Dali::Toolkit::Popup result;
49215
49216   argp1 = (Dali::BaseHandle *)jarg1;
49217   if (!argp1) {
49218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49219     return 0;
49220   }
49221   arg1 = *argp1;
49222   {
49223     try {
49224       result = Dali::Toolkit::Popup::DownCast(arg1);
49225     } CALL_CATCH_EXCEPTION(0);
49226   }
49227
49228   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49229   return jresult;
49230 }
49231
49232
49233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49234   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49235   Dali::Actor arg2 ;
49236   Dali::Actor *argp2 ;
49237
49238   arg1 = (Dali::Toolkit::Popup *)jarg1;
49239   argp2 = (Dali::Actor *)jarg2;
49240   if (!argp2) {
49241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49242     return ;
49243   }
49244   arg2 = *argp2;
49245   {
49246     try {
49247       (arg1)->SetTitle(arg2);
49248     } CALL_CATCH_EXCEPTION();
49249   }
49250
49251 }
49252
49253
49254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49255   void * jresult ;
49256   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49257   Dali::Actor result;
49258
49259   arg1 = (Dali::Toolkit::Popup *)jarg1;
49260   {
49261     try {
49262       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49263     } CALL_CATCH_EXCEPTION(0);
49264   }
49265
49266   jresult = new Dali::Actor((const Dali::Actor &)result);
49267   return jresult;
49268 }
49269
49270
49271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49272   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49273   Dali::Actor arg2 ;
49274   Dali::Actor *argp2 ;
49275
49276   arg1 = (Dali::Toolkit::Popup *)jarg1;
49277   argp2 = (Dali::Actor *)jarg2;
49278   if (!argp2) {
49279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49280     return ;
49281   }
49282   arg2 = *argp2;
49283   {
49284     try {
49285       (arg1)->SetContent(arg2);
49286     } CALL_CATCH_EXCEPTION();
49287   }
49288
49289 }
49290
49291
49292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49293   void * jresult ;
49294   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49295   Dali::Actor result;
49296
49297   arg1 = (Dali::Toolkit::Popup *)jarg1;
49298   {
49299     try {
49300       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49301     } CALL_CATCH_EXCEPTION(0);
49302   }
49303
49304   jresult = new Dali::Actor((const Dali::Actor &)result);
49305   return jresult;
49306 }
49307
49308
49309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49310   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49311   Dali::Actor arg2 ;
49312   Dali::Actor *argp2 ;
49313
49314   arg1 = (Dali::Toolkit::Popup *)jarg1;
49315   argp2 = (Dali::Actor *)jarg2;
49316   if (!argp2) {
49317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49318     return ;
49319   }
49320   arg2 = *argp2;
49321   {
49322     try {
49323       (arg1)->SetFooter(arg2);
49324     } CALL_CATCH_EXCEPTION();
49325   }
49326
49327 }
49328
49329
49330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49331   void * jresult ;
49332   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49333   Dali::Actor result;
49334
49335   arg1 = (Dali::Toolkit::Popup *)jarg1;
49336   {
49337     try {
49338       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49339     } CALL_CATCH_EXCEPTION(0);
49340   }
49341
49342   jresult = new Dali::Actor((const Dali::Actor &)result);
49343   return jresult;
49344 }
49345
49346
49347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49348   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49349   Dali::Toolkit::Popup::DisplayState arg2 ;
49350
49351   arg1 = (Dali::Toolkit::Popup *)jarg1;
49352   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49353   {
49354     try {
49355       (arg1)->SetDisplayState(arg2);
49356     } CALL_CATCH_EXCEPTION();
49357   }
49358
49359 }
49360
49361
49362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49363   int jresult ;
49364   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49365   Dali::Toolkit::Popup::DisplayState result;
49366
49367   arg1 = (Dali::Toolkit::Popup *)jarg1;
49368   {
49369     try {
49370       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49371     } CALL_CATCH_EXCEPTION(0);
49372   }
49373
49374   jresult = (int)result;
49375   return jresult;
49376 }
49377
49378
49379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49380   void * jresult ;
49381   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49382   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49383
49384   arg1 = (Dali::Toolkit::Popup *)jarg1;
49385   {
49386     try {
49387       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49388     } CALL_CATCH_EXCEPTION(0);
49389   }
49390
49391   jresult = (void *)result;
49392   return jresult;
49393 }
49394
49395
49396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49397   void * jresult ;
49398   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49399   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49400
49401   arg1 = (Dali::Toolkit::Popup *)jarg1;
49402   {
49403     try {
49404       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49405     } CALL_CATCH_EXCEPTION(0);
49406   }
49407
49408   jresult = (void *)result;
49409   return jresult;
49410 }
49411
49412
49413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
49414   void * jresult ;
49415   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49416   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49417
49418   arg1 = (Dali::Toolkit::Popup *)jarg1;
49419   {
49420     try {
49421       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
49422     } CALL_CATCH_EXCEPTION(0);
49423   }
49424
49425   jresult = (void *)result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
49431   void * jresult ;
49432   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49433   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49434
49435   arg1 = (Dali::Toolkit::Popup *)jarg1;
49436   {
49437     try {
49438       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
49439     } CALL_CATCH_EXCEPTION(0);
49440   }
49441
49442   jresult = (void *)result;
49443   return jresult;
49444 }
49445
49446
49447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
49448   void * jresult ;
49449   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49450   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49451
49452   arg1 = (Dali::Toolkit::Popup *)jarg1;
49453   {
49454     try {
49455       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
49456     } CALL_CATCH_EXCEPTION(0);
49457   }
49458
49459   jresult = (void *)result;
49460   return jresult;
49461 }
49462
49463
49464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49465   int jresult ;
49466   int result;
49467
49468   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49469   jresult = (int)result;
49470   return jresult;
49471 }
49472
49473
49474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49475   int jresult ;
49476   int result;
49477
49478   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49479   jresult = (int)result;
49480   return jresult;
49481 }
49482
49483
49484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49485   int jresult ;
49486   int result;
49487
49488   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49489   jresult = (int)result;
49490   return jresult;
49491 }
49492
49493
49494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49495   int jresult ;
49496   int result;
49497
49498   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49499   jresult = (int)result;
49500   return jresult;
49501 }
49502
49503
49504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49505   int jresult ;
49506   int result;
49507
49508   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49509   jresult = (int)result;
49510   return jresult;
49511 }
49512
49513
49514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49515   int jresult ;
49516   int result;
49517
49518   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49519   jresult = (int)result;
49520   return jresult;
49521 }
49522
49523
49524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49525   int jresult ;
49526   int result;
49527
49528   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49529   jresult = (int)result;
49530   return jresult;
49531 }
49532
49533
49534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49535   int jresult ;
49536   int result;
49537
49538   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49539   jresult = (int)result;
49540   return jresult;
49541 }
49542
49543
49544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49545   int jresult ;
49546   int result;
49547
49548   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49549   jresult = (int)result;
49550   return jresult;
49551 }
49552
49553
49554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49555   void * jresult ;
49556   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49557
49558   {
49559     try {
49560       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49561     } CALL_CATCH_EXCEPTION(0);
49562   }
49563
49564   jresult = (void *)result;
49565   return jresult;
49566 }
49567
49568
49569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49570   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49571
49572   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49573   {
49574     try {
49575       delete arg1;
49576     } CALL_CATCH_EXCEPTION();
49577   }
49578
49579 }
49580
49581
49582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49583   void * jresult ;
49584   Dali::Toolkit::ProgressBar result;
49585
49586   {
49587     try {
49588       result = Dali::Toolkit::ProgressBar::New();
49589     } CALL_CATCH_EXCEPTION(0);
49590   }
49591
49592   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49593   return jresult;
49594 }
49595
49596
49597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49598   void * jresult ;
49599   Dali::Toolkit::ProgressBar *result = 0 ;
49600
49601   {
49602     try {
49603       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49604     } CALL_CATCH_EXCEPTION(0);
49605   }
49606
49607   jresult = (void *)result;
49608   return jresult;
49609 }
49610
49611
49612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49613   void * jresult ;
49614   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49615   Dali::Toolkit::ProgressBar *result = 0 ;
49616
49617   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49618   if (!arg1) {
49619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49620     return 0;
49621   }
49622   {
49623     try {
49624       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49625     } CALL_CATCH_EXCEPTION(0);
49626   }
49627
49628   jresult = (void *)result;
49629   return jresult;
49630 }
49631
49632
49633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49634   void * jresult ;
49635   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49636   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49637   Dali::Toolkit::ProgressBar *result = 0 ;
49638
49639   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49640   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49641   if (!arg2) {
49642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49643     return 0;
49644   }
49645   {
49646     try {
49647       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49648     } CALL_CATCH_EXCEPTION(0);
49649   }
49650
49651   jresult = (void *)result;
49652   return jresult;
49653 }
49654
49655
49656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49657   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49658
49659   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49660   {
49661     try {
49662       delete arg1;
49663     } CALL_CATCH_EXCEPTION();
49664   }
49665
49666 }
49667
49668
49669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49670   void * jresult ;
49671   Dali::BaseHandle arg1 ;
49672   Dali::BaseHandle *argp1 ;
49673   Dali::Toolkit::ProgressBar result;
49674
49675   argp1 = (Dali::BaseHandle *)jarg1;
49676   if (!argp1) {
49677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49678     return 0;
49679   }
49680   arg1 = *argp1;
49681   {
49682     try {
49683       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49684     } CALL_CATCH_EXCEPTION(0);
49685   }
49686
49687   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49688   return jresult;
49689 }
49690
49691
49692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49693   void * jresult ;
49694   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49695   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49696
49697   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49698   {
49699     try {
49700       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49701     } CALL_CATCH_EXCEPTION(0);
49702   }
49703
49704   jresult = (void *)result;
49705   return jresult;
49706 }
49707
49708
49709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49710   void * jresult ;
49711   Dali::Toolkit::GaussianBlurView *result = 0 ;
49712
49713   {
49714     try {
49715       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49716     } CALL_CATCH_EXCEPTION(0);
49717   }
49718
49719   jresult = (void *)result;
49720   return jresult;
49721 }
49722
49723
49724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49725   void * jresult ;
49726   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
49727   Dali::Toolkit::GaussianBlurView *result = 0 ;
49728
49729   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49730   if (!arg1) {
49731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49732     return 0;
49733   }
49734   {
49735     try {
49736       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
49737     } CALL_CATCH_EXCEPTION(0);
49738   }
49739
49740   jresult = (void *)result;
49741   return jresult;
49742 }
49743
49744
49745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
49746   void * jresult ;
49747   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49748   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
49749   Dali::Toolkit::GaussianBlurView *result = 0 ;
49750
49751   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49752   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
49753   if (!arg2) {
49754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49755     return 0;
49756   }
49757   {
49758     try {
49759       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
49760     } CALL_CATCH_EXCEPTION(0);
49761   }
49762
49763   jresult = (void *)result;
49764   return jresult;
49765 }
49766
49767
49768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
49769   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49770
49771   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49772   {
49773     try {
49774       delete arg1;
49775     } CALL_CATCH_EXCEPTION();
49776   }
49777
49778 }
49779
49780
49781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
49782   void * jresult ;
49783   Dali::BaseHandle arg1 ;
49784   Dali::BaseHandle *argp1 ;
49785   Dali::Toolkit::GaussianBlurView result;
49786
49787   argp1 = (Dali::BaseHandle *)jarg1;
49788   if (!argp1) {
49789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49790     return 0;
49791   }
49792   arg1 = *argp1;
49793   {
49794     try {
49795       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
49796     } CALL_CATCH_EXCEPTION(0);
49797   }
49798
49799   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49800   return jresult;
49801 }
49802
49803
49804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
49805   void * jresult ;
49806   Dali::Toolkit::GaussianBlurView result;
49807
49808   {
49809     try {
49810       result = Dali::Toolkit::GaussianBlurView::New();
49811     } CALL_CATCH_EXCEPTION(0);
49812   }
49813
49814   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49815   return jresult;
49816 }
49817
49818
49819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
49820   void * jresult ;
49821   unsigned int arg1 ;
49822   float arg2 ;
49823   Dali::Pixel::Format arg3 ;
49824   float arg4 ;
49825   float arg5 ;
49826   bool arg6 ;
49827   Dali::Toolkit::GaussianBlurView result;
49828
49829   arg1 = (unsigned int)jarg1;
49830   arg2 = (float)jarg2;
49831   arg3 = (Dali::Pixel::Format)jarg3;
49832   arg4 = (float)jarg4;
49833   arg5 = (float)jarg5;
49834   arg6 = jarg6 ? true : false;
49835   {
49836     try {
49837       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
49838     } CALL_CATCH_EXCEPTION(0);
49839   }
49840
49841   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49842   return jresult;
49843 }
49844
49845
49846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
49847   void * jresult ;
49848   unsigned int arg1 ;
49849   float arg2 ;
49850   Dali::Pixel::Format arg3 ;
49851   float arg4 ;
49852   float arg5 ;
49853   Dali::Toolkit::GaussianBlurView result;
49854
49855   arg1 = (unsigned int)jarg1;
49856   arg2 = (float)jarg2;
49857   arg3 = (Dali::Pixel::Format)jarg3;
49858   arg4 = (float)jarg4;
49859   arg5 = (float)jarg5;
49860   {
49861     try {
49862       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
49863     } CALL_CATCH_EXCEPTION(0);
49864   }
49865
49866   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
49867   return jresult;
49868 }
49869
49870
49871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
49872   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49873   Dali::Actor arg2 ;
49874   Dali::Actor *argp2 ;
49875
49876   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49877   argp2 = (Dali::Actor *)jarg2;
49878   if (!argp2) {
49879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49880     return ;
49881   }
49882   arg2 = *argp2;
49883   {
49884     try {
49885       (arg1)->Add(arg2);
49886     } CALL_CATCH_EXCEPTION();
49887   }
49888
49889 }
49890
49891
49892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
49893   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49894   Dali::Actor arg2 ;
49895   Dali::Actor *argp2 ;
49896
49897   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49898   argp2 = (Dali::Actor *)jarg2;
49899   if (!argp2) {
49900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49901     return ;
49902   }
49903   arg2 = *argp2;
49904   {
49905     try {
49906       (arg1)->Remove(arg2);
49907     } CALL_CATCH_EXCEPTION();
49908   }
49909
49910 }
49911
49912
49913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
49914   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49915
49916   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49917   {
49918     try {
49919       (arg1)->Activate();
49920     } CALL_CATCH_EXCEPTION();
49921   }
49922
49923 }
49924
49925
49926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
49927   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49928
49929   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49930   {
49931     try {
49932       (arg1)->ActivateOnce();
49933     } CALL_CATCH_EXCEPTION();
49934   }
49935
49936 }
49937
49938
49939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
49940   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49941
49942   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49943   {
49944     try {
49945       (arg1)->Deactivate();
49946     } CALL_CATCH_EXCEPTION();
49947   }
49948
49949 }
49950
49951
49952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
49953   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49954   Dali::Texture arg2 ;
49955   Dali::FrameBuffer arg3 ;
49956   Dali::Texture *argp2 ;
49957   Dali::FrameBuffer *argp3 ;
49958
49959   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49960   argp2 = (Dali::Texture *)jarg2;
49961   if (!argp2) {
49962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
49963     return ;
49964   }
49965   arg2 = *argp2;
49966   argp3 = (Dali::FrameBuffer *)jarg3;
49967   if (!argp3) {
49968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
49969     return ;
49970   }
49971   arg3 = *argp3;
49972   {
49973     try {
49974       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
49975     } CALL_CATCH_EXCEPTION();
49976   }
49977
49978 }
49979
49980
49981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
49982   int jresult ;
49983   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49984   Dali::Property::Index result;
49985
49986   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49987   {
49988     try {
49989       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
49990     } CALL_CATCH_EXCEPTION(0);
49991   }
49992
49993   jresult = result;
49994   return jresult;
49995 }
49996
49997
49998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
49999   void * jresult ;
50000   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50001   Dali::FrameBuffer result;
50002
50003   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50004   {
50005     try {
50006       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50007     } CALL_CATCH_EXCEPTION(0);
50008   }
50009
50010   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50011   return jresult;
50012 }
50013
50014
50015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50016   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50017   Dali::Vector4 *arg2 = 0 ;
50018
50019   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50020   arg2 = (Dali::Vector4 *)jarg2;
50021   if (!arg2) {
50022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50023     return ;
50024   }
50025   {
50026     try {
50027       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50028     } CALL_CATCH_EXCEPTION();
50029   }
50030
50031 }
50032
50033
50034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50035   void * jresult ;
50036   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50037   Dali::Vector4 result;
50038
50039   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50040   {
50041     try {
50042       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50043     } CALL_CATCH_EXCEPTION(0);
50044   }
50045
50046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50052   void * jresult ;
50053   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50054   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50055
50056   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50057   {
50058     try {
50059       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50060     } CALL_CATCH_EXCEPTION(0);
50061   }
50062
50063   jresult = (void *)result;
50064   return jresult;
50065 }
50066
50067
50068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50069   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50070
50071   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50072   {
50073     try {
50074       delete arg1;
50075     } CALL_CATCH_EXCEPTION();
50076   }
50077
50078 }
50079
50080
50081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50082   unsigned int jresult ;
50083   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50084   unsigned int result;
50085
50086   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50087   {
50088     try {
50089       result = (unsigned int)(arg1)->GetNumberOfPages();
50090     } CALL_CATCH_EXCEPTION(0);
50091   }
50092
50093   jresult = result;
50094   return jresult;
50095 }
50096
50097
50098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50099   void * jresult ;
50100   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50101   unsigned int arg2 ;
50102   Dali::Texture result;
50103
50104   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50105   arg2 = (unsigned int)jarg2;
50106   {
50107     try {
50108       result = (arg1)->NewPage(arg2);
50109     } CALL_CATCH_EXCEPTION(0);
50110   }
50111
50112   jresult = new Dali::Texture((const Dali::Texture &)result);
50113   return jresult;
50114 }
50115
50116
50117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50118   int jresult ;
50119   int result;
50120
50121   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50122   jresult = (int)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50128   int jresult ;
50129   int result;
50130
50131   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50132   jresult = (int)result;
50133   return jresult;
50134 }
50135
50136
50137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50138   int jresult ;
50139   int result;
50140
50141   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50142   jresult = (int)result;
50143   return jresult;
50144 }
50145
50146
50147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50148   void * jresult ;
50149   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50150
50151   {
50152     try {
50153       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50154     } CALL_CATCH_EXCEPTION(0);
50155   }
50156
50157   jresult = (void *)result;
50158   return jresult;
50159 }
50160
50161
50162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50163   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50164
50165   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50166   {
50167     try {
50168       delete arg1;
50169     } CALL_CATCH_EXCEPTION();
50170   }
50171
50172 }
50173
50174
50175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50176   void * jresult ;
50177   Dali::Toolkit::PageTurnView *result = 0 ;
50178
50179   {
50180     try {
50181       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50182     } CALL_CATCH_EXCEPTION(0);
50183   }
50184
50185   jresult = (void *)result;
50186   return jresult;
50187 }
50188
50189
50190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50191   void * jresult ;
50192   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50193   Dali::Toolkit::PageTurnView *result = 0 ;
50194
50195   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50196   if (!arg1) {
50197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50198     return 0;
50199   }
50200   {
50201     try {
50202       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50203     } CALL_CATCH_EXCEPTION(0);
50204   }
50205
50206   jresult = (void *)result;
50207   return jresult;
50208 }
50209
50210
50211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50212   void * jresult ;
50213   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50214   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50215   Dali::Toolkit::PageTurnView *result = 0 ;
50216
50217   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50218   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50219   if (!arg2) {
50220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50221     return 0;
50222   }
50223   {
50224     try {
50225       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50226     } CALL_CATCH_EXCEPTION(0);
50227   }
50228
50229   jresult = (void *)result;
50230   return jresult;
50231 }
50232
50233
50234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50235   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50236
50237   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50238   {
50239     try {
50240       delete arg1;
50241     } CALL_CATCH_EXCEPTION();
50242   }
50243
50244 }
50245
50246
50247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50248   void * jresult ;
50249   Dali::BaseHandle arg1 ;
50250   Dali::BaseHandle *argp1 ;
50251   Dali::Toolkit::PageTurnView result;
50252
50253   argp1 = (Dali::BaseHandle *)jarg1;
50254   if (!argp1) {
50255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50256     return 0;
50257   }
50258   arg1 = *argp1;
50259   {
50260     try {
50261       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50262     } CALL_CATCH_EXCEPTION(0);
50263   }
50264
50265   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50266   return jresult;
50267 }
50268
50269
50270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50271   void * jresult ;
50272   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50273   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50274
50275   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50276   {
50277     try {
50278       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50279     } CALL_CATCH_EXCEPTION(0);
50280   }
50281
50282   jresult = (void *)result;
50283   return jresult;
50284 }
50285
50286
50287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
50288   void * jresult ;
50289   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50290   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50291
50292   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50293   {
50294     try {
50295       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
50296     } CALL_CATCH_EXCEPTION(0);
50297   }
50298
50299   jresult = (void *)result;
50300   return jresult;
50301 }
50302
50303
50304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50305   void * jresult ;
50306   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50307   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50308
50309   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50310   {
50311     try {
50312       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50313     } CALL_CATCH_EXCEPTION(0);
50314   }
50315
50316   jresult = (void *)result;
50317   return jresult;
50318 }
50319
50320
50321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
50322   void * jresult ;
50323   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50324   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50325
50326   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50327   {
50328     try {
50329       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
50330     } CALL_CATCH_EXCEPTION(0);
50331   }
50332
50333   jresult = (void *)result;
50334   return jresult;
50335 }
50336
50337
50338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50339   void * jresult ;
50340   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50341
50342   {
50343     try {
50344       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50345     } CALL_CATCH_EXCEPTION(0);
50346   }
50347
50348   jresult = (void *)result;
50349   return jresult;
50350 }
50351
50352
50353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50354   void * jresult ;
50355   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50356   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50357
50358   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50359   if (!arg1) {
50360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50361     return 0;
50362   }
50363   {
50364     try {
50365       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50366     } CALL_CATCH_EXCEPTION(0);
50367   }
50368
50369   jresult = (void *)result;
50370   return jresult;
50371 }
50372
50373
50374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50375   void * jresult ;
50376   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50377   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50378   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50379
50380   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50381   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50382   if (!arg2) {
50383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50384     return 0;
50385   }
50386   {
50387     try {
50388       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50389     } CALL_CATCH_EXCEPTION(0);
50390   }
50391
50392   jresult = (void *)result;
50393   return jresult;
50394 }
50395
50396
50397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50398   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50399
50400   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50401   {
50402     try {
50403       delete arg1;
50404     } CALL_CATCH_EXCEPTION();
50405   }
50406
50407 }
50408
50409
50410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50411   void * jresult ;
50412   Dali::Toolkit::PageFactory *arg1 = 0 ;
50413   Dali::Vector2 *arg2 = 0 ;
50414   Dali::Toolkit::PageTurnLandscapeView result;
50415
50416   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50417   if (!arg1) {
50418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50419     return 0;
50420   }
50421   arg2 = (Dali::Vector2 *)jarg2;
50422   if (!arg2) {
50423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50424     return 0;
50425   }
50426   {
50427     try {
50428       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50429     } CALL_CATCH_EXCEPTION(0);
50430   }
50431
50432   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50433   return jresult;
50434 }
50435
50436
50437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50438   void * jresult ;
50439   Dali::BaseHandle arg1 ;
50440   Dali::BaseHandle *argp1 ;
50441   Dali::Toolkit::PageTurnLandscapeView result;
50442
50443   argp1 = (Dali::BaseHandle *)jarg1;
50444   if (!argp1) {
50445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50446     return 0;
50447   }
50448   arg1 = *argp1;
50449   {
50450     try {
50451       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50452     } CALL_CATCH_EXCEPTION(0);
50453   }
50454
50455   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50456   return jresult;
50457 }
50458
50459
50460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50461   void * jresult ;
50462   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50463
50464   {
50465     try {
50466       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50467     } CALL_CATCH_EXCEPTION(0);
50468   }
50469
50470   jresult = (void *)result;
50471   return jresult;
50472 }
50473
50474
50475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50476   void * jresult ;
50477   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50478   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50479
50480   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50481   if (!arg1) {
50482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50483     return 0;
50484   }
50485   {
50486     try {
50487       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50488     } CALL_CATCH_EXCEPTION(0);
50489   }
50490
50491   jresult = (void *)result;
50492   return jresult;
50493 }
50494
50495
50496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50497   void * jresult ;
50498   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50499   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50500   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50501
50502   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50503   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50504   if (!arg2) {
50505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50506     return 0;
50507   }
50508   {
50509     try {
50510       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50511     } CALL_CATCH_EXCEPTION(0);
50512   }
50513
50514   jresult = (void *)result;
50515   return jresult;
50516 }
50517
50518
50519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50520   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50521
50522   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50523   {
50524     try {
50525       delete arg1;
50526     } CALL_CATCH_EXCEPTION();
50527   }
50528
50529 }
50530
50531
50532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50533   void * jresult ;
50534   Dali::Toolkit::PageFactory *arg1 = 0 ;
50535   Dali::Vector2 *arg2 = 0 ;
50536   Dali::Toolkit::PageTurnPortraitView result;
50537
50538   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50539   if (!arg1) {
50540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50541     return 0;
50542   }
50543   arg2 = (Dali::Vector2 *)jarg2;
50544   if (!arg2) {
50545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50546     return 0;
50547   }
50548   {
50549     try {
50550       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50551     } CALL_CATCH_EXCEPTION(0);
50552   }
50553
50554   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50560   void * jresult ;
50561   Dali::BaseHandle arg1 ;
50562   Dali::BaseHandle *argp1 ;
50563   Dali::Toolkit::PageTurnPortraitView result;
50564
50565   argp1 = (Dali::BaseHandle *)jarg1;
50566   if (!argp1) {
50567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50568     return 0;
50569   }
50570   arg1 = *argp1;
50571   {
50572     try {
50573       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50574     } CALL_CATCH_EXCEPTION(0);
50575   }
50576
50577   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50583   int jresult ;
50584   int result;
50585
50586   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50587   jresult = (int)result;
50588   return jresult;
50589 }
50590
50591
50592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50593   int jresult ;
50594   int result;
50595
50596   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50597   jresult = (int)result;
50598   return jresult;
50599 }
50600
50601
50602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50603   int jresult ;
50604   int result;
50605
50606   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50607   jresult = (int)result;
50608   return jresult;
50609 }
50610
50611
50612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50613   void * jresult ;
50614   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50615
50616   {
50617     try {
50618       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50619     } CALL_CATCH_EXCEPTION(0);
50620   }
50621
50622   jresult = (void *)result;
50623   return jresult;
50624 }
50625
50626
50627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50628   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50629
50630   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50631   {
50632     try {
50633       delete arg1;
50634     } CALL_CATCH_EXCEPTION();
50635   }
50636
50637 }
50638
50639
50640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50641   void * jresult ;
50642   Dali::Toolkit::ToggleButton *result = 0 ;
50643
50644   {
50645     try {
50646       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50647     } CALL_CATCH_EXCEPTION(0);
50648   }
50649
50650   jresult = (void *)result;
50651   return jresult;
50652 }
50653
50654
50655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50656   void * jresult ;
50657   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50658   Dali::Toolkit::ToggleButton *result = 0 ;
50659
50660   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50661   if (!arg1) {
50662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50663     return 0;
50664   }
50665   {
50666     try {
50667       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50668     } CALL_CATCH_EXCEPTION(0);
50669   }
50670
50671   jresult = (void *)result;
50672   return jresult;
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50677   void * jresult ;
50678   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50679   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50680   Dali::Toolkit::ToggleButton *result = 0 ;
50681
50682   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50683   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50684   if (!arg2) {
50685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50686     return 0;
50687   }
50688   {
50689     try {
50690       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50691     } CALL_CATCH_EXCEPTION(0);
50692   }
50693
50694   jresult = (void *)result;
50695   return jresult;
50696 }
50697
50698
50699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50700   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50701
50702   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50703   {
50704     try {
50705       delete arg1;
50706     } CALL_CATCH_EXCEPTION();
50707   }
50708
50709 }
50710
50711
50712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50713   void * jresult ;
50714   Dali::Toolkit::ToggleButton result;
50715
50716   {
50717     try {
50718       result = Dali::Toolkit::ToggleButton::New();
50719     } CALL_CATCH_EXCEPTION(0);
50720   }
50721
50722   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50723   return jresult;
50724 }
50725
50726
50727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
50728   void * jresult ;
50729   Dali::BaseHandle arg1 ;
50730   Dali::BaseHandle *argp1 ;
50731   Dali::Toolkit::ToggleButton result;
50732
50733   argp1 = (Dali::BaseHandle *)jarg1;
50734   if (!argp1) {
50735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50736     return 0;
50737   }
50738   arg1 = *argp1;
50739   {
50740     try {
50741       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
50742     } CALL_CATCH_EXCEPTION(0);
50743   }
50744
50745   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50746   return jresult;
50747 }
50748
50749
50750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
50751   void * jresult ;
50752   Dali::Toolkit::Visual::Base *result = 0 ;
50753
50754   {
50755     try {
50756       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
50757     } CALL_CATCH_EXCEPTION(0);
50758   }
50759
50760   jresult = (void *)result;
50761   return jresult;
50762 }
50763
50764
50765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
50766   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50767
50768   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50769   {
50770     try {
50771       delete arg1;
50772     } CALL_CATCH_EXCEPTION();
50773   }
50774
50775 }
50776
50777
50778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
50779   void * jresult ;
50780   Dali::Toolkit::Visual::Base *arg1 = 0 ;
50781   Dali::Toolkit::Visual::Base *result = 0 ;
50782
50783   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50784   if (!arg1) {
50785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
50786     return 0;
50787   }
50788   {
50789     try {
50790       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
50791     } CALL_CATCH_EXCEPTION(0);
50792   }
50793
50794   jresult = (void *)result;
50795   return jresult;
50796 }
50797
50798
50799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
50800   void * jresult ;
50801   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50802   Dali::Toolkit::Visual::Base *arg2 = 0 ;
50803   Dali::Toolkit::Visual::Base *result = 0 ;
50804
50805   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50806   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
50807   if (!arg2) {
50808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
50809     return 0;
50810   }
50811   {
50812     try {
50813       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
50814     } CALL_CATCH_EXCEPTION(0);
50815   }
50816
50817   jresult = (void *)result;
50818   return jresult;
50819 }
50820
50821
50822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
50823   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50824   std::string *arg2 = 0 ;
50825
50826   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50827   if (!jarg2) {
50828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50829     return ;
50830   }
50831   std::string arg2_str(jarg2);
50832   arg2 = &arg2_str;
50833   {
50834     try {
50835       (arg1)->SetName((std::string const &)*arg2);
50836     } CALL_CATCH_EXCEPTION();
50837   }
50838
50839
50840   //argout typemap for const std::string&
50841
50842 }
50843
50844
50845 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
50846   char * jresult ;
50847   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50848   std::string *result = 0 ;
50849
50850   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50851   {
50852     try {
50853       result = (std::string *) &(arg1)->GetName();
50854     } CALL_CATCH_EXCEPTION(0);
50855   }
50856
50857   jresult = SWIG_csharp_string_callback(result->c_str());
50858   return jresult;
50859 }
50860
50861
50862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
50863   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50864   Dali::Property::Map *arg2 = 0 ;
50865   Dali::Size arg3 ;
50866   Dali::Size *argp3 ;
50867
50868   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50869   arg2 = (Dali::Property::Map *)jarg2;
50870   if (!arg2) {
50871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
50872     return ;
50873   }
50874   argp3 = (Dali::Size *)jarg3;
50875   if (!argp3) {
50876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
50877     return ;
50878   }
50879   arg3 = *argp3;
50880   {
50881     try {
50882       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
50883     } CALL_CATCH_EXCEPTION();
50884   }
50885
50886 }
50887
50888
50889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
50890   float jresult ;
50891   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50892   float arg2 ;
50893   float result;
50894
50895   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50896   arg2 = (float)jarg2;
50897   {
50898     try {
50899       result = (float)(arg1)->GetHeightForWidth(arg2);
50900     } CALL_CATCH_EXCEPTION(0);
50901   }
50902
50903   jresult = result;
50904   return jresult;
50905 }
50906
50907
50908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
50909   float jresult ;
50910   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50911   float arg2 ;
50912   float result;
50913
50914   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50915   arg2 = (float)jarg2;
50916   {
50917     try {
50918       result = (float)(arg1)->GetWidthForHeight(arg2);
50919     } CALL_CATCH_EXCEPTION(0);
50920   }
50921
50922   jresult = result;
50923   return jresult;
50924 }
50925
50926
50927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
50928   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50929   Dali::Vector2 *arg2 = 0 ;
50930
50931   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50932   arg2 = (Dali::Vector2 *)jarg2;
50933   if (!arg2) {
50934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
50935     return ;
50936   }
50937   {
50938     try {
50939       (arg1)->GetNaturalSize(*arg2);
50940     } CALL_CATCH_EXCEPTION();
50941   }
50942
50943 }
50944
50945
50946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
50947   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50948   float arg2 ;
50949
50950   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50951   arg2 = (int)jarg2;
50952   {
50953     try {
50954       (arg1)->SetDepthIndex(arg2);
50955     } CALL_CATCH_EXCEPTION();
50956   }
50957
50958 }
50959
50960
50961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
50962   int jresult ;
50963   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50964   int result;
50965
50966   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50967   {
50968     try {
50969       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
50970     } CALL_CATCH_EXCEPTION(0);
50971   }
50972
50973   jresult = result;
50974   return jresult;
50975 }
50976
50977
50978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
50979   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50980   Dali::Property::Map *arg2 = 0 ;
50981
50982   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50983   arg2 = (Dali::Property::Map *)jarg2;
50984   if (!arg2) {
50985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
50986     return ;
50987   }
50988   {
50989     try {
50990       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
50991     } CALL_CATCH_EXCEPTION();
50992   }
50993
50994 }
50995
50996
50997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
50998   void * jresult ;
50999   Dali::Toolkit::VisualFactory result;
51000
51001   {
51002     try {
51003       result = Dali::Toolkit::VisualFactory::Get();
51004     } CALL_CATCH_EXCEPTION(0);
51005   }
51006
51007   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51008   return jresult;
51009 }
51010
51011
51012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51013   void * jresult ;
51014   Dali::Toolkit::VisualFactory *result = 0 ;
51015
51016   {
51017     try {
51018       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51019     } CALL_CATCH_EXCEPTION(0);
51020   }
51021
51022   jresult = (void *)result;
51023   return jresult;
51024 }
51025
51026
51027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51028   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51029
51030   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51031   {
51032     try {
51033       delete arg1;
51034     } CALL_CATCH_EXCEPTION();
51035   }
51036
51037 }
51038
51039
51040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51041   void * jresult ;
51042   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51043   Dali::Toolkit::VisualFactory *result = 0 ;
51044
51045   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51046   if (!arg1) {
51047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51048     return 0;
51049   }
51050   {
51051     try {
51052       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51053     } CALL_CATCH_EXCEPTION(0);
51054   }
51055
51056   jresult = (void *)result;
51057   return jresult;
51058 }
51059
51060
51061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51062   void * jresult ;
51063   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51064   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51065   Dali::Toolkit::VisualFactory *result = 0 ;
51066
51067   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51068   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51069   if (!arg2) {
51070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51071     return 0;
51072   }
51073   {
51074     try {
51075       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51076     } CALL_CATCH_EXCEPTION(0);
51077   }
51078
51079   jresult = (void *)result;
51080   return jresult;
51081 }
51082
51083
51084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51085   void * jresult ;
51086   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51087   Dali::Property::Map *arg2 = 0 ;
51088   Dali::Toolkit::Visual::Base result;
51089
51090   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51091   arg2 = (Dali::Property::Map *)jarg2;
51092   if (!arg2) {
51093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51094     return 0;
51095   }
51096   {
51097     try {
51098       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51099     } CALL_CATCH_EXCEPTION(0);
51100   }
51101
51102   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51103   return jresult;
51104 }
51105
51106
51107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51108   void * jresult ;
51109   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51110   std::string *arg2 = 0 ;
51111   Dali::ImageDimensions arg3 ;
51112   Dali::ImageDimensions *argp3 ;
51113   Dali::Toolkit::Visual::Base result;
51114
51115   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51116   if (!jarg2) {
51117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51118     return 0;
51119   }
51120   std::string arg2_str(jarg2);
51121   arg2 = &arg2_str;
51122   argp3 = (Dali::ImageDimensions *)jarg3;
51123   if (!argp3) {
51124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51125     return 0;
51126   }
51127   arg3 = *argp3;
51128   {
51129     try {
51130       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51131     } CALL_CATCH_EXCEPTION(0);
51132   }
51133
51134   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51135
51136   //argout typemap for const std::string&
51137
51138   return jresult;
51139 }
51140
51141
51142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51143   void * jresult ;
51144   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51145
51146   {
51147     try {
51148       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51149     } CALL_CATCH_EXCEPTION(0);
51150   }
51151
51152   jresult = (void *)result;
51153   return jresult;
51154 }
51155
51156
51157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51158   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51159
51160   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51161   {
51162     try {
51163       delete arg1;
51164     } CALL_CATCH_EXCEPTION();
51165   }
51166
51167 }
51168
51169
51170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51171   void * jresult ;
51172   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51173   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51174
51175   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51176   if (!arg1) {
51177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51178     return 0;
51179   }
51180   {
51181     try {
51182       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51183     } CALL_CATCH_EXCEPTION(0);
51184   }
51185
51186   jresult = (void *)result;
51187   return jresult;
51188 }
51189
51190
51191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51192   void * jresult ;
51193   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51194   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51195   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51196
51197   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51198   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51199   if (!arg2) {
51200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51201     return 0;
51202   }
51203   {
51204     try {
51205       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51206     } CALL_CATCH_EXCEPTION(0);
51207   }
51208
51209   jresult = (void *)result;
51210   return jresult;
51211 }
51212
51213
51214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51215   void * jresult ;
51216   Dali::Toolkit::AsyncImageLoader result;
51217
51218   {
51219     try {
51220       result = Dali::Toolkit::AsyncImageLoader::New();
51221     } CALL_CATCH_EXCEPTION(0);
51222   }
51223
51224   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51225   return jresult;
51226 }
51227
51228
51229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51230   void * jresult ;
51231   Dali::BaseHandle arg1 ;
51232   Dali::BaseHandle *argp1 ;
51233   Dali::Toolkit::AsyncImageLoader result;
51234
51235   argp1 = (Dali::BaseHandle *)jarg1;
51236   if (!argp1) {
51237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51238     return 0;
51239   }
51240   arg1 = *argp1;
51241   {
51242     try {
51243       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51244     } CALL_CATCH_EXCEPTION(0);
51245   }
51246
51247   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51248   return jresult;
51249 }
51250
51251
51252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51253   unsigned int jresult ;
51254   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51255   std::string *arg2 = 0 ;
51256   uint32_t result;
51257
51258   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51259   if (!jarg2) {
51260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51261     return 0;
51262   }
51263   std::string arg2_str(jarg2);
51264   arg2 = &arg2_str;
51265   {
51266     try {
51267       result = (arg1)->Load((std::string const &)*arg2);
51268     } CALL_CATCH_EXCEPTION(0);
51269   }
51270
51271   jresult = result;
51272
51273   //argout typemap for const std::string&
51274
51275   return jresult;
51276 }
51277
51278
51279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51280   unsigned int jresult ;
51281   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51282   std::string *arg2 = 0 ;
51283   Dali::ImageDimensions arg3 ;
51284   Dali::ImageDimensions *argp3 ;
51285   uint32_t result;
51286
51287   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51288   if (!jarg2) {
51289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51290     return 0;
51291   }
51292   std::string arg2_str(jarg2);
51293   arg2 = &arg2_str;
51294   argp3 = (Dali::ImageDimensions *)jarg3;
51295   if (!argp3) {
51296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51297     return 0;
51298   }
51299   arg3 = *argp3;
51300   {
51301     try {
51302       result = (arg1)->Load((std::string const &)*arg2,arg3);
51303     } CALL_CATCH_EXCEPTION(0);
51304   }
51305
51306   jresult = result;
51307
51308   //argout typemap for const std::string&
51309
51310   return jresult;
51311 }
51312
51313
51314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51315   unsigned int jresult ;
51316   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51317   std::string *arg2 = 0 ;
51318   Dali::ImageDimensions arg3 ;
51319   Dali::FittingMode::Type arg4 ;
51320   Dali::SamplingMode::Type arg5 ;
51321   bool arg6 ;
51322   Dali::ImageDimensions *argp3 ;
51323   uint32_t result;
51324
51325   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51326   if (!jarg2) {
51327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51328     return 0;
51329   }
51330   std::string arg2_str(jarg2);
51331   arg2 = &arg2_str;
51332   argp3 = (Dali::ImageDimensions *)jarg3;
51333   if (!argp3) {
51334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51335     return 0;
51336   }
51337   arg3 = *argp3;
51338   arg4 = (Dali::FittingMode::Type)jarg4;
51339   arg5 = (Dali::SamplingMode::Type)jarg5;
51340   arg6 = jarg6 ? true : false;
51341   {
51342     try {
51343       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51344     } CALL_CATCH_EXCEPTION(0);
51345   }
51346
51347   jresult = result;
51348
51349   //argout typemap for const std::string&
51350
51351   return jresult;
51352 }
51353
51354
51355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51356   unsigned int jresult ;
51357   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51358   uint32_t arg2 ;
51359   bool result;
51360
51361   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51362   arg2 = (uint32_t)jarg2;
51363   {
51364     try {
51365       result = (bool)(arg1)->Cancel(arg2);
51366     } CALL_CATCH_EXCEPTION(0);
51367   }
51368
51369   jresult = result;
51370   return jresult;
51371 }
51372
51373
51374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51375   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51376
51377   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51378   {
51379     try {
51380       (arg1)->CancelAll();
51381     } CALL_CATCH_EXCEPTION();
51382   }
51383
51384 }
51385
51386
51387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51388   void * jresult ;
51389   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51390   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51391
51392   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51393   {
51394     try {
51395       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51396     } CALL_CATCH_EXCEPTION(0);
51397   }
51398
51399   jresult = (void *)result;
51400   return jresult;
51401 }
51402
51403
51404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51405   void * jresult ;
51406   std::string *arg1 = 0 ;
51407   Dali::PixelData result;
51408
51409   if (!jarg1) {
51410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51411     return 0;
51412   }
51413   std::string arg1_str(jarg1);
51414   arg1 = &arg1_str;
51415   {
51416     try {
51417       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51418     } CALL_CATCH_EXCEPTION(0);
51419   }
51420
51421   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51422
51423   //argout typemap for const std::string&
51424
51425   return jresult;
51426 }
51427
51428
51429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51430   void * jresult ;
51431   std::string *arg1 = 0 ;
51432   Dali::ImageDimensions arg2 ;
51433   Dali::ImageDimensions *argp2 ;
51434   Dali::PixelData result;
51435
51436   if (!jarg1) {
51437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51438     return 0;
51439   }
51440   std::string arg1_str(jarg1);
51441   arg1 = &arg1_str;
51442   argp2 = (Dali::ImageDimensions *)jarg2;
51443   if (!argp2) {
51444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51445     return 0;
51446   }
51447   arg2 = *argp2;
51448   {
51449     try {
51450       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51451     } CALL_CATCH_EXCEPTION(0);
51452   }
51453
51454   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51455
51456   //argout typemap for const std::string&
51457
51458   return jresult;
51459 }
51460
51461
51462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51463   void * jresult ;
51464   std::string *arg1 = 0 ;
51465   Dali::ImageDimensions arg2 ;
51466   Dali::FittingMode::Type arg3 ;
51467   Dali::SamplingMode::Type arg4 ;
51468   bool arg5 ;
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   arg3 = (Dali::FittingMode::Type)jarg3;
51485   arg4 = (Dali::SamplingMode::Type)jarg4;
51486   arg5 = jarg5 ? true : false;
51487   {
51488     try {
51489       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51490     } CALL_CATCH_EXCEPTION(0);
51491   }
51492
51493   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51494
51495   //argout typemap for const std::string&
51496
51497   return jresult;
51498 }
51499
51500
51501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51502   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51503
51504   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51505   {
51506     try {
51507       delete arg1;
51508     } CALL_CATCH_EXCEPTION();
51509   }
51510
51511 }
51512
51513
51514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51515   void * jresult ;
51516   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51517   Dali::Actor arg2 ;
51518   Dali::Actor arg3 ;
51519   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51520   Dali::Actor *argp2 ;
51521   Dali::Actor *argp3 ;
51522   Dali::Actor result;
51523
51524   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51525   argp2 = (Dali::Actor *)jarg2;
51526   if (!argp2) {
51527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51528     return 0;
51529   }
51530   arg2 = *argp2;
51531   argp3 = (Dali::Actor *)jarg3;
51532   if (!argp3) {
51533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51534     return 0;
51535   }
51536   arg3 = *argp3;
51537   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51538   {
51539     try {
51540       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51541     } CALL_CATCH_EXCEPTION(0);
51542   }
51543
51544   jresult = new Dali::Actor((const Dali::Actor &)result);
51545   return jresult;
51546 }
51547
51548
51549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51550   void * jresult ;
51551   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51552
51553   {
51554     try {
51555       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51556     } CALL_CATCH_EXCEPTION(0);
51557   }
51558
51559   jresult = (void *)result;
51560   return jresult;
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51565   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51566   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51567   if (director) {
51568     director->swig_connect_director(callback0);
51569   }
51570 }
51571
51572
51573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51574   void * jresult ;
51575   Dali::FrameCallbackInterface *result = 0 ;
51576
51577   {
51578     try {
51579       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51580     } CALL_CATCH_EXCEPTION(0);
51581   }
51582
51583   jresult = (void *)result;
51584   return jresult;
51585 }
51586
51587 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51588   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51589   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51590   return proxy->GetPosition(id, *vector3);
51591 }
51592
51593 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51594   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51595   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51596   return proxy->SetPosition(id, *vector3);
51597 }
51598
51599 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51600   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51601   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51602   return proxy->BakePosition(id, *vector3);
51603 }
51604
51605 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51606   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51607   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51608   return proxy->GetSize(id, *vector3);
51609 }
51610
51611 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51612   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51613   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51614   return proxy->SetSize(id, *vector3);
51615 }
51616 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51617   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51618   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51619   return proxy->BakeSize(id, *vector3);
51620 }
51621
51622 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51623   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51624   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51625   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51626   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51627 }
51628
51629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51630   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51631   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51632   return proxy->GetScale(id,* vector3);
51633 }
51634
51635 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51636   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51637   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51638   return proxy->SetScale(id, *vector3);
51639 }
51640
51641 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51642   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51643   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51644   return proxy->BakeScale(id, *vector3);
51645 }
51646
51647 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51648   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51649   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51650   return proxy->GetColor(id, *vector4);
51651 }
51652
51653 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51654   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51655   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51656   return proxy->SetColor(id, *vector4);
51657 }
51658
51659 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51660   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51661   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51662   return proxy->BakeColor(id, *vector4);
51663 }
51664
51665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51666   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51667   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51668
51669   Dali::Stage *arg1 = (Dali::Stage *) 0;
51670   Dali::Actor *arg3 = 0;
51671
51672   arg1 = (Dali::Stage *)jarg1;
51673   arg3 = (Dali::Actor *)jarg3;
51674
51675   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51676   return;
51677 }
51678
51679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51680
51681   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51682   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51683
51684   Dali::Stage *arg1 = (Dali::Stage *) 0;
51685
51686   arg1 = (Dali::Stage *)jarg1;
51687
51688   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51689   return;
51690 }
51691
51692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51693   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51694   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51695   if (director) {
51696     director->swig_connect_director(callback0);
51697   }
51698 }
51699
51700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51701   KeyboardFocusManager arg1 ;
51702   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51703   KeyboardFocusManager *argp1 ;
51704
51705   argp1 = (KeyboardFocusManager *)jarg1;
51706   if (!argp1) {
51707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51708     return ;
51709   }
51710   arg1 = *argp1;
51711   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51712   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51713   {
51714     try {
51715       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51716     } CALL_CATCH_EXCEPTION();
51717   }
51718
51719 }
51720
51721
51722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51723   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51724
51725   arg1 = (std::vector< unsigned int > *)jarg1;
51726   {
51727     try {
51728       (arg1)->clear();
51729     } CALL_CATCH_EXCEPTION();
51730   }
51731
51732 }
51733
51734
51735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
51736   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51737   unsigned int *arg2 = 0 ;
51738   unsigned int temp2 ;
51739
51740   arg1 = (std::vector< unsigned int > *)jarg1;
51741   temp2 = (unsigned int)jarg2;
51742   arg2 = &temp2;
51743   {
51744     try {
51745       (arg1)->push_back((unsigned int const &)*arg2);
51746     } CALL_CATCH_EXCEPTION();
51747   }
51748
51749 }
51750
51751
51752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
51753   unsigned long jresult ;
51754   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51755   std::vector< unsigned int >::size_type result;
51756
51757   arg1 = (std::vector< unsigned int > *)jarg1;
51758   {
51759     try {
51760       result = ((std::vector< unsigned int > const *)arg1)->size();
51761     } CALL_CATCH_EXCEPTION(0);
51762   }
51763
51764   jresult = (unsigned long)result;
51765   return jresult;
51766 }
51767
51768
51769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
51770   unsigned long jresult ;
51771   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51772   std::vector< unsigned int >::size_type result;
51773
51774   arg1 = (std::vector< unsigned int > *)jarg1;
51775   {
51776     try {
51777       result = ((std::vector< unsigned int > const *)arg1)->capacity();
51778     } CALL_CATCH_EXCEPTION(0);
51779   }
51780
51781   jresult = (unsigned long)result;
51782   return jresult;
51783 }
51784
51785
51786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
51787   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51788   std::vector< unsigned int >::size_type arg2 ;
51789
51790   arg1 = (std::vector< unsigned int > *)jarg1;
51791   arg2 = (std::vector< unsigned int >::size_type)jarg2;
51792   {
51793     try {
51794       (arg1)->reserve(arg2);
51795     } CALL_CATCH_EXCEPTION();
51796   }
51797
51798 }
51799
51800
51801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
51802   void * jresult ;
51803   std::vector< unsigned int > *result = 0 ;
51804
51805   {
51806     try {
51807       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
51808     } CALL_CATCH_EXCEPTION(0);
51809   }
51810
51811   jresult = (void *)result;
51812   return jresult;
51813 }
51814
51815
51816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
51817   void * jresult ;
51818   std::vector< unsigned int > *arg1 = 0 ;
51819   std::vector< unsigned int > *result = 0 ;
51820
51821   arg1 = (std::vector< unsigned int > *)jarg1;
51822   if (!arg1) {
51823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
51824     return 0;
51825   }
51826   {
51827     try {
51828       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
51829     } CALL_CATCH_EXCEPTION(0);
51830   }
51831
51832   jresult = (void *)result;
51833   return jresult;
51834 }
51835
51836
51837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
51838   void * jresult ;
51839   int arg1 ;
51840   std::vector< unsigned int > *result = 0 ;
51841
51842   arg1 = (int)jarg1;
51843   {
51844     try {
51845       try {
51846         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
51847       }
51848       catch(std::out_of_range &_e) {
51849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51850         return 0;
51851       }
51852
51853     } CALL_CATCH_EXCEPTION(0);
51854   }
51855
51856   jresult = (void *)result;
51857   return jresult;
51858 }
51859
51860
51861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
51862   unsigned int jresult ;
51863   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51864   int arg2 ;
51865   unsigned int result;
51866
51867   arg1 = (std::vector< unsigned int > *)jarg1;
51868   arg2 = (int)jarg2;
51869   {
51870     try {
51871       try {
51872         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
51873       }
51874       catch(std::out_of_range &_e) {
51875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51876         return 0;
51877       }
51878
51879     } CALL_CATCH_EXCEPTION(0);
51880   }
51881
51882   jresult = result;
51883   return jresult;
51884 }
51885
51886
51887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
51888   unsigned int jresult ;
51889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51890   int arg2 ;
51891   unsigned int *result = 0 ;
51892
51893   arg1 = (std::vector< unsigned int > *)jarg1;
51894   arg2 = (int)jarg2;
51895   {
51896     try {
51897       try {
51898         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
51899       }
51900       catch(std::out_of_range &_e) {
51901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51902         return 0;
51903       }
51904
51905     } CALL_CATCH_EXCEPTION(0);
51906   }
51907
51908   jresult = *result;
51909   return jresult;
51910 }
51911
51912
51913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
51914   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51915   int arg2 ;
51916   unsigned int *arg3 = 0 ;
51917   unsigned int temp3 ;
51918
51919   arg1 = (std::vector< unsigned int > *)jarg1;
51920   arg2 = (int)jarg2;
51921   temp3 = (unsigned int)jarg3;
51922   arg3 = &temp3;
51923   {
51924     try {
51925       try {
51926         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
51927       }
51928       catch(std::out_of_range &_e) {
51929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51930         return ;
51931       }
51932
51933     } CALL_CATCH_EXCEPTION();
51934   }
51935
51936 }
51937
51938
51939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
51940   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51941   std::vector< unsigned int > *arg2 = 0 ;
51942
51943   arg1 = (std::vector< unsigned int > *)jarg1;
51944   arg2 = (std::vector< unsigned int > *)jarg2;
51945   if (!arg2) {
51946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
51947     return ;
51948   }
51949   {
51950     try {
51951       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
51952     } CALL_CATCH_EXCEPTION();
51953   }
51954
51955 }
51956
51957
51958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
51959   void * jresult ;
51960   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51961   int arg2 ;
51962   int arg3 ;
51963   std::vector< unsigned int > *result = 0 ;
51964
51965   arg1 = (std::vector< unsigned int > *)jarg1;
51966   arg2 = (int)jarg2;
51967   arg3 = (int)jarg3;
51968   {
51969     try {
51970       try {
51971         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
51972       }
51973       catch(std::out_of_range &_e) {
51974         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
51975         return 0;
51976       }
51977       catch(std::invalid_argument &_e) {
51978         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
51979         return 0;
51980       }
51981
51982     } CALL_CATCH_EXCEPTION(0);
51983   }
51984
51985   jresult = (void *)result;
51986   return jresult;
51987 }
51988
51989
51990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
51991   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51992   int arg2 ;
51993   unsigned int *arg3 = 0 ;
51994   unsigned int temp3 ;
51995
51996   arg1 = (std::vector< unsigned int > *)jarg1;
51997   arg2 = (int)jarg2;
51998   temp3 = (unsigned int)jarg3;
51999   arg3 = &temp3;
52000   {
52001     try {
52002       try {
52003         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52004       }
52005       catch(std::out_of_range &_e) {
52006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52007         return ;
52008       }
52009
52010     } CALL_CATCH_EXCEPTION();
52011   }
52012
52013 }
52014
52015
52016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52017   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52018   int arg2 ;
52019   std::vector< unsigned int > *arg3 = 0 ;
52020
52021   arg1 = (std::vector< unsigned int > *)jarg1;
52022   arg2 = (int)jarg2;
52023   arg3 = (std::vector< unsigned int > *)jarg3;
52024   if (!arg3) {
52025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52026     return ;
52027   }
52028   {
52029     try {
52030       try {
52031         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52032       }
52033       catch(std::out_of_range &_e) {
52034         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52035         return ;
52036       }
52037
52038     } CALL_CATCH_EXCEPTION();
52039   }
52040
52041 }
52042
52043
52044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52045   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52046   int arg2 ;
52047
52048   arg1 = (std::vector< unsigned int > *)jarg1;
52049   arg2 = (int)jarg2;
52050   {
52051     try {
52052       try {
52053         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52054       }
52055       catch(std::out_of_range &_e) {
52056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52057         return ;
52058       }
52059
52060     } CALL_CATCH_EXCEPTION();
52061   }
52062
52063 }
52064
52065
52066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52067   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52068   int arg2 ;
52069   int arg3 ;
52070
52071   arg1 = (std::vector< unsigned int > *)jarg1;
52072   arg2 = (int)jarg2;
52073   arg3 = (int)jarg3;
52074   {
52075     try {
52076       try {
52077         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52078       }
52079       catch(std::out_of_range &_e) {
52080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52081         return ;
52082       }
52083       catch(std::invalid_argument &_e) {
52084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52085         return ;
52086       }
52087
52088     } CALL_CATCH_EXCEPTION();
52089   }
52090
52091 }
52092
52093
52094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52095   void * jresult ;
52096   unsigned int *arg1 = 0 ;
52097   int arg2 ;
52098   unsigned int temp1 ;
52099   std::vector< unsigned int > *result = 0 ;
52100
52101   temp1 = (unsigned int)jarg1;
52102   arg1 = &temp1;
52103   arg2 = (int)jarg2;
52104   {
52105     try {
52106       try {
52107         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52108       }
52109       catch(std::out_of_range &_e) {
52110         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52111         return 0;
52112       }
52113
52114     } CALL_CATCH_EXCEPTION(0);
52115   }
52116
52117   jresult = (void *)result;
52118   return jresult;
52119 }
52120
52121
52122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52123   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52124
52125   arg1 = (std::vector< unsigned int > *)jarg1;
52126   {
52127     try {
52128       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52129     } CALL_CATCH_EXCEPTION();
52130   }
52131
52132 }
52133
52134
52135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52137   int arg2 ;
52138   int arg3 ;
52139
52140   arg1 = (std::vector< unsigned int > *)jarg1;
52141   arg2 = (int)jarg2;
52142   arg3 = (int)jarg3;
52143   {
52144     try {
52145       try {
52146         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52147       }
52148       catch(std::out_of_range &_e) {
52149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52150         return ;
52151       }
52152       catch(std::invalid_argument &_e) {
52153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52154         return ;
52155       }
52156
52157     } CALL_CATCH_EXCEPTION();
52158   }
52159
52160 }
52161
52162
52163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52164   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52165   int arg2 ;
52166   std::vector< unsigned int > *arg3 = 0 ;
52167
52168   arg1 = (std::vector< unsigned int > *)jarg1;
52169   arg2 = (int)jarg2;
52170   arg3 = (std::vector< unsigned int > *)jarg3;
52171   if (!arg3) {
52172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52173     return ;
52174   }
52175   {
52176     try {
52177       try {
52178         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52179       }
52180       catch(std::out_of_range &_e) {
52181         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52182         return ;
52183       }
52184
52185     } CALL_CATCH_EXCEPTION();
52186   }
52187
52188 }
52189
52190
52191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52192   unsigned int jresult ;
52193   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52194   unsigned int *arg2 = 0 ;
52195   unsigned int temp2 ;
52196   bool result;
52197
52198   arg1 = (std::vector< unsigned int > *)jarg1;
52199   temp2 = (unsigned int)jarg2;
52200   arg2 = &temp2;
52201   {
52202     try {
52203       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52204     } CALL_CATCH_EXCEPTION(0);
52205   }
52206
52207   jresult = result;
52208   return jresult;
52209 }
52210
52211
52212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52213   int jresult ;
52214   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52215   unsigned int *arg2 = 0 ;
52216   unsigned int temp2 ;
52217   int result;
52218
52219   arg1 = (std::vector< unsigned int > *)jarg1;
52220   temp2 = (unsigned int)jarg2;
52221   arg2 = &temp2;
52222   {
52223     try {
52224       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52225     } CALL_CATCH_EXCEPTION(0);
52226   }
52227
52228   jresult = result;
52229   return jresult;
52230 }
52231
52232
52233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52234   int jresult ;
52235   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52236   unsigned int *arg2 = 0 ;
52237   unsigned int temp2 ;
52238   int result;
52239
52240   arg1 = (std::vector< unsigned int > *)jarg1;
52241   temp2 = (unsigned int)jarg2;
52242   arg2 = &temp2;
52243   {
52244     try {
52245       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52246     } CALL_CATCH_EXCEPTION(0);
52247   }
52248
52249   jresult = result;
52250   return jresult;
52251 }
52252
52253
52254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52255   unsigned int jresult ;
52256   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52257   unsigned int *arg2 = 0 ;
52258   unsigned int temp2 ;
52259   bool result;
52260
52261   arg1 = (std::vector< unsigned int > *)jarg1;
52262   temp2 = (unsigned int)jarg2;
52263   arg2 = &temp2;
52264   {
52265     try {
52266       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52267     } CALL_CATCH_EXCEPTION(0);
52268   }
52269
52270   jresult = result;
52271   return jresult;
52272 }
52273
52274
52275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52276   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52277
52278   arg1 = (std::vector< unsigned int > *)jarg1;
52279   {
52280     try {
52281       delete arg1;
52282     } CALL_CATCH_EXCEPTION();
52283   }
52284
52285 }
52286
52287
52288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52289   void * jresult ;
52290   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52291
52292   {
52293     try {
52294       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52295     } CALL_CATCH_EXCEPTION(0);
52296   }
52297
52298   jresult = (void *)result;
52299   return jresult;
52300 }
52301
52302
52303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52304   void * jresult ;
52305   unsigned int arg1 ;
52306   Dali::Actor arg2 ;
52307   Dali::Actor *argp2 ;
52308   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52309
52310   arg1 = (unsigned int)jarg1;
52311   argp2 = (Dali::Actor *)jarg2;
52312   if (!argp2) {
52313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52314     return 0;
52315   }
52316   arg2 = *argp2;
52317   {
52318     try {
52319       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52320     } CALL_CATCH_EXCEPTION(0);
52321   }
52322
52323   jresult = (void *)result;
52324   return jresult;
52325 }
52326
52327
52328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52329   void * jresult ;
52330   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52331   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52332
52333   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52334   if (!arg1) {
52335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52336     return 0;
52337   }
52338   {
52339     try {
52340       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52341     } CALL_CATCH_EXCEPTION(0);
52342   }
52343
52344   jresult = (void *)result;
52345   return jresult;
52346 }
52347
52348
52349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52350   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52351   unsigned int arg2 ;
52352
52353   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52354   arg2 = (unsigned int)jarg2;
52355   if (arg1) (arg1)->first = arg2;
52356 }
52357
52358
52359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52360   unsigned int jresult ;
52361   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52362   unsigned int result;
52363
52364   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52365   result = (unsigned int) ((arg1)->first);
52366   jresult = result;
52367   return jresult;
52368 }
52369
52370
52371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52372   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52373   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52374
52375   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52376   arg2 = (Dali::Actor *)jarg2;
52377   if (arg1) (arg1)->second = *arg2;
52378 }
52379
52380
52381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52382   void * jresult ;
52383   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52384   Dali::Actor *result = 0 ;
52385
52386   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52387   result = (Dali::Actor *)& ((arg1)->second);
52388   jresult = (void *)result;
52389   return jresult;
52390 }
52391
52392
52393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52394   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52395
52396   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52397   {
52398     try {
52399       delete arg1;
52400     } CALL_CATCH_EXCEPTION();
52401   }
52402
52403 }
52404
52405
52406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52407   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52408
52409   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52410   {
52411     try {
52412       (arg1)->clear();
52413     } CALL_CATCH_EXCEPTION();
52414   }
52415
52416 }
52417
52418
52419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52420   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52421   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52422
52423   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52424   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52425   if (!arg2) {
52426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52427     return ;
52428   }
52429   {
52430     try {
52431       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52432     } CALL_CATCH_EXCEPTION();
52433   }
52434
52435 }
52436
52437
52438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52439   unsigned long jresult ;
52440   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52441   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52442
52443   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52444   {
52445     try {
52446       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52447     } CALL_CATCH_EXCEPTION(0);
52448   }
52449
52450   jresult = (unsigned long)result;
52451   return jresult;
52452 }
52453
52454
52455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
52456   unsigned long jresult ;
52457   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52458   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52459
52460   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52461   {
52462     try {
52463       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
52464     } CALL_CATCH_EXCEPTION(0);
52465   }
52466
52467   jresult = (unsigned long)result;
52468   return jresult;
52469 }
52470
52471
52472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52473   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52474   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52475
52476   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52477   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52478   {
52479     try {
52480       (arg1)->reserve(arg2);
52481     } CALL_CATCH_EXCEPTION();
52482   }
52483
52484 }
52485
52486
52487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52488   void * jresult ;
52489   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52490
52491   {
52492     try {
52493       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52494     } CALL_CATCH_EXCEPTION(0);
52495   }
52496
52497   jresult = (void *)result;
52498   return jresult;
52499 }
52500
52501
52502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52503   void * jresult ;
52504   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52505   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52506
52507   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52508   if (!arg1) {
52509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52510     return 0;
52511   }
52512   {
52513     try {
52514       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);
52515     } CALL_CATCH_EXCEPTION(0);
52516   }
52517
52518   jresult = (void *)result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52524   void * jresult ;
52525   int arg1 ;
52526   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52527
52528   arg1 = (int)jarg1;
52529   {
52530     try {
52531       try {
52532         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);
52533       }
52534       catch(std::out_of_range &_e) {
52535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52536         return 0;
52537       }
52538
52539     } CALL_CATCH_EXCEPTION(0);
52540   }
52541
52542   jresult = (void *)result;
52543   return jresult;
52544 }
52545
52546
52547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52548   void * jresult ;
52549   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52550   int arg2 ;
52551   std::pair< unsigned int,Dali::Actor > result;
52552
52553   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52554   arg2 = (int)jarg2;
52555   {
52556     try {
52557       try {
52558         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52559       }
52560       catch(std::out_of_range &_e) {
52561         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52562         return 0;
52563       }
52564
52565     } CALL_CATCH_EXCEPTION(0);
52566   }
52567
52568   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52569   return jresult;
52570 }
52571
52572
52573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52574   void * jresult ;
52575   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52576   int arg2 ;
52577   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52578
52579   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52580   arg2 = (int)jarg2;
52581   {
52582     try {
52583       try {
52584         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52585       }
52586       catch(std::out_of_range &_e) {
52587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52588         return 0;
52589       }
52590
52591     } CALL_CATCH_EXCEPTION(0);
52592   }
52593
52594   jresult = (void *)result;
52595   return jresult;
52596 }
52597
52598
52599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52600   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52601   int arg2 ;
52602   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52603
52604   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52605   arg2 = (int)jarg2;
52606   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52607   if (!arg3) {
52608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52609     return ;
52610   }
52611   {
52612     try {
52613       try {
52614         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);
52615       }
52616       catch(std::out_of_range &_e) {
52617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52618         return ;
52619       }
52620
52621     } CALL_CATCH_EXCEPTION();
52622   }
52623
52624 }
52625
52626
52627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52628   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52629   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52630
52631   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52632   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52633   if (!arg2) {
52634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52635     return ;
52636   }
52637   {
52638     try {
52639       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);
52640     } CALL_CATCH_EXCEPTION();
52641   }
52642
52643 }
52644
52645
52646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52647   void * jresult ;
52648   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52649   int arg2 ;
52650   int arg3 ;
52651   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52652
52653   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52654   arg2 = (int)jarg2;
52655   arg3 = (int)jarg3;
52656   {
52657     try {
52658       try {
52659         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);
52660       }
52661       catch(std::out_of_range &_e) {
52662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52663         return 0;
52664       }
52665       catch(std::invalid_argument &_e) {
52666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52667         return 0;
52668       }
52669
52670     } CALL_CATCH_EXCEPTION(0);
52671   }
52672
52673   jresult = (void *)result;
52674   return jresult;
52675 }
52676
52677
52678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52679   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52680   int arg2 ;
52681   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52682
52683   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52684   arg2 = (int)jarg2;
52685   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52686   if (!arg3) {
52687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52688     return ;
52689   }
52690   {
52691     try {
52692       try {
52693         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);
52694       }
52695       catch(std::out_of_range &_e) {
52696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52697         return ;
52698       }
52699
52700     } CALL_CATCH_EXCEPTION();
52701   }
52702
52703 }
52704
52705
52706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52707   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52708   int arg2 ;
52709   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52710
52711   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52712   arg2 = (int)jarg2;
52713   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52714   if (!arg3) {
52715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52716     return ;
52717   }
52718   {
52719     try {
52720       try {
52721         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);
52722       }
52723       catch(std::out_of_range &_e) {
52724         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52725         return ;
52726       }
52727
52728     } CALL_CATCH_EXCEPTION();
52729   }
52730
52731 }
52732
52733
52734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
52735   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52736   int arg2 ;
52737
52738   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52739   arg2 = (int)jarg2;
52740   {
52741     try {
52742       try {
52743         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
52744       }
52745       catch(std::out_of_range &_e) {
52746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52747         return ;
52748       }
52749
52750     } CALL_CATCH_EXCEPTION();
52751   }
52752
52753 }
52754
52755
52756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52757   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52758   int arg2 ;
52759   int arg3 ;
52760
52761   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52762   arg2 = (int)jarg2;
52763   arg3 = (int)jarg3;
52764   {
52765     try {
52766       try {
52767         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
52768       }
52769       catch(std::out_of_range &_e) {
52770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52771         return ;
52772       }
52773       catch(std::invalid_argument &_e) {
52774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52775         return ;
52776       }
52777
52778     } CALL_CATCH_EXCEPTION();
52779   }
52780
52781 }
52782
52783
52784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
52785   void * jresult ;
52786   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52787   int arg2 ;
52788   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52789
52790   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52791   if (!arg1) {
52792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52793     return 0;
52794   }
52795   arg2 = (int)jarg2;
52796   {
52797     try {
52798       try {
52799         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);
52800       }
52801       catch(std::out_of_range &_e) {
52802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52803         return 0;
52804       }
52805
52806     } CALL_CATCH_EXCEPTION(0);
52807   }
52808
52809   jresult = (void *)result;
52810   return jresult;
52811 }
52812
52813
52814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
52815   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52816
52817   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52818   {
52819     try {
52820       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
52821     } CALL_CATCH_EXCEPTION();
52822   }
52823
52824 }
52825
52826
52827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52828   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52829   int arg2 ;
52830   int arg3 ;
52831
52832   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52833   arg2 = (int)jarg2;
52834   arg3 = (int)jarg3;
52835   {
52836     try {
52837       try {
52838         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52839       }
52840       catch(std::out_of_range &_e) {
52841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52842         return ;
52843       }
52844       catch(std::invalid_argument &_e) {
52845         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52846         return ;
52847       }
52848
52849     } CALL_CATCH_EXCEPTION();
52850   }
52851
52852 }
52853
52854
52855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52856   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52857   int arg2 ;
52858   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52859
52860   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52861   arg2 = (int)jarg2;
52862   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52863   if (!arg3) {
52864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52865     return ;
52866   }
52867   {
52868     try {
52869       try {
52870         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3);
52871       }
52872       catch(std::out_of_range &_e) {
52873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52874         return ;
52875       }
52876
52877     } CALL_CATCH_EXCEPTION();
52878   }
52879
52880 }
52881
52882
52883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
52884   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52885
52886   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52887   {
52888     try {
52889       delete arg1;
52890     } CALL_CATCH_EXCEPTION();
52891   }
52892
52893 }
52894
52895
52896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
52897   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52898
52899   arg1 = (std::vector< Dali::Actor > *)jarg1;
52900   {
52901     try {
52902       (arg1)->clear();
52903     } CALL_CATCH_EXCEPTION();
52904   }
52905
52906 }
52907
52908
52909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
52910   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52911   Dali::Actor *arg2 = 0 ;
52912
52913   arg1 = (std::vector< Dali::Actor > *)jarg1;
52914   arg2 = (Dali::Actor *)jarg2;
52915   if (!arg2) {
52916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
52917     return ;
52918   }
52919   {
52920     try {
52921       (arg1)->push_back((Dali::Actor const &)*arg2);
52922     } CALL_CATCH_EXCEPTION();
52923   }
52924
52925 }
52926
52927
52928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
52929   unsigned long jresult ;
52930   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52931   std::vector< Dali::Actor >::size_type result;
52932
52933   arg1 = (std::vector< Dali::Actor > *)jarg1;
52934   {
52935     try {
52936       result = ((std::vector< Dali::Actor > const *)arg1)->size();
52937     } CALL_CATCH_EXCEPTION(0);
52938   }
52939
52940   jresult = (unsigned long)result;
52941   return jresult;
52942 }
52943
52944
52945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
52946   unsigned long jresult ;
52947   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52948   std::vector< Dali::Actor >::size_type result;
52949
52950   arg1 = (std::vector< Dali::Actor > *)jarg1;
52951   {
52952     try {
52953       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
52954     } CALL_CATCH_EXCEPTION(0);
52955   }
52956
52957   jresult = (unsigned long)result;
52958   return jresult;
52959 }
52960
52961
52962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
52963   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
52964   std::vector< Dali::Actor >::size_type arg2 ;
52965
52966   arg1 = (std::vector< Dali::Actor > *)jarg1;
52967   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
52968   {
52969     try {
52970       (arg1)->reserve(arg2);
52971     } CALL_CATCH_EXCEPTION();
52972   }
52973
52974 }
52975
52976
52977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
52978   void * jresult ;
52979   std::vector< Dali::Actor > *result = 0 ;
52980
52981   {
52982     try {
52983       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
52984     } CALL_CATCH_EXCEPTION(0);
52985   }
52986
52987   jresult = (void *)result;
52988   return jresult;
52989 }
52990
52991
52992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
52993   void * jresult ;
52994   std::vector< Dali::Actor > *arg1 = 0 ;
52995   std::vector< Dali::Actor > *result = 0 ;
52996
52997   arg1 = (std::vector< Dali::Actor > *)jarg1;
52998   if (!arg1) {
52999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53000     return 0;
53001   }
53002   {
53003     try {
53004       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53005     } CALL_CATCH_EXCEPTION(0);
53006   }
53007
53008   jresult = (void *)result;
53009   return jresult;
53010 }
53011
53012
53013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53014   void * jresult ;
53015   int arg1 ;
53016   std::vector< Dali::Actor > *result = 0 ;
53017
53018   arg1 = (int)jarg1;
53019   {
53020     try {
53021       try {
53022         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53023       }
53024       catch(std::out_of_range &_e) {
53025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53026         return 0;
53027       }
53028
53029     } CALL_CATCH_EXCEPTION(0);
53030   }
53031
53032   jresult = (void *)result;
53033   return jresult;
53034 }
53035
53036
53037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53038   void * jresult ;
53039   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53040   int arg2 ;
53041   Dali::Actor result;
53042
53043   arg1 = (std::vector< Dali::Actor > *)jarg1;
53044   arg2 = (int)jarg2;
53045   {
53046     try {
53047       try {
53048         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53049       }
53050       catch(std::out_of_range &_e) {
53051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53052         return 0;
53053       }
53054
53055     } CALL_CATCH_EXCEPTION(0);
53056   }
53057
53058   jresult = new Dali::Actor((const Dali::Actor &)result);
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53064   void * jresult ;
53065   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53066   int arg2 ;
53067   Dali::Actor *result = 0 ;
53068
53069   arg1 = (std::vector< Dali::Actor > *)jarg1;
53070   arg2 = (int)jarg2;
53071   {
53072     try {
53073       try {
53074         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53075       }
53076       catch(std::out_of_range &_e) {
53077         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53078         return 0;
53079       }
53080
53081     } CALL_CATCH_EXCEPTION(0);
53082   }
53083
53084   jresult = (void *)result;
53085   return jresult;
53086 }
53087
53088
53089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53090   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53091   int arg2 ;
53092   Dali::Actor *arg3 = 0 ;
53093
53094   arg1 = (std::vector< Dali::Actor > *)jarg1;
53095   arg2 = (int)jarg2;
53096   arg3 = (Dali::Actor *)jarg3;
53097   if (!arg3) {
53098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53099     return ;
53100   }
53101   {
53102     try {
53103       try {
53104         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53105       }
53106       catch(std::out_of_range &_e) {
53107         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53108         return ;
53109       }
53110
53111     } CALL_CATCH_EXCEPTION();
53112   }
53113
53114 }
53115
53116
53117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53118   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53119   std::vector< Dali::Actor > *arg2 = 0 ;
53120
53121   arg1 = (std::vector< Dali::Actor > *)jarg1;
53122   arg2 = (std::vector< Dali::Actor > *)jarg2;
53123   if (!arg2) {
53124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53125     return ;
53126   }
53127   {
53128     try {
53129       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53130     } CALL_CATCH_EXCEPTION();
53131   }
53132
53133 }
53134
53135
53136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53137   void * jresult ;
53138   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53139   int arg2 ;
53140   int arg3 ;
53141   std::vector< Dali::Actor > *result = 0 ;
53142
53143   arg1 = (std::vector< Dali::Actor > *)jarg1;
53144   arg2 = (int)jarg2;
53145   arg3 = (int)jarg3;
53146   {
53147     try {
53148       try {
53149         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53150       }
53151       catch(std::out_of_range &_e) {
53152         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53153         return 0;
53154       }
53155       catch(std::invalid_argument &_e) {
53156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53157         return 0;
53158       }
53159
53160     } CALL_CATCH_EXCEPTION(0);
53161   }
53162
53163   jresult = (void *)result;
53164   return jresult;
53165 }
53166
53167
53168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53169   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53170   int arg2 ;
53171   Dali::Actor *arg3 = 0 ;
53172
53173   arg1 = (std::vector< Dali::Actor > *)jarg1;
53174   arg2 = (int)jarg2;
53175   arg3 = (Dali::Actor *)jarg3;
53176   if (!arg3) {
53177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53178     return ;
53179   }
53180   {
53181     try {
53182       try {
53183         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53184       }
53185       catch(std::out_of_range &_e) {
53186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53187         return ;
53188       }
53189
53190     } CALL_CATCH_EXCEPTION();
53191   }
53192
53193 }
53194
53195
53196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53197   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53198   int arg2 ;
53199   std::vector< Dali::Actor > *arg3 = 0 ;
53200
53201   arg1 = (std::vector< Dali::Actor > *)jarg1;
53202   arg2 = (int)jarg2;
53203   arg3 = (std::vector< Dali::Actor > *)jarg3;
53204   if (!arg3) {
53205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53206     return ;
53207   }
53208   {
53209     try {
53210       try {
53211         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53212       }
53213       catch(std::out_of_range &_e) {
53214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53215         return ;
53216       }
53217
53218     } CALL_CATCH_EXCEPTION();
53219   }
53220
53221 }
53222
53223
53224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53225   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53226   int arg2 ;
53227
53228   arg1 = (std::vector< Dali::Actor > *)jarg1;
53229   arg2 = (int)jarg2;
53230   {
53231     try {
53232       try {
53233         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53234       }
53235       catch(std::out_of_range &_e) {
53236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53237         return ;
53238       }
53239
53240     } CALL_CATCH_EXCEPTION();
53241   }
53242
53243 }
53244
53245
53246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53247   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53248   int arg2 ;
53249   int arg3 ;
53250
53251   arg1 = (std::vector< Dali::Actor > *)jarg1;
53252   arg2 = (int)jarg2;
53253   arg3 = (int)jarg3;
53254   {
53255     try {
53256       try {
53257         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53258       }
53259       catch(std::out_of_range &_e) {
53260         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53261         return ;
53262       }
53263       catch(std::invalid_argument &_e) {
53264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53265         return ;
53266       }
53267
53268     } CALL_CATCH_EXCEPTION();
53269   }
53270
53271 }
53272
53273
53274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53275   void * jresult ;
53276   Dali::Actor *arg1 = 0 ;
53277   int arg2 ;
53278   std::vector< Dali::Actor > *result = 0 ;
53279
53280   arg1 = (Dali::Actor *)jarg1;
53281   if (!arg1) {
53282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53283     return 0;
53284   }
53285   arg2 = (int)jarg2;
53286   {
53287     try {
53288       try {
53289         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53290       }
53291       catch(std::out_of_range &_e) {
53292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53293         return 0;
53294       }
53295
53296     } CALL_CATCH_EXCEPTION(0);
53297   }
53298
53299   jresult = (void *)result;
53300   return jresult;
53301 }
53302
53303
53304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53305   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53306
53307   arg1 = (std::vector< Dali::Actor > *)jarg1;
53308   {
53309     try {
53310       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53311     } CALL_CATCH_EXCEPTION();
53312   }
53313
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53318   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53319   int arg2 ;
53320   int arg3 ;
53321
53322   arg1 = (std::vector< Dali::Actor > *)jarg1;
53323   arg2 = (int)jarg2;
53324   arg3 = (int)jarg3;
53325   {
53326     try {
53327       try {
53328         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53329       }
53330       catch(std::out_of_range &_e) {
53331         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53332         return ;
53333       }
53334       catch(std::invalid_argument &_e) {
53335         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53336         return ;
53337       }
53338
53339     } CALL_CATCH_EXCEPTION();
53340   }
53341
53342 }
53343
53344
53345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53346   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53347   int arg2 ;
53348   std::vector< Dali::Actor > *arg3 = 0 ;
53349
53350   arg1 = (std::vector< Dali::Actor > *)jarg1;
53351   arg2 = (int)jarg2;
53352   arg3 = (std::vector< Dali::Actor > *)jarg3;
53353   if (!arg3) {
53354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53355     return ;
53356   }
53357   {
53358     try {
53359       try {
53360         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53361       }
53362       catch(std::out_of_range &_e) {
53363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53364         return ;
53365       }
53366
53367     } CALL_CATCH_EXCEPTION();
53368   }
53369
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53374   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53375
53376   arg1 = (std::vector< Dali::Actor > *)jarg1;
53377   {
53378     try {
53379       delete arg1;
53380     } CALL_CATCH_EXCEPTION();
53381   }
53382
53383 }
53384
53385
53386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53387   unsigned int jresult ;
53388   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53389   bool result;
53390
53391   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53392   {
53393     try {
53394       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53395     } CALL_CATCH_EXCEPTION(0);
53396   }
53397
53398   jresult = result;
53399   return jresult;
53400 }
53401
53402
53403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53404   unsigned long jresult ;
53405   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53406   std::size_t result;
53407
53408   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53409   {
53410     try {
53411       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53412     } CALL_CATCH_EXCEPTION(0);
53413   }
53414
53415   jresult = (unsigned long)result;
53416   return jresult;
53417 }
53418
53419
53420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53421   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53422   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53423
53424   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53425   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53426   {
53427     try {
53428       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53429     } CALL_CATCH_EXCEPTION();
53430   }
53431
53432 }
53433
53434
53435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53436   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53437   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53438
53439   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53440   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53441   {
53442     try {
53443       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53444     } CALL_CATCH_EXCEPTION();
53445   }
53446
53447 }
53448
53449
53450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53451   unsigned int jresult ;
53452   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53453   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53454   bool result;
53455
53456   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53457   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53458   if (!arg2) {
53459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53460     return 0;
53461   }
53462   {
53463     try {
53464       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53465     } CALL_CATCH_EXCEPTION(0);
53466   }
53467
53468   jresult = result;
53469   return jresult;
53470 }
53471
53472
53473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53474   void * jresult ;
53475   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53476
53477   {
53478     try {
53479       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53480     } CALL_CATCH_EXCEPTION(0);
53481   }
53482
53483   jresult = (void *)result;
53484   return jresult;
53485 }
53486
53487
53488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53489   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53490
53491   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53492   {
53493     try {
53494       delete arg1;
53495     } CALL_CATCH_EXCEPTION();
53496   }
53497
53498 }
53499
53500
53501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53502   unsigned int jresult ;
53503   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53504   bool result;
53505
53506   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53507   {
53508     try {
53509       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);
53510     } CALL_CATCH_EXCEPTION(0);
53511   }
53512
53513   jresult = result;
53514   return jresult;
53515 }
53516
53517
53518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53519   unsigned long jresult ;
53520   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53521   std::size_t result;
53522
53523   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53524   {
53525     try {
53526       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);
53527     } CALL_CATCH_EXCEPTION(0);
53528   }
53529
53530   jresult = (unsigned long)result;
53531   return jresult;
53532 }
53533
53534
53535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53536   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53537   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53538
53539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53540   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53541   {
53542     try {
53543       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53544     } CALL_CATCH_EXCEPTION();
53545   }
53546
53547 }
53548
53549
53550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53551   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53552   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53553
53554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53555   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53556   {
53557     try {
53558       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53559     } CALL_CATCH_EXCEPTION();
53560   }
53561
53562 }
53563
53564
53565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53566   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53567   Dali::Actor arg2 ;
53568   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53569   Dali::Actor *argp2 ;
53570
53571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53572   argp2 = (Dali::Actor *)jarg2;
53573   if (!argp2) {
53574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53575     return ;
53576   }
53577   arg2 = *argp2;
53578   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53579   {
53580     try {
53581       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53582     } CALL_CATCH_EXCEPTION();
53583   }
53584
53585 }
53586
53587
53588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53589   void * jresult ;
53590   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53591
53592   {
53593     try {
53594       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53595     } CALL_CATCH_EXCEPTION(0);
53596   }
53597
53598   jresult = (void *)result;
53599   return jresult;
53600 }
53601
53602
53603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53604   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53605
53606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53607   {
53608     try {
53609       delete arg1;
53610     } CALL_CATCH_EXCEPTION();
53611   }
53612
53613 }
53614
53615
53616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53617   unsigned int jresult ;
53618   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53619   bool result;
53620
53621   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53622   {
53623     try {
53624       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53625     } CALL_CATCH_EXCEPTION(0);
53626   }
53627
53628   jresult = result;
53629   return jresult;
53630 }
53631
53632
53633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53634   unsigned long jresult ;
53635   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53636   std::size_t result;
53637
53638   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53639   {
53640     try {
53641       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53642     } CALL_CATCH_EXCEPTION(0);
53643   }
53644
53645   jresult = (unsigned long)result;
53646   return jresult;
53647 }
53648
53649
53650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53651   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53652   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53653
53654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53655   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53656   {
53657     try {
53658       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53659     } CALL_CATCH_EXCEPTION();
53660   }
53661
53662 }
53663
53664
53665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53666   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53667   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53668
53669   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53670   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53671   {
53672     try {
53673       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53674     } CALL_CATCH_EXCEPTION();
53675   }
53676
53677 }
53678
53679
53680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53681   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53682   Dali::Actor arg2 ;
53683   Dali::Actor arg3 ;
53684   Dali::Actor *argp2 ;
53685   Dali::Actor *argp3 ;
53686
53687   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53688   argp2 = (Dali::Actor *)jarg2;
53689   if (!argp2) {
53690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53691     return ;
53692   }
53693   arg2 = *argp2;
53694   argp3 = (Dali::Actor *)jarg3;
53695   if (!argp3) {
53696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53697     return ;
53698   }
53699   arg3 = *argp3;
53700   {
53701     try {
53702       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53703     } CALL_CATCH_EXCEPTION();
53704   }
53705
53706 }
53707
53708
53709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53710   void * jresult ;
53711   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53712
53713   {
53714     try {
53715       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53716     } CALL_CATCH_EXCEPTION(0);
53717   }
53718
53719   jresult = (void *)result;
53720   return jresult;
53721 }
53722
53723
53724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53725   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53726
53727   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53728   {
53729     try {
53730       delete arg1;
53731     } CALL_CATCH_EXCEPTION();
53732   }
53733
53734 }
53735
53736
53737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
53738   unsigned int jresult ;
53739   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53740   bool result;
53741
53742   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53743   {
53744     try {
53745       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53746     } CALL_CATCH_EXCEPTION(0);
53747   }
53748
53749   jresult = result;
53750   return jresult;
53751 }
53752
53753
53754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
53755   unsigned long jresult ;
53756   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53757   std::size_t result;
53758
53759   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53760   {
53761     try {
53762       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53763     } CALL_CATCH_EXCEPTION(0);
53764   }
53765
53766   jresult = (unsigned long)result;
53767   return jresult;
53768 }
53769
53770
53771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
53772   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53773   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53774
53775   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53776   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53777   {
53778     try {
53779       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
53780     } CALL_CATCH_EXCEPTION();
53781   }
53782
53783 }
53784
53785
53786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53787   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53788   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53789
53790   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53791   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53792   {
53793     try {
53794       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
53795     } CALL_CATCH_EXCEPTION();
53796   }
53797
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
53802   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53803   Dali::Actor arg2 ;
53804   bool arg3 ;
53805   Dali::Actor *argp2 ;
53806
53807   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53808   argp2 = (Dali::Actor *)jarg2;
53809   if (!argp2) {
53810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53811     return ;
53812   }
53813   arg2 = *argp2;
53814   arg3 = jarg3 ? true : false;
53815   {
53816     try {
53817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
53818     } CALL_CATCH_EXCEPTION();
53819   }
53820
53821 }
53822
53823
53824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
53825   void * jresult ;
53826   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
53827
53828   {
53829     try {
53830       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
53831     } CALL_CATCH_EXCEPTION(0);
53832   }
53833
53834   jresult = (void *)result;
53835   return jresult;
53836 }
53837
53838
53839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
53840   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53841
53842   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53843   {
53844     try {
53845       delete arg1;
53846     } CALL_CATCH_EXCEPTION();
53847   }
53848
53849 }
53850
53851
53852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
53853   unsigned int jresult ;
53854   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53855   bool result;
53856
53857   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53858   {
53859     try {
53860       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);
53861     } CALL_CATCH_EXCEPTION(0);
53862   }
53863
53864   jresult = result;
53865   return jresult;
53866 }
53867
53868
53869 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
53870   unsigned long jresult ;
53871   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53872   std::size_t result;
53873
53874   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53875   {
53876     try {
53877       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);
53878     } CALL_CATCH_EXCEPTION(0);
53879   }
53880
53881   jresult = (unsigned long)result;
53882   return jresult;
53883 }
53884
53885
53886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
53887   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53888   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
53889
53890   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53891   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
53892   {
53893     try {
53894       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
53895     } CALL_CATCH_EXCEPTION();
53896   }
53897
53898 }
53899
53900
53901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53902   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53903   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
53904
53905   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53906   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
53907   {
53908     try {
53909       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
53910     } CALL_CATCH_EXCEPTION();
53911   }
53912
53913 }
53914
53915
53916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53917   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53918   Dali::Toolkit::StyleManager arg2 ;
53919   Dali::StyleChange::Type arg3 ;
53920   Dali::Toolkit::StyleManager *argp2 ;
53921
53922   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53923   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
53924   if (!argp2) {
53925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
53926     return ;
53927   }
53928   arg2 = *argp2;
53929   arg3 = (Dali::StyleChange::Type)jarg3;
53930   {
53931     try {
53932       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
53933     } CALL_CATCH_EXCEPTION();
53934   }
53935
53936 }
53937
53938
53939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
53940   void * jresult ;
53941   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
53942
53943   {
53944     try {
53945       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
53946     } CALL_CATCH_EXCEPTION(0);
53947   }
53948
53949   jresult = (void *)result;
53950   return jresult;
53951 }
53952
53953
53954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
53955   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
53956
53957   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
53958   {
53959     try {
53960       delete arg1;
53961     } CALL_CATCH_EXCEPTION();
53962   }
53963
53964 }
53965
53966
53967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
53968   unsigned int jresult ;
53969   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
53970   bool result;
53971
53972   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
53973   {
53974     try {
53975       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
53976     } CALL_CATCH_EXCEPTION(0);
53977   }
53978
53979   jresult = result;
53980   return jresult;
53981 }
53982
53983
53984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
53985   unsigned long jresult ;
53986   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
53987   std::size_t result;
53988
53989   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
53990   {
53991     try {
53992       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
53993     } CALL_CATCH_EXCEPTION(0);
53994   }
53995
53996   jresult = (unsigned long)result;
53997   return jresult;
53998 }
53999
54000
54001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54002   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54003   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54004
54005   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54006   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54007   {
54008     try {
54009       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54010     } CALL_CATCH_EXCEPTION();
54011   }
54012
54013 }
54014
54015
54016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54017   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54018   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54019
54020   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54021   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54022   {
54023     try {
54024       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54025     } CALL_CATCH_EXCEPTION();
54026   }
54027
54028 }
54029
54030
54031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54032   unsigned int jresult ;
54033   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54034   Dali::Toolkit::Button arg2 ;
54035   Dali::Toolkit::Button *argp2 ;
54036   bool result;
54037
54038   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54039   argp2 = (Dali::Toolkit::Button *)jarg2;
54040   if (!argp2) {
54041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54042     return 0;
54043   }
54044   arg2 = *argp2;
54045   {
54046     try {
54047       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54048     } CALL_CATCH_EXCEPTION(0);
54049   }
54050
54051   jresult = result;
54052   return jresult;
54053 }
54054
54055
54056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54057   void * jresult ;
54058   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54059
54060   {
54061     try {
54062       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54063     } CALL_CATCH_EXCEPTION(0);
54064   }
54065
54066   jresult = (void *)result;
54067   return jresult;
54068 }
54069
54070
54071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54072   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54073
54074   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54075   {
54076     try {
54077       delete arg1;
54078     } CALL_CATCH_EXCEPTION();
54079   }
54080
54081 }
54082
54083
54084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54085   unsigned int jresult ;
54086   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54087   bool result;
54088
54089   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54090   {
54091     try {
54092       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54093     } CALL_CATCH_EXCEPTION(0);
54094   }
54095
54096   jresult = result;
54097   return jresult;
54098 }
54099
54100
54101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54102   unsigned long jresult ;
54103   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54104   std::size_t result;
54105
54106   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54107   {
54108     try {
54109       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54110     } CALL_CATCH_EXCEPTION(0);
54111   }
54112
54113   jresult = (unsigned long)result;
54114   return jresult;
54115 }
54116
54117
54118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54119   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54120   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54121
54122   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54123   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54124   {
54125     try {
54126       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54127     } CALL_CATCH_EXCEPTION();
54128   }
54129
54130 }
54131
54132
54133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54134   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54135   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54136
54137   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54138   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54139   {
54140     try {
54141       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54142     } CALL_CATCH_EXCEPTION();
54143   }
54144
54145 }
54146
54147
54148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54149   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54150   Dali::Toolkit::GaussianBlurView arg2 ;
54151   Dali::Toolkit::GaussianBlurView *argp2 ;
54152
54153   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54154   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54155   if (!argp2) {
54156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54157     return ;
54158   }
54159   arg2 = *argp2;
54160   {
54161     try {
54162       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54163     } CALL_CATCH_EXCEPTION();
54164   }
54165
54166 }
54167
54168
54169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54170   void * jresult ;
54171   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54172
54173   {
54174     try {
54175       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54176     } CALL_CATCH_EXCEPTION(0);
54177   }
54178
54179   jresult = (void *)result;
54180   return jresult;
54181 }
54182
54183
54184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54185   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54186
54187   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54188   {
54189     try {
54190       delete arg1;
54191     } CALL_CATCH_EXCEPTION();
54192   }
54193
54194 }
54195
54196
54197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54198   unsigned int jresult ;
54199   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54200   bool result;
54201
54202   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54203   {
54204     try {
54205       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);
54206     } CALL_CATCH_EXCEPTION(0);
54207   }
54208
54209   jresult = result;
54210   return jresult;
54211 }
54212
54213
54214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54215   unsigned long jresult ;
54216   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54217   std::size_t result;
54218
54219   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54220   {
54221     try {
54222       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);
54223     } CALL_CATCH_EXCEPTION(0);
54224   }
54225
54226   jresult = (unsigned long)result;
54227   return jresult;
54228 }
54229
54230
54231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54232   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54233   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54234
54235   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54236   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54237   {
54238     try {
54239       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54240     } CALL_CATCH_EXCEPTION();
54241   }
54242
54243 }
54244
54245
54246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54247   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54248   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54249
54250   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54251   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54252   {
54253     try {
54254       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54255     } CALL_CATCH_EXCEPTION();
54256   }
54257
54258 }
54259
54260
54261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54262   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54263   Dali::Toolkit::PageTurnView arg2 ;
54264   unsigned int arg3 ;
54265   bool arg4 ;
54266   Dali::Toolkit::PageTurnView *argp2 ;
54267
54268   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54269   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54270   if (!argp2) {
54271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54272     return ;
54273   }
54274   arg2 = *argp2;
54275   arg3 = (unsigned int)jarg3;
54276   arg4 = jarg4 ? true : false;
54277   {
54278     try {
54279       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54280     } CALL_CATCH_EXCEPTION();
54281   }
54282
54283 }
54284
54285
54286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54287   void * jresult ;
54288   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54289
54290   {
54291     try {
54292       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54293     } CALL_CATCH_EXCEPTION(0);
54294   }
54295
54296   jresult = (void *)result;
54297   return jresult;
54298 }
54299
54300
54301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54302   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54305   {
54306     try {
54307       delete arg1;
54308     } CALL_CATCH_EXCEPTION();
54309   }
54310
54311 }
54312
54313
54314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54315   unsigned int jresult ;
54316   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54317   bool result;
54318
54319   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54320   {
54321     try {
54322       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54323     } CALL_CATCH_EXCEPTION(0);
54324   }
54325
54326   jresult = result;
54327   return jresult;
54328 }
54329
54330
54331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54332   unsigned long jresult ;
54333   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54334   std::size_t result;
54335
54336   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54337   {
54338     try {
54339       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54340     } CALL_CATCH_EXCEPTION(0);
54341   }
54342
54343   jresult = (unsigned long)result;
54344   return jresult;
54345 }
54346
54347
54348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54349   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54350   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54351
54352   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54353   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54354   {
54355     try {
54356       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54357     } CALL_CATCH_EXCEPTION();
54358   }
54359 }
54360
54361
54362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54363   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54364   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54365
54366   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54367   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54368   {
54369     try {
54370       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54371     } CALL_CATCH_EXCEPTION();
54372   }
54373 }
54374
54375
54376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54377   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54378   Dali::Toolkit::PageTurnView arg2 ;
54379   Dali::Toolkit::PageTurnView *argp2 ;
54380
54381   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54382   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54383   if (!argp2) {
54384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54385     return ;
54386   }
54387   arg2 = *argp2;
54388   {
54389     try {
54390       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54391     } CALL_CATCH_EXCEPTION();
54392   }
54393 }
54394
54395
54396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54397   void * jresult ;
54398   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54399
54400   {
54401     try {
54402       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54403     } CALL_CATCH_EXCEPTION(0);
54404   }
54405
54406   jresult = (void *)result;
54407   return jresult;
54408 }
54409
54410
54411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54412   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54413
54414   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54415   {
54416     try {
54417       delete arg1;
54418     } CALL_CATCH_EXCEPTION();
54419   }
54420
54421 }
54422
54423
54424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54425   unsigned int jresult ;
54426   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54427   bool result;
54428
54429   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54430   {
54431     try {
54432       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);
54433     } CALL_CATCH_EXCEPTION(0);
54434   }
54435
54436   jresult = result;
54437   return jresult;
54438 }
54439
54440
54441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54442   unsigned long jresult ;
54443   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54444   std::size_t result;
54445
54446   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54447   {
54448     try {
54449       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);
54450     } CALL_CATCH_EXCEPTION(0);
54451   }
54452
54453   jresult = (unsigned long)result;
54454   return jresult;
54455 }
54456
54457
54458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54459   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54460   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54461
54462   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54463   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54464   {
54465     try {
54466       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54467     } CALL_CATCH_EXCEPTION();
54468   }
54469
54470 }
54471
54472
54473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54474   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54475   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54476
54477   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54478   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54479   {
54480     try {
54481       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54482     } CALL_CATCH_EXCEPTION();
54483   }
54484
54485 }
54486
54487
54488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54489   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54490   Dali::Toolkit::ProgressBar arg2 ;
54491   float arg3 ;
54492   float arg4 ;
54493   Dali::Toolkit::ProgressBar *argp2 ;
54494
54495   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54496   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54497   if (!argp2) {
54498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54499     return ;
54500   }
54501   arg2 = *argp2;
54502   arg3 = (float)jarg3;
54503   arg4 = (float)jarg4;
54504   {
54505     try {
54506       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54507     } CALL_CATCH_EXCEPTION();
54508   }
54509
54510 }
54511
54512
54513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54514   void * jresult ;
54515   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54516
54517   {
54518     try {
54519       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54520     } CALL_CATCH_EXCEPTION(0);
54521   }
54522
54523   jresult = (void *)result;
54524   return jresult;
54525 }
54526
54527
54528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54529   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54530
54531   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54532   {
54533     try {
54534       delete arg1;
54535     } CALL_CATCH_EXCEPTION();
54536   }
54537
54538 }
54539
54540
54541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54542   unsigned int jresult ;
54543   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54544   bool result;
54545
54546   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54547   {
54548     try {
54549       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);
54550     } CALL_CATCH_EXCEPTION(0);
54551   }
54552
54553   jresult = result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54559   unsigned long jresult ;
54560   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54561   std::size_t result;
54562
54563   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54564   {
54565     try {
54566       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);
54567     } CALL_CATCH_EXCEPTION(0);
54568   }
54569
54570   jresult = (unsigned long)result;
54571   return jresult;
54572 }
54573
54574
54575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54576   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54577   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54578
54579   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54580   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54581   {
54582     try {
54583       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54584     } CALL_CATCH_EXCEPTION();
54585   }
54586
54587 }
54588
54589
54590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54591   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54592   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54593
54594   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54595   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54596   {
54597     try {
54598       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54599     } CALL_CATCH_EXCEPTION();
54600   }
54601
54602 }
54603
54604
54605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54606   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54607   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54608
54609   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54610   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54611   if (!arg2) {
54612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54613     return ;
54614   }
54615   {
54616     try {
54617       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54618     } CALL_CATCH_EXCEPTION();
54619   }
54620
54621 }
54622
54623
54624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54625   void * jresult ;
54626   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54627
54628   {
54629     try {
54630       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54631     } CALL_CATCH_EXCEPTION(0);
54632   }
54633
54634   jresult = (void *)result;
54635   return jresult;
54636 }
54637
54638
54639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54640   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54641
54642   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54643   {
54644     try {
54645       delete arg1;
54646     } CALL_CATCH_EXCEPTION();
54647   }
54648
54649 }
54650
54651
54652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54653   unsigned int jresult ;
54654   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54655   bool result;
54656
54657   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54658   {
54659     try {
54660       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54661     } CALL_CATCH_EXCEPTION(0);
54662   }
54663
54664   jresult = result;
54665   return jresult;
54666 }
54667
54668
54669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54670   unsigned long jresult ;
54671   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54672   std::size_t result;
54673
54674   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54675   {
54676     try {
54677       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54678     } CALL_CATCH_EXCEPTION(0);
54679   }
54680
54681   jresult = (unsigned long)result;
54682   return jresult;
54683 }
54684
54685
54686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54687   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54688   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54689
54690   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54691   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54692   {
54693     try {
54694       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54695     } CALL_CATCH_EXCEPTION();
54696   }
54697
54698 }
54699
54700
54701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54702   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54703   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54704
54705   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54706   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54707   {
54708     try {
54709       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54710     } CALL_CATCH_EXCEPTION();
54711   }
54712
54713 }
54714
54715
54716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54717   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54718   Dali::Vector2 *arg2 = 0 ;
54719
54720   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54721   arg2 = (Dali::Vector2 *)jarg2;
54722   if (!arg2) {
54723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54724     return ;
54725   }
54726   {
54727     try {
54728       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
54729     } CALL_CATCH_EXCEPTION();
54730   }
54731
54732 }
54733
54734
54735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
54736   void * jresult ;
54737   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
54738
54739   {
54740     try {
54741       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
54742     } CALL_CATCH_EXCEPTION(0);
54743   }
54744
54745   jresult = (void *)result;
54746   return jresult;
54747 }
54748
54749
54750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
54751   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54752
54753   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54754   {
54755     try {
54756       delete arg1;
54757     } CALL_CATCH_EXCEPTION();
54758   }
54759
54760 }
54761
54762
54763
54764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
54765   unsigned int jresult ;
54766   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54767   bool result;
54768
54769   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54770   {
54771     try {
54772       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);
54773     } CALL_CATCH_EXCEPTION(0);
54774   }
54775
54776   jresult = result;
54777   return jresult;
54778 }
54779
54780
54781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
54782   unsigned long jresult ;
54783   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54784   std::size_t result;
54785
54786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54787   {
54788     try {
54789       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);
54790     } CALL_CATCH_EXCEPTION(0);
54791   }
54792
54793   jresult = (unsigned long)result;
54794   return jresult;
54795 }
54796
54797
54798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
54799   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54800   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
54801
54802   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54803   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
54804   {
54805     try {
54806       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54807     } CALL_CATCH_EXCEPTION();
54808   }
54809
54810 }
54811
54812
54813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
54814   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54815   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
54816
54817   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54818   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
54819   {
54820     try {
54821       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54822     } CALL_CATCH_EXCEPTION();
54823   }
54824
54825 }
54826
54827
54828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54829   unsigned int jresult ;
54830   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54831   Dali::Toolkit::Control arg2 ;
54832   Dali::KeyEvent *arg3 = 0 ;
54833   Dali::Toolkit::Control *argp2 ;
54834   bool result;
54835
54836   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54837   argp2 = (Dali::Toolkit::Control *)jarg2;
54838   if (!argp2) {
54839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
54840     return 0;
54841   }
54842   arg2 = *argp2;
54843   arg3 = (Dali::KeyEvent *)jarg3;
54844   if (!arg3) {
54845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
54846     return 0;
54847   }
54848   {
54849     try {
54850       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);
54851     } CALL_CATCH_EXCEPTION(0);
54852   }
54853
54854   jresult = result;
54855   return jresult;
54856 }
54857
54858
54859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
54860   void * jresult ;
54861   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
54862
54863   {
54864     try {
54865       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
54866     } CALL_CATCH_EXCEPTION(0);
54867   }
54868
54869   jresult = (void *)result;
54870   return jresult;
54871 }
54872
54873
54874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
54875   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54876
54877   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54878   {
54879     try {
54880       delete arg1;
54881     } CALL_CATCH_EXCEPTION();
54882   }
54883
54884 }
54885
54886
54887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
54888   unsigned int jresult ;
54889   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54890   bool result;
54891
54892   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54893   {
54894     try {
54895       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
54896     } CALL_CATCH_EXCEPTION(0);
54897   }
54898
54899   jresult = result;
54900   return jresult;
54901 }
54902
54903
54904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
54905   unsigned long jresult ;
54906   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54907   std::size_t result;
54908
54909   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54910   {
54911     try {
54912       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
54913     } CALL_CATCH_EXCEPTION(0);
54914   }
54915
54916   jresult = (unsigned long)result;
54917   return jresult;
54918 }
54919
54920
54921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
54922   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54923   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
54924
54925   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54926   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
54927   {
54928     try {
54929       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
54930     } CALL_CATCH_EXCEPTION();
54931   }
54932
54933 }
54934
54935
54936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
54937   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54938   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
54939
54940   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54941   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
54942   {
54943     try {
54944       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
54945     } CALL_CATCH_EXCEPTION();
54946   }
54947
54948 }
54949
54950
54951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
54952   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54953   Dali::Toolkit::Control arg2 ;
54954   Dali::Toolkit::Control *argp2 ;
54955
54956   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54957   argp2 = (Dali::Toolkit::Control *)jarg2;
54958   if (!argp2) {
54959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
54960     return ;
54961   }
54962   arg2 = *argp2;
54963   {
54964     try {
54965       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
54966     } CALL_CATCH_EXCEPTION();
54967   }
54968
54969 }
54970
54971
54972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
54973   void * jresult ;
54974   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
54975
54976   {
54977     try {
54978       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
54979     } CALL_CATCH_EXCEPTION(0);
54980   }
54981
54982   jresult = (void *)result;
54983   return jresult;
54984 }
54985
54986
54987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
54988   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
54989
54990   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
54991   {
54992     try {
54993       delete arg1;
54994     } CALL_CATCH_EXCEPTION();
54995   }
54996
54997 }
54998
54999
55000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55001   unsigned int jresult ;
55002   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55003   bool result;
55004
55005   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55006   {
55007     try {
55008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55009     } CALL_CATCH_EXCEPTION(0);
55010   }
55011
55012   jresult = result;
55013   return jresult;
55014 }
55015
55016
55017 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55018   unsigned long jresult ;
55019   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55020   std::size_t result;
55021
55022   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55023   {
55024     try {
55025       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55026     } CALL_CATCH_EXCEPTION(0);
55027   }
55028
55029   jresult = (unsigned long)result;
55030   return jresult;
55031 }
55032
55033
55034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55035   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55036   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55037
55038   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55039   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55040   {
55041     try {
55042       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55043     } CALL_CATCH_EXCEPTION();
55044   }
55045
55046 }
55047
55048
55049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55050   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55051   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55052
55053   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55054   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55055   {
55056     try {
55057       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55058     } CALL_CATCH_EXCEPTION();
55059   }
55060
55061 }
55062
55063
55064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55065   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55066   Dali::Toolkit::VideoView *arg2 = 0 ;
55067
55068   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55069   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55070   if (!arg2) {
55071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55072     return ;
55073   }
55074   {
55075     try {
55076       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55077     } CALL_CATCH_EXCEPTION();
55078   }
55079
55080 }
55081
55082
55083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55084   void * jresult ;
55085   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55086
55087   {
55088     try {
55089       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55090     } CALL_CATCH_EXCEPTION(0);
55091   }
55092
55093   jresult = (void *)result;
55094   return jresult;
55095 }
55096
55097
55098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55099   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55100
55101   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55102   {
55103     try {
55104       delete arg1;
55105     } CALL_CATCH_EXCEPTION();
55106   }
55107
55108 }
55109
55110
55111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55112   unsigned int jresult ;
55113   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55114   bool result;
55115
55116   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55117   {
55118     try {
55119       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55120     } CALL_CATCH_EXCEPTION(0);
55121   }
55122
55123   jresult = result;
55124   return jresult;
55125 }
55126
55127
55128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55129   unsigned long jresult ;
55130   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55131   std::size_t result;
55132
55133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55134   {
55135     try {
55136       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55137     } CALL_CATCH_EXCEPTION(0);
55138   }
55139
55140   jresult = (unsigned long)result;
55141   return jresult;
55142 }
55143
55144
55145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55146   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55147   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55148
55149   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55150   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55151   {
55152     try {
55153       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55154     } CALL_CATCH_EXCEPTION();
55155   }
55156
55157 }
55158
55159
55160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55161   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55162   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55163
55164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55165   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55166   {
55167     try {
55168       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55169     } CALL_CATCH_EXCEPTION();
55170   }
55171
55172 }
55173
55174
55175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55176   unsigned int jresult ;
55177   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55178   Dali::Toolkit::Slider arg2 ;
55179   float arg3 ;
55180   Dali::Toolkit::Slider *argp2 ;
55181   bool result;
55182
55183   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55184   argp2 = (Dali::Toolkit::Slider *)jarg2;
55185   if (!argp2) {
55186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55187     return 0;
55188   }
55189   arg2 = *argp2;
55190   arg3 = (float)jarg3;
55191   {
55192     try {
55193       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55194     } CALL_CATCH_EXCEPTION(0);
55195   }
55196
55197   jresult = result;
55198   return jresult;
55199 }
55200
55201
55202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55203   void * jresult ;
55204   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55205
55206   {
55207     try {
55208       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55209     } CALL_CATCH_EXCEPTION(0);
55210   }
55211
55212   jresult = (void *)result;
55213   return jresult;
55214 }
55215
55216
55217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55218   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55219
55220   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55221   {
55222     try {
55223       delete arg1;
55224     } CALL_CATCH_EXCEPTION();
55225   }
55226
55227 }
55228
55229
55230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55231   unsigned int jresult ;
55232   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55233   bool result;
55234
55235   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55236   {
55237     try {
55238       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55239     } CALL_CATCH_EXCEPTION(0);
55240   }
55241
55242   jresult = result;
55243   return jresult;
55244 }
55245
55246
55247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55248   unsigned long jresult ;
55249   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55250   std::size_t result;
55251
55252   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55253   {
55254     try {
55255       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55256     } CALL_CATCH_EXCEPTION(0);
55257   }
55258
55259   jresult = (unsigned long)result;
55260   return jresult;
55261 }
55262
55263
55264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55265   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55266   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55267
55268   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55269   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55270   {
55271     try {
55272       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55273     } CALL_CATCH_EXCEPTION();
55274   }
55275
55276 }
55277
55278
55279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55280   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55281   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55282
55283   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55284   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55285   {
55286     try {
55287       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55288     } CALL_CATCH_EXCEPTION();
55289   }
55290
55291 }
55292
55293
55294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55295   unsigned int jresult ;
55296   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55297   Dali::Toolkit::Slider arg2 ;
55298   int arg3 ;
55299   Dali::Toolkit::Slider *argp2 ;
55300   bool result;
55301
55302   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55303   argp2 = (Dali::Toolkit::Slider *)jarg2;
55304   if (!argp2) {
55305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55306     return 0;
55307   }
55308   arg2 = *argp2;
55309   arg3 = (int)jarg3;
55310   {
55311     try {
55312       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55313     } CALL_CATCH_EXCEPTION(0);
55314   }
55315
55316   jresult = result;
55317   return jresult;
55318 }
55319
55320
55321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55322   void * jresult ;
55323   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55324
55325   {
55326     try {
55327       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55328     } CALL_CATCH_EXCEPTION(0);
55329   }
55330
55331   jresult = (void *)result;
55332   return jresult;
55333 }
55334
55335
55336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55337   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55338
55339   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55340   {
55341     try {
55342       delete arg1;
55343     } CALL_CATCH_EXCEPTION();
55344   }
55345
55346 }
55347
55348
55349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55350   void * jresult ;
55351   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55352
55353   {
55354     try {
55355       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55356     } CALL_CATCH_EXCEPTION(0);
55357   }
55358
55359   jresult = (void *)result;
55360   return jresult;
55361 }
55362
55363
55364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55365   void * jresult ;
55366   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55367   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55368
55369   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55370   {
55371     try {
55372       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
55373     } CALL_CATCH_EXCEPTION(0);
55374   }
55375
55376   jresult = (void *)result;
55377   return jresult;
55378 }
55379
55380
55381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
55382   void * jresult ;
55383   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55384   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55385
55386   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55387   if (!arg1) {
55388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55389     return 0;
55390   }
55391   {
55392     try {
55393       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55394     } CALL_CATCH_EXCEPTION(0);
55395   }
55396
55397   jresult = (void *)result;
55398   return jresult;
55399 }
55400
55401
55402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55404
55405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55406   {
55407     try {
55408       delete arg1;
55409     } CALL_CATCH_EXCEPTION();
55410   }
55411
55412 }
55413
55414
55415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55416   void * jresult ;
55417   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55418   Dali::Toolkit::Ruler *result = 0 ;
55419
55420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55421   {
55422     try {
55423       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55424     } CALL_CATCH_EXCEPTION(0);
55425   }
55426
55427   jresult = (void *)result;
55428   return jresult;
55429 }
55430
55431
55432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
55433   void * jresult ;
55434   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55435   Dali::Toolkit::Ruler *result = 0 ;
55436
55437   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55438   {
55439     try {
55440       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
55441     } CALL_CATCH_EXCEPTION(0);
55442   }
55443
55444   jresult = (void *)result;
55445   return jresult;
55446 }
55447
55448
55449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
55450   void * jresult ;
55451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55452   Dali::Toolkit::Ruler *result = 0 ;
55453
55454   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55455   {
55456     try {
55457       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
55458     } CALL_CATCH_EXCEPTION(0);
55459   }
55460
55461   jresult = (void *)result;
55462   return jresult;
55463 }
55464
55465
55466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
55467   void * jresult ;
55468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55469   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55470   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55471
55472   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55473   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55474   if (!arg2) {
55475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55476     return 0;
55477   }
55478   {
55479     try {
55480       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55481     } CALL_CATCH_EXCEPTION(0);
55482   }
55483
55484   jresult = (void *)result;
55485   return jresult;
55486 }
55487
55488
55489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55490   void * jresult ;
55491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55492   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55493   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55494
55495   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55496   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55497   {
55498     try {
55499       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55500     } CALL_CATCH_EXCEPTION(0);
55501   }
55502
55503   jresult = (void *)result;
55504   return jresult;
55505 }
55506
55507
55508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55509   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55510
55511   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55512   {
55513     try {
55514       (arg1)->Reset();
55515     } CALL_CATCH_EXCEPTION();
55516   }
55517
55518 }
55519
55520
55521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55522   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55523   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55524
55525   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55526   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55527   {
55528     try {
55529       (arg1)->Reset(arg2);
55530     } CALL_CATCH_EXCEPTION();
55531   }
55532
55533 }
55534
55535
55536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55537   void * jresult ;
55538   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55539   Dali::Toolkit::Ruler *result = 0 ;
55540
55541   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55542   {
55543     try {
55544       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55545     } CALL_CATCH_EXCEPTION(0);
55546   }
55547
55548   jresult = (void *)result;
55549   return jresult;
55550 }
55551
55552
55553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55554   float jresult ;
55555   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55556   float arg2 ;
55557   float arg3 ;
55558   float result;
55559
55560   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55561   arg2 = (float)jarg2;
55562   arg3 = (float)jarg3;
55563   {
55564     try {
55565       result = (float)(*arg1)->Snap(arg2,arg3);
55566     } CALL_CATCH_EXCEPTION(0);
55567   }
55568
55569   jresult = result;
55570   return jresult;
55571 }
55572
55573
55574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55575   float jresult ;
55576   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55577   float arg2 ;
55578   float result;
55579
55580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55581   arg2 = (float)jarg2;
55582   {
55583     try {
55584       result = (float)(*arg1)->Snap(arg2);
55585     } CALL_CATCH_EXCEPTION(0);
55586   }
55587
55588   jresult = result;
55589   return jresult;
55590 }
55591
55592
55593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55594   float jresult ;
55595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55596   unsigned int arg2 ;
55597   unsigned int *arg3 = 0 ;
55598   bool arg4 ;
55599   float result;
55600
55601   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55602   arg2 = (unsigned int)jarg2;
55603   arg3 = (unsigned int *)jarg3;
55604   arg4 = jarg4 ? true : false;
55605   {
55606     try {
55607       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55608     } CALL_CATCH_EXCEPTION(0);
55609   }
55610
55611   jresult = result;
55612   return jresult;
55613 }
55614
55615
55616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55617   unsigned int jresult ;
55618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55619   float arg2 ;
55620   bool arg3 ;
55621   unsigned int result;
55622
55623   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55624   arg2 = (float)jarg2;
55625   arg3 = jarg3 ? true : false;
55626   {
55627     try {
55628       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55629     } CALL_CATCH_EXCEPTION(0);
55630   }
55631
55632   jresult = result;
55633   return jresult;
55634 }
55635
55636
55637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55638   unsigned int jresult ;
55639   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55640   unsigned int result;
55641
55642   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55643   {
55644     try {
55645       result = (unsigned int)(*arg1)->GetTotalPages();
55646     } CALL_CATCH_EXCEPTION(0);
55647   }
55648
55649   jresult = result;
55650   return jresult;
55651 }
55652
55653
55654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55655   int jresult ;
55656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55657   Dali::Toolkit::Ruler::RulerType result;
55658
55659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55660   {
55661     try {
55662       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55663     } CALL_CATCH_EXCEPTION(0);
55664   }
55665
55666   jresult = (int)result;
55667   return jresult;
55668 }
55669
55670
55671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55672   unsigned int jresult ;
55673   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55674   bool result;
55675
55676   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55677   {
55678     try {
55679       result = (bool)(*arg1)->IsEnabled();
55680     } CALL_CATCH_EXCEPTION(0);
55681   }
55682
55683   jresult = result;
55684   return jresult;
55685 }
55686
55687
55688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55689   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55690
55691   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55692   {
55693     try {
55694       (*arg1)->Enable();
55695     } CALL_CATCH_EXCEPTION();
55696   }
55697
55698 }
55699
55700
55701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55703
55704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55705   {
55706     try {
55707       (*arg1)->Disable();
55708     } CALL_CATCH_EXCEPTION();
55709   }
55710
55711 }
55712
55713
55714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55715   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55716   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55717   Dali::Toolkit::RulerDomain *argp2 ;
55718
55719   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55720   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55721   if (!argp2) {
55722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55723     return ;
55724   }
55725   arg2 = *argp2;
55726   {
55727     try {
55728       (*arg1)->SetDomain(arg2);
55729     } CALL_CATCH_EXCEPTION();
55730   }
55731
55732 }
55733
55734
55735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
55736   void * jresult ;
55737   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55738   Dali::Toolkit::RulerDomain *result = 0 ;
55739
55740   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55741   {
55742     try {
55743       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
55744     } CALL_CATCH_EXCEPTION(0);
55745   }
55746
55747   jresult = (void *)result;
55748   return jresult;
55749 }
55750
55751
55752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
55753   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55754
55755   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55756   {
55757     try {
55758       (*arg1)->DisableDomain();
55759     } CALL_CATCH_EXCEPTION();
55760   }
55761
55762 }
55763
55764
55765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
55766   float jresult ;
55767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55768   float arg2 ;
55769   float arg3 ;
55770   float arg4 ;
55771   float result;
55772
55773   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55774   arg2 = (float)jarg2;
55775   arg3 = (float)jarg3;
55776   arg4 = (float)jarg4;
55777   {
55778     try {
55779       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
55780     } CALL_CATCH_EXCEPTION(0);
55781   }
55782
55783   jresult = result;
55784   return jresult;
55785 }
55786
55787
55788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
55789   float jresult ;
55790   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55791   float arg2 ;
55792   float arg3 ;
55793   float result;
55794
55795   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55796   arg2 = (float)jarg2;
55797   arg3 = (float)jarg3;
55798   {
55799     try {
55800       result = (float)(*arg1)->Clamp(arg2,arg3);
55801     } CALL_CATCH_EXCEPTION(0);
55802   }
55803
55804   jresult = result;
55805   return jresult;
55806 }
55807
55808
55809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
55810   float jresult ;
55811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55812   float arg2 ;
55813   float result;
55814
55815   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55816   arg2 = (float)jarg2;
55817   {
55818     try {
55819       result = (float)(*arg1)->Clamp(arg2);
55820     } CALL_CATCH_EXCEPTION(0);
55821   }
55822
55823   jresult = result;
55824   return jresult;
55825 }
55826
55827
55828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
55829   float jresult ;
55830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55831   float arg2 ;
55832   float arg3 ;
55833   float arg4 ;
55834   Dali::Toolkit::ClampState *arg5 = 0 ;
55835   float result;
55836
55837   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55838   arg2 = (float)jarg2;
55839   arg3 = (float)jarg3;
55840   arg4 = (float)jarg4;
55841   arg5 = (Dali::Toolkit::ClampState *)jarg5;
55842   if (!arg5) {
55843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
55844     return 0;
55845   }
55846   {
55847     try {
55848       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
55849     } CALL_CATCH_EXCEPTION(0);
55850   }
55851
55852   jresult = result;
55853   return jresult;
55854 }
55855
55856
55857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
55858   float jresult ;
55859   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55860   float arg2 ;
55861   float arg3 ;
55862   float arg4 ;
55863   float arg5 ;
55864   float result;
55865
55866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55867   arg2 = (float)jarg2;
55868   arg3 = (float)jarg3;
55869   arg4 = (float)jarg4;
55870   arg5 = (float)jarg5;
55871   {
55872     try {
55873       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
55874     } CALL_CATCH_EXCEPTION(0);
55875   }
55876
55877   jresult = result;
55878   return jresult;
55879 }
55880
55881
55882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
55883   float jresult ;
55884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55885   float arg2 ;
55886   float arg3 ;
55887   float arg4 ;
55888   float result;
55889
55890   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55891   arg2 = (float)jarg2;
55892   arg3 = (float)jarg3;
55893   arg4 = (float)jarg4;
55894   {
55895     try {
55896       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
55897     } CALL_CATCH_EXCEPTION(0);
55898   }
55899
55900   jresult = result;
55901   return jresult;
55902 }
55903
55904
55905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
55906   float jresult ;
55907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55908   float arg2 ;
55909   float arg3 ;
55910   float result;
55911
55912   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55913   arg2 = (float)jarg2;
55914   arg3 = (float)jarg3;
55915   {
55916     try {
55917       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
55918     } CALL_CATCH_EXCEPTION(0);
55919   }
55920
55921   jresult = result;
55922   return jresult;
55923 }
55924
55925
55926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
55927   float jresult ;
55928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55929   float arg2 ;
55930   float result;
55931
55932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55933   arg2 = (float)jarg2;
55934   {
55935     try {
55936       result = (float)(*arg1)->SnapAndClamp(arg2);
55937     } CALL_CATCH_EXCEPTION(0);
55938   }
55939
55940   jresult = result;
55941   return jresult;
55942 }
55943
55944
55945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
55946   float jresult ;
55947   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55948   float arg2 ;
55949   float arg3 ;
55950   float arg4 ;
55951   float arg5 ;
55952   Dali::Toolkit::ClampState *arg6 = 0 ;
55953   float result;
55954
55955   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55956   arg2 = (float)jarg2;
55957   arg3 = (float)jarg3;
55958   arg4 = (float)jarg4;
55959   arg5 = (float)jarg5;
55960   arg6 = (Dali::Toolkit::ClampState *)jarg6;
55961   if (!arg6) {
55962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
55963     return 0;
55964   }
55965   {
55966     try {
55967       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
55968     } CALL_CATCH_EXCEPTION(0);
55969   }
55970
55971   jresult = result;
55972   return jresult;
55973 }
55974
55975
55976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
55977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55978
55979   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55980   {
55981     try {
55982       (*arg1)->Reference();
55983     } CALL_CATCH_EXCEPTION();
55984   }
55985
55986 }
55987
55988
55989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
55990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55991
55992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55993   {
55994     try {
55995       (*arg1)->Unreference();
55996     } CALL_CATCH_EXCEPTION();
55997   }
55998
55999 }
56000
56001
56002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56003   int jresult ;
56004   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56005   int result;
56006
56007   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56008   {
56009     try {
56010       result = (int)(*arg1)->ReferenceCount();
56011     } CALL_CATCH_EXCEPTION(0);
56012   }
56013
56014   jresult = result;
56015   return jresult;
56016 }
56017
56018
56019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56020   unsigned int jresult ;
56021   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56022   bool result;
56023
56024   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56025   {
56026     try {
56027       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56028     } CALL_CATCH_EXCEPTION(0);
56029   }
56030
56031   jresult = result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56037   unsigned long jresult ;
56038   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56039   std::size_t result;
56040
56041   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56042   {
56043     try {
56044       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56045     } CALL_CATCH_EXCEPTION(0);
56046   }
56047
56048   jresult = (unsigned long)result;
56049   return jresult;
56050 }
56051
56052
56053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56054   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56055   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56056
56057   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56058   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56059   {
56060     try {
56061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56062     } CALL_CATCH_EXCEPTION();
56063   }
56064
56065 }
56066
56067
56068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56069   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56070   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56071
56072   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56073   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56074   {
56075     try {
56076       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56077     } CALL_CATCH_EXCEPTION();
56078   }
56079
56080 }
56081
56082
56083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56084   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56085   Dali::Toolkit::Control arg2 ;
56086   Dali::Toolkit::Control *argp2 ;
56087
56088   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56089   argp2 = (Dali::Toolkit::Control *)jarg2;
56090   if (!argp2) {
56091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56092     return ;
56093   }
56094   arg2 = *argp2;
56095   {
56096     try {
56097       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56098     } CALL_CATCH_EXCEPTION();
56099   }
56100
56101 }
56102
56103
56104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56105   void * jresult ;
56106   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56107
56108   {
56109     try {
56110       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56111     } CALL_CATCH_EXCEPTION(0);
56112   }
56113
56114   jresult = (void *)result;
56115   return jresult;
56116 }
56117
56118
56119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56120   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56121
56122   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56123   {
56124     try {
56125       delete arg1;
56126     } CALL_CATCH_EXCEPTION();
56127   }
56128
56129 }
56130
56131 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56132   Dali::RefObject *result = NULL;
56133
56134   if (arg1)
56135   {
56136     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56137   }
56138   return result;
56139 }
56140
56141 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56142     return (Dali::RefObject *)jarg1;
56143 }
56144
56145 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56146     return (Dali::SignalObserver *)jarg1;
56147 }
56148
56149 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56150     return (Dali::ConnectionTrackerInterface *)jarg1;
56151 }
56152
56153 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56154     return (Dali::BaseHandle *)jarg1;
56155 }
56156
56157 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56158     return (Dali::BaseHandle *)jarg1;
56159 }
56160
56161 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56162     return (Dali::BaseHandle *)jarg1;
56163 }
56164
56165 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56166     return (Dali::BaseHandle *)jarg1;
56167 }
56168
56169 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56170     return (Dali::BaseHandle *)jarg1;
56171 }
56172
56173 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56174     return (Dali::BaseHandle *)jarg1;
56175 }
56176
56177 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56178     return (Dali::BaseHandle *)jarg1;
56179 }
56180
56181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56182     return (Dali::BaseHandle *)jarg1;
56183 }
56184
56185 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56186     return (Dali::BaseHandle *)jarg1;
56187 }
56188
56189 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56190     return (Dali::BaseHandle *)jarg1;
56191 }
56192
56193 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56194     return (Dali::BaseHandle *)jarg1;
56195 }
56196
56197 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56198     return (Dali::BaseHandle *)jarg1;
56199 }
56200
56201 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56202     return (Dali::Handle *)jarg1;
56203 }
56204
56205 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56206     return (Dali::Handle *)jarg1;
56207 }
56208
56209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56210     return (Dali::BaseHandle *)jarg1;
56211 }
56212
56213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56214     return (Dali::BaseHandle *)jarg1;
56215 }
56216
56217 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56218     return (Dali::Handle *)jarg1;
56219 }
56220
56221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56222     return (Dali::BaseHandle *)jarg1;
56223 }
56224
56225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56226     return (Dali::BaseHandle *)jarg1;
56227 }
56228
56229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56230     return (Dali::BaseHandle *)jarg1;
56231 }
56232
56233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56234     return (Dali::BaseHandle *)jarg1;
56235 }
56236
56237 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56238     return (Dali::Handle *)jarg1;
56239 }
56240
56241 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56242     return (Dali::GestureDetector *)jarg1;
56243 }
56244
56245 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56246     return (Dali::Gesture *)jarg1;
56247 }
56248
56249 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56250     return (Dali::Handle *)jarg1;
56251 }
56252
56253 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56254     return (Dali::Actor *)jarg1;
56255 }
56256
56257 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56258     return (Dali::RefObject *)jarg1;
56259 }
56260
56261 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56262     return (Dali::Actor *)jarg1;
56263 }
56264
56265 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56266     return (Dali::GestureDetector *)jarg1;
56267 }
56268
56269 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56270     return (Dali::Gesture *)jarg1;
56271 }
56272
56273 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56274     return (Dali::GestureDetector *)jarg1;
56275 }
56276
56277 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56278     return (Dali::Gesture *)jarg1;
56279 }
56280
56281 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56282     return (Dali::GestureDetector *)jarg1;
56283 }
56284
56285 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56286     return (Dali::Gesture *)jarg1;
56287 }
56288
56289 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56290     return (Dali::BaseHandle *)jarg1;
56291 }
56292
56293 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56294     return (Dali::Handle *)jarg1;
56295 }
56296
56297 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56298     return (Dali::Handle *)jarg1;
56299 }
56300
56301 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56302     return (Dali::Handle *)jarg1;
56303 }
56304
56305 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56306     return (Dali::RefObject *)jarg1;
56307 }
56308
56309 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56310     return (Dali::Actor *)jarg1;
56311 }
56312
56313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56314     return (Dali::BaseHandle *)jarg1;
56315 }
56316
56317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56318     return (Dali::BaseHandle *)jarg1;
56319 }
56320
56321 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56322     return (Dali::BaseHandle *)jarg1;
56323 }
56324
56325 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56326     return (Dali::CustomActorImpl *)jarg1;
56327 }
56328
56329 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56330     return (Dali::CustomActor *)jarg1;
56331 }
56332
56333 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56334     return (Dali::BaseHandle *)jarg1;
56335 }
56336
56337 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56338     return (Dali::Toolkit::Control *)jarg1;
56339 }
56340
56341 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56342     return (Dali::Toolkit::Control *)jarg1;
56343 }
56344
56345 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56346     return (Dali::Toolkit::Button *)jarg1;
56347 }
56348
56349 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56350     return (Dali::Toolkit::Button *)jarg1;
56351 }
56352
56353 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56354     return (Dali::Toolkit::Button *)jarg1;
56355 }
56356
56357 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56358     return (Dali::Toolkit::Control *)jarg1;
56359 }
56360
56361 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56362     return (Dali::Toolkit::Control *)jarg1;
56363 }
56364
56365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56366     return (Dali::Toolkit::Control *)jarg1;
56367 }
56368
56369 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56370     return (Dali::Toolkit::Control *)jarg1;
56371 }
56372
56373 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56374     return (Dali::Toolkit::Control *)jarg1;
56375 }
56376
56377 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56378     return (Dali::RefObject *)jarg1;
56379 }
56380
56381 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56382     return (Dali::Toolkit::Scrollable *)jarg1;
56383 }
56384
56385 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56386     return (Dali::BaseHandle *)jarg1;
56387 }
56388
56389 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56390     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56391 }
56392
56393 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56394     return (Dali::RefObject *)jarg1;
56395 }
56396
56397 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56398     return (Dali::Toolkit::Ruler *)jarg1;
56399 }
56400
56401 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56402     return (Dali::Toolkit::Ruler *)jarg1;
56403 }
56404
56405 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56406     return (Dali::Toolkit::Scrollable *)jarg1;
56407 }
56408
56409 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56410     return (Dali::Toolkit::Control *)jarg1;
56411 }
56412
56413
56414 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56415     return (Dali::Toolkit::Control *)jarg1;
56416 }
56417
56418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56419     return (Dali::BaseHandle *)jarg1;
56420 }
56421
56422 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56423     return (Dali::BaseHandle *)jarg1;
56424 }
56425
56426 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56427     return (Dali::Toolkit::Control *)jarg1;
56428 }
56429
56430 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56431     return (Dali::Toolkit::Control *)jarg1;
56432 }
56433
56434 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56435     return (Dali::Toolkit::Control *)jarg1;
56436 }
56437
56438 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56439     return (Dali::Toolkit::Control *)jarg1;
56440 }
56441
56442 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56443     return (Dali::Toolkit::Control *)jarg1;
56444 }
56445
56446 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56447     return (Dali::Toolkit::Control *)jarg1;
56448 }
56449
56450 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56451     return (Dali::Toolkit::PageTurnView *)jarg1;
56452 }
56453
56454 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56455     return (Dali::Toolkit::PageTurnView *)jarg1;
56456 }
56457
56458 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56459     return (Dali::Toolkit::Button *)jarg1;
56460 }
56461
56462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56463     return (Dali::BaseHandle *)jarg1;
56464 }
56465
56466 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56467     return (Dali::BaseHandle *)jarg1;
56468 }
56469
56470 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56471     return (Dali::BaseHandle *)jarg1;
56472 }
56473
56474 /*
56475  * Widget binding
56476  */
56477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56478     return (Dali::BaseHandle *)jarg1;
56479 }
56480
56481 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56482     return (Dali::BaseObject *)jarg1;
56483 }
56484
56485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56486   void * jresult ;
56487   Dali::Widget result;
56488
56489   {
56490     try {
56491       result = Dali::Widget::New();
56492     } CALL_CATCH_EXCEPTION(0);
56493   }
56494
56495   jresult = new Dali::Widget((const Dali::Widget &)result);
56496   return jresult;
56497 }
56498
56499
56500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56501   void * jresult ;
56502   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56503   Dali::Widget result;
56504
56505   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56506
56507   if (!arg1) {
56508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56509     return 0;
56510   }
56511   {
56512     try {
56513       jresult = new Dali::Widget(arg1);
56514     } CALL_CATCH_EXCEPTION(0);
56515   }
56516   return jresult;
56517 }
56518
56519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56520   void * jresult ;
56521   Dali::Widget *result = 0 ;
56522
56523   {
56524     try {
56525       result = (Dali::Widget *)new Dali::Widget();
56526     } CALL_CATCH_EXCEPTION(0);
56527   }
56528   jresult = (void *)result;
56529   return jresult;
56530 }
56531
56532
56533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56534   void * jresult ;
56535   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56536   Dali::Widget *arg2 = 0 ;
56537   Dali::Widget *result = 0 ;
56538
56539   arg1 = (Dali::Widget *)jarg1;
56540   arg2 = (Dali::Widget *)jarg2;
56541   if (!arg2) {
56542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56543     return 0;
56544   }
56545   {
56546     try {
56547       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56548     } CALL_CATCH_EXCEPTION(0);
56549   }
56550   jresult = (void *)result;
56551   return jresult;
56552 }
56553
56554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56555   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56556
56557   arg1 = (Dali::Widget *)jarg1;
56558   {
56559     try {
56560       delete arg1;
56561     } CALL_CATCH_EXCEPTION();
56562   }
56563 }
56564
56565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56566   void * jresult ;
56567   SwigDirector_WidgetImpl* result;
56568   {
56569     try {
56570       result = new SwigDirector_WidgetImpl();
56571     } CALL_CATCH_EXCEPTION(0);
56572   }
56573   jresult = result;
56574   return jresult;
56575 }
56576
56577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56578   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56579   std::string *arg2 = 0 ;
56580   Dali::Window arg3 ;
56581   Dali::Window *argp3 ;
56582
56583   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56584   if (!jarg2) {
56585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56586     return ;
56587   }
56588   std::string arg2_str(jarg2);
56589   arg2 = &arg2_str;
56590   argp3 = (Dali::Window *)jarg3;
56591   if (!argp3) {
56592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56593     return ;
56594   }
56595   arg3 = *argp3;
56596   {
56597     try {
56598       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56599     } CALL_CATCH_EXCEPTION();
56600   }
56601 }
56602
56603
56604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56605   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56606   std::string *arg2 = 0 ;
56607   Dali::Window arg3 ;
56608   Dali::Window *argp3 ;
56609
56610   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56611   if (!jarg2) {
56612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56613     return ;
56614   }
56615   std::string arg2_str(jarg2);
56616   arg2 = &arg2_str;
56617   argp3 = (Dali::Window *)jarg3;
56618   if (!argp3) {
56619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56620     return ;
56621   }
56622   arg3 = *argp3;
56623   {
56624     try {
56625       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56626     } CALL_CATCH_EXCEPTION();
56627   }
56628 }
56629
56630
56631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56632   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56633   std::string *arg2 = 0 ;
56634   Dali::Widget::Termination arg3 ;
56635
56636   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56637   if (!jarg2) {
56638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56639     return ;
56640   }
56641   std::string arg2_str(jarg2);
56642   arg2 = &arg2_str;
56643   arg3 = (Dali::Widget::Termination)jarg3;
56644   {
56645     try {
56646       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56647     } CALL_CATCH_EXCEPTION();
56648   }
56649 }
56650
56651
56652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56653   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56654   std::string *arg2 = 0 ;
56655   Dali::Widget::Termination arg3 ;
56656
56657   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56658   if (!jarg2) {
56659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56660     return ;
56661   }
56662   std::string arg2_str(jarg2);
56663   arg2 = &arg2_str;
56664   arg3 = (Dali::Widget::Termination)jarg3;
56665   {
56666     try {
56667       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56668     } CALL_CATCH_EXCEPTION();
56669   }
56670 }
56671
56672
56673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56674   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56675
56676   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56677   {
56678     try {
56679       (arg1)->OnPause();
56680     } CALL_CATCH_EXCEPTION();
56681   }
56682 }
56683
56684
56685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56686   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56687
56688   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56689   {
56690     try {
56691       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56692     } CALL_CATCH_EXCEPTION();
56693   }
56694 }
56695
56696
56697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56698   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56699
56700   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56701   {
56702     try {
56703       (arg1)->OnResume();
56704     } CALL_CATCH_EXCEPTION();
56705   }
56706 }
56707
56708
56709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(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)->Dali::Internal::Adaptor::Widget::OnResume();
56716     } CALL_CATCH_EXCEPTION();
56717   }
56718 }
56719
56720
56721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56722   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56723   Dali::Window arg2 ;
56724   Dali::Window *argp2 ;
56725
56726   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56727   argp2 = (Dali::Window *)jarg2;
56728   if (!argp2) {
56729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56730     return ;
56731   }
56732   arg2 = *argp2;
56733   {
56734     try {
56735       (arg1)->OnResize(arg2);
56736     } CALL_CATCH_EXCEPTION();
56737   }
56738 }
56739
56740
56741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
56742   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56743   Dali::Window arg2 ;
56744   Dali::Window *argp2 ;
56745
56746   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56747   argp2 = (Dali::Window *)jarg2;
56748   if (!argp2) {
56749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56750     return ;
56751   }
56752   arg2 = *argp2;
56753   {
56754     try {
56755       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
56756     } CALL_CATCH_EXCEPTION();
56757   }
56758 }
56759
56760
56761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
56762   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56763   std::string *arg2 = 0 ;
56764   int arg3 ;
56765
56766   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56767   if (!jarg2) {
56768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56769     return ;
56770   }
56771   std::string arg2_str(jarg2);
56772   arg2 = &arg2_str;
56773   arg3 = (int)jarg3;
56774   {
56775     try {
56776       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
56777     } CALL_CATCH_EXCEPTION();
56778   }
56779 }
56780
56781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56782   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56783   std::string *arg2 = 0 ;
56784   int arg3 ;
56785
56786   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56787   if (!jarg2) {
56788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56789     return ;
56790   }
56791   std::string arg2_str(jarg2);
56792   arg2 = &arg2_str;
56793   arg3 = (int)jarg3;
56794   {
56795     try {
56796       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
56797     } CALL_CATCH_EXCEPTION();
56798   }
56799 }
56800
56801
56802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
56803   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56804   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56805   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56806
56807   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56808   arg2 = (Dali::SlotObserver *)jarg2;
56809   arg3 = (Dali::CallbackBase *)jarg3;
56810   {
56811     try {
56812       (arg1)->SignalConnected(arg2,arg3);
56813     } CALL_CATCH_EXCEPTION();
56814   }
56815 }
56816
56817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
56818   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56819   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56820   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56821
56822   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56823   arg2 = (Dali::SlotObserver *)jarg2;
56824   arg3 = (Dali::CallbackBase *)jarg3;
56825   {
56826     try {
56827       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
56828     } CALL_CATCH_EXCEPTION();
56829   }
56830 }
56831
56832
56833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
56834   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56835   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56836   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56837
56838   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56839   arg2 = (Dali::SlotObserver *)jarg2;
56840   arg3 = (Dali::CallbackBase *)jarg3;
56841   {
56842     try {
56843       (arg1)->SignalDisconnected(arg2,arg3);
56844     } CALL_CATCH_EXCEPTION();
56845   }
56846 }
56847
56848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
56849   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56850   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
56851   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
56852
56853   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56854   arg2 = (Dali::SlotObserver *)jarg2;
56855   arg3 = (Dali::CallbackBase *)jarg3;
56856   {
56857     try {
56858       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
56859     } CALL_CATCH_EXCEPTION();
56860   }
56861 }
56862
56863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
56864   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56865   std::string *arg2 = 0 ;
56866
56867   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56868   if (!jarg2) {
56869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56870     return ;
56871   }
56872   std::string arg2_str(jarg2);
56873   arg2 = &arg2_str;
56874   {
56875     try {
56876       (arg1)->SetContentInfo((std::string const &)*arg2);
56877     } CALL_CATCH_EXCEPTION();
56878   }
56879 }
56880
56881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
56882   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56883   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
56884
56885   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56886   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
56887   {
56888     try {
56889       (arg1)->SetImpl(arg2);
56890     } CALL_CATCH_EXCEPTION();
56891   }
56892 }
56893
56894
56895 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) {
56896   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
56897   if (director) {
56898     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
56899   }
56900 }
56901
56902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
56903   void * jresult ;
56904   Dali::Widget *arg1 = 0 ;
56905   SwigDirector_WidgetImpl *result = 0 ;
56906
56907   arg1 = (Dali::Widget *)jarg1;
56908   if (!arg1) {
56909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
56910     return 0;
56911   }
56912   {
56913     try {
56914       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
56915     } CALL_CATCH_EXCEPTION(0);
56916   }
56917   jresult = (void*) result;
56918   return jresult;
56919 }
56920
56921
56922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
56923   void * jresult ;
56924   int *arg1 = (int *) 0 ;
56925   char ***arg2 ;
56926   std::string *arg3 = 0 ;
56927   Dali::WidgetApplication result;
56928   {
56929     int index = 0;
56930     int length = 0;
56931     char *retPtr;
56932     char *nextPtr;
56933     argWidgetC = jarg1;
56934     argWidgetV = new char*[jarg1 + 1];
56935
56936     retPtr = strtok_r( jarg2, " ", &nextPtr);
56937     if( retPtr )
56938     {
56939       length = strlen(retPtr);
56940     }
56941     argWidgetV[index] = new char[length + 1];
56942     if( retPtr )
56943     {
56944       strncpy(argWidgetV[index], retPtr, length);
56945     }
56946     argWidgetV[index][length] = '\0';
56947     index++;
56948
56949     while (index < jarg1)
56950     {
56951       length = 0;
56952       retPtr = strtok_r(NULL, " ", &nextPtr);
56953       if( retPtr )
56954       {
56955         length = strlen(retPtr);
56956       }
56957       argWidgetV[index] = new char[length + 1];
56958       if( retPtr )
56959       {
56960         strncpy(argWidgetV[index], retPtr, length);
56961       }
56962       argWidgetV[index][length] = '\0';
56963       index++;
56964     }
56965
56966     argWidgetV[jarg1] = NULL;
56967     argWidgetC = jarg1;
56968
56969     arg1 = &argWidgetC;
56970     arg2 = &argWidgetV;
56971   }
56972
56973   if (!jarg3) {
56974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56975     return 0;
56976   }
56977   std::string arg3_str(jarg3);
56978   arg3 = &arg3_str;
56979   {
56980     try {
56981       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
56982     } CALL_CATCH_EXCEPTION(0);
56983   }
56984   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
56985   return jresult;
56986 }
56987
56988
56989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
56990   void * jresult ;
56991   Dali::WidgetApplication *result = 0 ;
56992
56993   {
56994     try {
56995       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
56996     } CALL_CATCH_EXCEPTION(0);
56997   }
56998   jresult = (void *)result;
56999   return jresult;
57000 }
57001
57002
57003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57004   void * jresult ;
57005   Dali::WidgetApplication *arg1 = 0 ;
57006   Dali::WidgetApplication *result = 0 ;
57007
57008   arg1 = (Dali::WidgetApplication *)jarg1;
57009   if (!arg1) {
57010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57011     return 0;
57012   }
57013   {
57014     try {
57015       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57016     } CALL_CATCH_EXCEPTION(0);
57017   }
57018   jresult = (void *)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57024   void * jresult ;
57025   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57026   Dali::WidgetApplication *arg2 = 0 ;
57027   Dali::WidgetApplication *result = 0 ;
57028
57029   arg1 = (Dali::WidgetApplication *)jarg1;
57030   arg2 = (Dali::WidgetApplication *)jarg2;
57031   if (!arg2) {
57032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57033     return 0;
57034   }
57035   {
57036     try {
57037       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57038     } CALL_CATCH_EXCEPTION(0);
57039   }
57040   jresult = (void *)result;
57041   return jresult;
57042 }
57043
57044
57045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57046   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57047
57048   arg1 = (Dali::WidgetApplication *)jarg1;
57049   {
57050     try {
57051       delete arg1;
57052       if( argWidgetV )
57053       {
57054         // free string data
57055         for( int i=0; i < argWidgetC+1; i++)
57056         {
57057           delete [] argWidgetV[i];
57058         }
57059         delete [] argWidgetV;
57060       }
57061     } CALL_CATCH_EXCEPTION();
57062   }
57063 }
57064
57065
57066 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57067 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57068
57069 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57070 {
57071   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57072   return *widget;
57073 }
57074
57075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57076   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57077   std::string *arg2 = 0 ;
57078
57079   arg1 = (Dali::WidgetApplication *)jarg1;
57080   if (!jarg2) {
57081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57082     return ;
57083   }
57084   std::string arg2_str(*jarg2);
57085   arg2 = &arg2_str;
57086
57087   if(!_CSharpCreateWidgetFunction)
57088   {
57089     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57090   }
57091
57092   {
57093     try {
57094       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57095     } CALL_CATCH_EXCEPTION();
57096   }
57097   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57098 }
57099
57100
57101 //for PixelBuffer and ImageLoading
57102
57103 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57104     return (Dali::BaseHandle *)jarg1;
57105 }
57106
57107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57108   void * jresult ;
57109   unsigned int arg1 ;
57110   unsigned int arg2 ;
57111   Dali::Pixel::Format arg3 ;
57112   Dali::Devel::PixelBuffer result;
57113
57114   arg1 = (unsigned int)jarg1;
57115   arg2 = (unsigned int)jarg2;
57116   arg3 = (Dali::Pixel::Format)jarg3;
57117   {
57118     try {
57119       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57120     } CALL_CATCH_EXCEPTION(0);
57121   }
57122   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57123   return jresult;
57124 }
57125
57126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57127   void * jresult ;
57128   Dali::Devel::PixelBuffer *result = 0 ;
57129
57130   {
57131     try {
57132       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57133     } CALL_CATCH_EXCEPTION(0);
57134   }
57135   jresult = (void *)result;
57136   return jresult;
57137 }
57138
57139
57140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57141   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57142
57143   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57144   {
57145     try {
57146       delete arg1;
57147     } CALL_CATCH_EXCEPTION();
57148   }
57149 }
57150
57151
57152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57153   void * jresult ;
57154   Dali::Devel::PixelBuffer *arg1 = 0 ;
57155   Dali::Devel::PixelBuffer *result = 0 ;
57156
57157   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57158   if (!arg1) {
57159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57160     return 0;
57161   }
57162   {
57163     try {
57164       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57165     } CALL_CATCH_EXCEPTION(0);
57166   }
57167   jresult = (void *)result;
57168   return jresult;
57169 }
57170
57171
57172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57173   void * jresult ;
57174   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57175   Dali::Devel::PixelBuffer *arg2 = 0 ;
57176   Dali::Devel::PixelBuffer *result = 0 ;
57177
57178   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57179   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57180   if (!arg2) {
57181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57182     return 0;
57183   }
57184   {
57185     try {
57186       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57187     } CALL_CATCH_EXCEPTION(0);
57188   }
57189   jresult = (void *)result;
57190   return jresult;
57191 }
57192
57193
57194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57195   void * jresult ;
57196   Dali::Devel::PixelBuffer *arg1 = 0 ;
57197   Dali::PixelData result;
57198
57199   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57200   if (!arg1) {
57201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57202     return 0;
57203   }
57204   {
57205     try {
57206       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57207     } CALL_CATCH_EXCEPTION(0);
57208   }
57209   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57210   return jresult;
57211 }
57212
57213
57214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57215   void * jresult ;
57216   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57217   Dali::PixelData result;
57218
57219   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57220   {
57221     try {
57222       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57223     } CALL_CATCH_EXCEPTION(0);
57224   }
57225   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57231   void * jresult ;
57232   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57233   unsigned char *result = 0 ;
57234
57235   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57236   {
57237     try {
57238       result = (unsigned char *)(arg1)->GetBuffer();
57239     } CALL_CATCH_EXCEPTION(0);
57240   }
57241    jresult = (void *)result;
57242    return jresult;
57243 }
57244
57245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57246   unsigned int jresult ;
57247   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57248   unsigned int result;
57249
57250   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57251   {
57252     try {
57253       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57254     } CALL_CATCH_EXCEPTION(0);
57255   }
57256   jresult = result;
57257   return jresult;
57258 }
57259
57260
57261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57262   unsigned int jresult ;
57263   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57264   unsigned int result;
57265
57266   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57267   {
57268     try {
57269       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57270     } CALL_CATCH_EXCEPTION(0);
57271   }
57272   jresult = result;
57273   return jresult;
57274 }
57275
57276
57277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57278   int jresult ;
57279   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57280   Dali::Pixel::Format result;
57281
57282   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57283   {
57284     try {
57285       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57286     } CALL_CATCH_EXCEPTION(0);
57287   }
57288   jresult = (int)result;
57289   return jresult;
57290 }
57291
57292
57293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57294   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57295   Dali::Devel::PixelBuffer arg2 ;
57296   float arg3 ;
57297   bool arg4 ;
57298   Dali::Devel::PixelBuffer *argp2 ;
57299
57300   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57301   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57302   if (!argp2) {
57303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57304     return ;
57305   }
57306   arg2 = *argp2;
57307   arg3 = (float)jarg3;
57308   arg4 = jarg4 ? true : false;
57309   {
57310     try {
57311       (arg1)->ApplyMask(arg2,arg3,arg4);
57312     } CALL_CATCH_EXCEPTION();
57313   }
57314 }
57315
57316
57317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57318   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57319   Dali::Devel::PixelBuffer arg2 ;
57320   float arg3 ;
57321   Dali::Devel::PixelBuffer *argp2 ;
57322
57323   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57324   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57325   if (!argp2) {
57326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57327     return ;
57328   }
57329   arg2 = *argp2;
57330   arg3 = (float)jarg3;
57331   {
57332     try {
57333       (arg1)->ApplyMask(arg2,arg3);
57334     } CALL_CATCH_EXCEPTION();
57335   }
57336 }
57337
57338
57339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57340   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57341   Dali::Devel::PixelBuffer arg2 ;
57342   Dali::Devel::PixelBuffer *argp2 ;
57343
57344   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57345   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57346   if (!argp2) {
57347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57348     return ;
57349   }
57350   arg2 = *argp2;
57351   {
57352     try {
57353       (arg1)->ApplyMask(arg2);
57354     } CALL_CATCH_EXCEPTION();
57355   }
57356 }
57357
57358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57359   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57360   float arg2 ;
57361
57362   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57363   arg2 = (float)jarg2;
57364   {
57365     try {
57366       (arg1)->ApplyGaussianBlur(arg2);
57367     } CALL_CATCH_EXCEPTION();
57368   }
57369 }
57370
57371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57372   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57373   uint16_t arg2 ;
57374   uint16_t arg3 ;
57375   uint16_t arg4 ;
57376   uint16_t arg5 ;
57377
57378   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57379   arg2 = (uint16_t)jarg2;
57380   arg3 = (uint16_t)jarg3;
57381   arg4 = (uint16_t)jarg4;
57382   arg5 = (uint16_t)jarg5;
57383   {
57384     try {
57385       (arg1)->Crop(arg2,arg3,arg4,arg5);
57386     } CALL_CATCH_EXCEPTION();
57387   }
57388 }
57389
57390
57391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57392   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57393   uint16_t arg2 ;
57394   uint16_t arg3 ;
57395
57396   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57397   arg2 = (uint16_t)jarg2;
57398   arg3 = (uint16_t)jarg3;
57399   {
57400     try {
57401       (arg1)->Resize(arg2,arg3);
57402     } CALL_CATCH_EXCEPTION();
57403   }
57404 }
57405
57406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57407   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57408   Dali::Degree * arg2 ;
57409
57410   bool result = false;
57411
57412   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57413   arg2 = (Dali::Degree *)jarg2;
57414   {
57415     try {
57416       result = (arg1)->Rotate(*arg2);
57417     } CALL_CATCH_EXCEPTION(false);
57418   }
57419   return result;
57420 }
57421
57422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57423   void * jresult ;
57424   std::string *arg1 = 0 ;
57425   Dali::ImageDimensions arg2 ;
57426   Dali::FittingMode::Type arg3 ;
57427   Dali::SamplingMode::Type arg4 ;
57428   bool arg5 ;
57429   Dali::ImageDimensions *argp2 ;
57430   Dali::Devel::PixelBuffer result;
57431
57432   if (!jarg1) {
57433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57434     return 0;
57435   }
57436   std::string arg1_str(jarg1);
57437   arg1 = &arg1_str;
57438   argp2 = (Dali::ImageDimensions *)jarg2;
57439   if (!argp2) {
57440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57441     return 0;
57442   }
57443   arg2 = *argp2;
57444   arg3 = (Dali::FittingMode::Type)jarg3;
57445   arg4 = (Dali::SamplingMode::Type)jarg4;
57446   arg5 = jarg5 ? true : false;
57447   {
57448     try {
57449       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57450     } CALL_CATCH_EXCEPTION(0);
57451   }
57452   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57453   return jresult;
57454 }
57455
57456
57457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57458   void * jresult ;
57459   std::string *arg1 = 0 ;
57460   Dali::ImageDimensions arg2 ;
57461   Dali::FittingMode::Type arg3 ;
57462   Dali::SamplingMode::Type arg4 ;
57463   Dali::ImageDimensions *argp2 ;
57464   Dali::Devel::PixelBuffer result;
57465
57466   if (!jarg1) {
57467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57468     return 0;
57469   }
57470   std::string arg1_str(jarg1);
57471   arg1 = &arg1_str;
57472   argp2 = (Dali::ImageDimensions *)jarg2;
57473   if (!argp2) {
57474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57475     return 0;
57476   }
57477   arg2 = *argp2;
57478   arg3 = (Dali::FittingMode::Type)jarg3;
57479   arg4 = (Dali::SamplingMode::Type)jarg4;
57480   {
57481     try {
57482       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57483     } CALL_CATCH_EXCEPTION(0);
57484   }
57485   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57486   return jresult;
57487 }
57488
57489
57490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57491   void * jresult ;
57492   std::string *arg1 = 0 ;
57493   Dali::ImageDimensions arg2 ;
57494   Dali::FittingMode::Type arg3 ;
57495   Dali::ImageDimensions *argp2 ;
57496   Dali::Devel::PixelBuffer result;
57497
57498   if (!jarg1) {
57499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57500     return 0;
57501   }
57502   std::string arg1_str(jarg1);
57503   arg1 = &arg1_str;
57504   argp2 = (Dali::ImageDimensions *)jarg2;
57505   if (!argp2) {
57506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57507     return 0;
57508   }
57509   arg2 = *argp2;
57510   arg3 = (Dali::FittingMode::Type)jarg3;
57511   {
57512     try {
57513       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57514     } CALL_CATCH_EXCEPTION(0);
57515   }
57516   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57517   return jresult;
57518 }
57519
57520
57521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57522   void * jresult ;
57523   std::string *arg1 = 0 ;
57524   Dali::ImageDimensions arg2 ;
57525   Dali::ImageDimensions *argp2 ;
57526   Dali::Devel::PixelBuffer result;
57527
57528   if (!jarg1) {
57529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57530     return 0;
57531   }
57532   std::string arg1_str(jarg1);
57533   arg1 = &arg1_str;
57534   argp2 = (Dali::ImageDimensions *)jarg2;
57535   if (!argp2) {
57536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57537     return 0;
57538   }
57539   arg2 = *argp2;
57540   {
57541     try {
57542       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57543     } CALL_CATCH_EXCEPTION(0);
57544   }
57545   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57546   return jresult;
57547 }
57548
57549
57550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57551   void * jresult ;
57552   std::string *arg1 = 0 ;
57553   Dali::Devel::PixelBuffer result;
57554
57555   if (!jarg1) {
57556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57557     return 0;
57558   }
57559   std::string arg1_str(jarg1);
57560   arg1 = &arg1_str;
57561   {
57562     try {
57563       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57564     } CALL_CATCH_EXCEPTION(0);
57565   }
57566   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57567   return jresult;
57568 }
57569
57570
57571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57572   void * jresult ;
57573   std::string *arg1 = 0 ;
57574   Dali::ImageDimensions arg2 ;
57575   Dali::FittingMode::Type arg3 ;
57576   Dali::SamplingMode::Type arg4 ;
57577   bool arg5 ;
57578   Dali::ImageDimensions *argp2 ;
57579   Dali::ImageDimensions result;
57580
57581   if (!jarg1) {
57582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57583     return 0;
57584   }
57585   std::string arg1_str(jarg1);
57586   arg1 = &arg1_str;
57587   argp2 = (Dali::ImageDimensions *)jarg2;
57588   if (!argp2) {
57589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57590     return 0;
57591   }
57592   arg2 = *argp2;
57593   arg3 = (Dali::FittingMode::Type)jarg3;
57594   arg4 = (Dali::SamplingMode::Type)jarg4;
57595   arg5 = jarg5 ? true : false;
57596   {
57597     try {
57598       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57599     } CALL_CATCH_EXCEPTION(0);
57600   }
57601   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57602   return jresult;
57603 }
57604
57605
57606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57607   void * jresult ;
57608   std::string *arg1 = 0 ;
57609   Dali::ImageDimensions arg2 ;
57610   Dali::FittingMode::Type arg3 ;
57611   Dali::SamplingMode::Type arg4 ;
57612   Dali::ImageDimensions *argp2 ;
57613   Dali::ImageDimensions result;
57614
57615   if (!jarg1) {
57616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57617     return 0;
57618   }
57619   std::string arg1_str(jarg1);
57620   arg1 = &arg1_str;
57621   argp2 = (Dali::ImageDimensions *)jarg2;
57622   if (!argp2) {
57623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57624     return 0;
57625   }
57626   arg2 = *argp2;
57627   arg3 = (Dali::FittingMode::Type)jarg3;
57628   arg4 = (Dali::SamplingMode::Type)jarg4;
57629   {
57630     try {
57631       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57632     } CALL_CATCH_EXCEPTION(0);
57633   }
57634   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57635   return jresult;
57636 }
57637
57638
57639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57640   void * jresult ;
57641   std::string *arg1 = 0 ;
57642   Dali::ImageDimensions arg2 ;
57643   Dali::FittingMode::Type arg3 ;
57644   Dali::ImageDimensions *argp2 ;
57645   Dali::ImageDimensions result;
57646
57647   if (!jarg1) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57649     return 0;
57650   }
57651   std::string arg1_str(jarg1);
57652   arg1 = &arg1_str;
57653   argp2 = (Dali::ImageDimensions *)jarg2;
57654   if (!argp2) {
57655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57656     return 0;
57657   }
57658   arg2 = *argp2;
57659   arg3 = (Dali::FittingMode::Type)jarg3;
57660   {
57661     try {
57662       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57663     } CALL_CATCH_EXCEPTION(0);
57664   }
57665   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57666   return jresult;
57667 }
57668
57669
57670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57671   void * jresult ;
57672   std::string *arg1 = 0 ;
57673   Dali::ImageDimensions arg2 ;
57674   Dali::ImageDimensions *argp2 ;
57675   Dali::ImageDimensions result;
57676
57677   if (!jarg1) {
57678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57679     return 0;
57680   }
57681   std::string arg1_str(jarg1);
57682   arg1 = &arg1_str;
57683   argp2 = (Dali::ImageDimensions *)jarg2;
57684   if (!argp2) {
57685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57686     return 0;
57687   }
57688   arg2 = *argp2;
57689   {
57690     try {
57691       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57692     } CALL_CATCH_EXCEPTION(0);
57693   }
57694   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57695   return jresult;
57696 }
57697
57698
57699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57700   void * jresult ;
57701   std::string *arg1 = 0 ;
57702   Dali::ImageDimensions result;
57703
57704   if (!jarg1) {
57705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57706     return 0;
57707   }
57708   std::string arg1_str(jarg1);
57709   arg1 = &arg1_str;
57710   {
57711     try {
57712       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57713     } CALL_CATCH_EXCEPTION(0);
57714   }
57715   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57716   return jresult;
57717 }
57718
57719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57720   void * jresult ;
57721   std::string *arg1 = 0 ;
57722   Dali::ImageDimensions result;
57723
57724   if (!jarg1) {
57725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57726     return 0;
57727   }
57728   std::string arg1_str(jarg1);
57729   arg1 = &arg1_str;
57730   {
57731     try {
57732       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
57733     } CALL_CATCH_EXCEPTION(0);
57734   }
57735   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57736   return jresult;
57737 }
57738
57739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57740   void * jresult ;
57741   std::string *arg1 = 0 ;
57742   Dali::ImageDimensions arg2 ;
57743   Dali::FittingMode::Type arg3 ;
57744   Dali::SamplingMode::Type arg4 ;
57745   bool arg5 ;
57746   Dali::ImageDimensions *argp2 ;
57747   Dali::Devel::PixelBuffer result;
57748
57749   if (!jarg1) {
57750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57751     return 0;
57752   }
57753   std::string arg1_str(jarg1);
57754   arg1 = &arg1_str;
57755   argp2 = (Dali::ImageDimensions *)jarg2;
57756   if (!argp2) {
57757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57758     return 0;
57759   }
57760   arg2 = *argp2;
57761   arg3 = (Dali::FittingMode::Type)jarg3;
57762   arg4 = (Dali::SamplingMode::Type)jarg4;
57763   arg5 = jarg5 ? true : false;
57764   {
57765     try {
57766       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57767     } CALL_CATCH_EXCEPTION(0);
57768   }
57769   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57770   return jresult;
57771 }
57772
57773
57774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57775   void * jresult ;
57776   std::string *arg1 = 0 ;
57777   Dali::ImageDimensions arg2 ;
57778   Dali::FittingMode::Type arg3 ;
57779   Dali::SamplingMode::Type arg4 ;
57780   Dali::ImageDimensions *argp2 ;
57781   Dali::Devel::PixelBuffer result;
57782
57783   if (!jarg1) {
57784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57785     return 0;
57786   }
57787   std::string arg1_str(jarg1);
57788   arg1 = &arg1_str;
57789   argp2 = (Dali::ImageDimensions *)jarg2;
57790   if (!argp2) {
57791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57792     return 0;
57793   }
57794   arg2 = *argp2;
57795   arg3 = (Dali::FittingMode::Type)jarg3;
57796   arg4 = (Dali::SamplingMode::Type)jarg4;
57797   {
57798     try {
57799       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
57800     } CALL_CATCH_EXCEPTION(0);
57801   }
57802   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57803   return jresult;
57804 }
57805
57806
57807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57808   void * jresult ;
57809   std::string *arg1 = 0 ;
57810   Dali::ImageDimensions arg2 ;
57811   Dali::FittingMode::Type arg3 ;
57812   Dali::ImageDimensions *argp2 ;
57813   Dali::Devel::PixelBuffer result;
57814
57815   if (!jarg1) {
57816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57817     return 0;
57818   }
57819   std::string arg1_str(jarg1);
57820   arg1 = &arg1_str;
57821   argp2 = (Dali::ImageDimensions *)jarg2;
57822   if (!argp2) {
57823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57824     return 0;
57825   }
57826   arg2 = *argp2;
57827   arg3 = (Dali::FittingMode::Type)jarg3;
57828   {
57829     try {
57830       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
57831     } CALL_CATCH_EXCEPTION(0);
57832   }
57833   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57834   return jresult;
57835 }
57836
57837
57838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
57839   void * jresult ;
57840   std::string *arg1 = 0 ;
57841   Dali::ImageDimensions arg2 ;
57842   Dali::ImageDimensions *argp2 ;
57843   Dali::Devel::PixelBuffer result;
57844
57845   if (!jarg1) {
57846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57847     return 0;
57848   }
57849   std::string arg1_str(jarg1);
57850   arg1 = &arg1_str;
57851   argp2 = (Dali::ImageDimensions *)jarg2;
57852   if (!argp2) {
57853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57854     return 0;
57855   }
57856   arg2 = *argp2;
57857   {
57858     try {
57859       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
57860     } CALL_CATCH_EXCEPTION(0);
57861   }
57862   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57863   return jresult;
57864 }
57865
57866
57867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
57868   void * jresult ;
57869   std::string *arg1 = 0 ;
57870   Dali::Devel::PixelBuffer result;
57871
57872   if (!jarg1) {
57873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57874     return 0;
57875   }
57876   std::string arg1_str(jarg1);
57877   arg1 = &arg1_str;
57878   {
57879     try {
57880       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
57881     } CALL_CATCH_EXCEPTION(0);
57882   }
57883   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57884   return jresult;
57885 }
57886
57887
57888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
57889   void * jresult ;
57890   Dali::Toolkit::WebView result;
57891
57892   {
57893     try {
57894       result = Dali::Toolkit::WebView::New();
57895     } CALL_CATCH_EXCEPTION(0);
57896   }
57897   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
57898   return jresult;
57899 }
57900
57901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
57902   void * jresult ;
57903   Dali::Toolkit::WebView result;
57904
57905   std::string *arg1;
57906   std::string *arg2;
57907
57908   if (!jarg1) {
57909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
57910     return 0;
57911   }
57912   if (!jarg2) {
57913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
57914     return 0;
57915   }
57916
57917   std::string jarg1_str = std::string(jarg1);
57918   std::string jarg2_str = std::string(jarg2);
57919
57920   arg1 = &jarg1_str;
57921   arg2 = &jarg2_str;
57922
57923   {
57924     try {
57925       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
57926     } CALL_CATCH_EXCEPTION(0);
57927   }
57928   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
57929   return jresult;
57930 }
57931
57932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
57933   void * jresult ;
57934   Dali::Toolkit::WebView *arg1 = 0 ;
57935   Dali::Toolkit::WebView *result = 0 ;
57936
57937   arg1 = (Dali::Toolkit::WebView *)jarg1;
57938   if (!arg1) {
57939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
57940     return 0;
57941   }
57942   {
57943     try {
57944       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
57945     } CALL_CATCH_EXCEPTION(0);
57946   }
57947   jresult = (void *)result;
57948   return jresult;
57949 }
57950
57951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
57952   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
57953   arg1 = (Dali::Toolkit::WebView *)jarg1;
57954   {
57955     try {
57956       delete arg1;
57957     } CALL_CATCH_EXCEPTION();
57958   }
57959 }
57960
57961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
57962   void * jresult ;
57963   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
57964   Dali::Toolkit::WebView *arg2 = 0 ;
57965   Dali::Toolkit::WebView *result = 0 ;
57966
57967   arg1 = (Dali::Toolkit::WebView *)jarg1;
57968   arg2 = (Dali::Toolkit::WebView *)jarg2;
57969   if (!arg2) {
57970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
57971     return 0;
57972   }
57973   {
57974     try {
57975       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
57976     } CALL_CATCH_EXCEPTION(0);
57977   }
57978   jresult = (void *)result;
57979   return jresult;
57980 }
57981
57982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
57983   void * jresult ;
57984   Dali::BaseHandle arg1 ;
57985   Dali::BaseHandle *argp1 ;
57986   Dali::Toolkit::WebView result;
57987
57988   argp1 = (Dali::BaseHandle *)jarg1;
57989   if (!argp1) {
57990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
57991     return 0;
57992   }
57993   arg1 = *argp1;
57994   {
57995     try {
57996       result = Dali::Toolkit::WebView::DownCast(arg1);
57997     } CALL_CATCH_EXCEPTION(0);
57998   }
57999   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58000   return jresult;
58001 }
58002
58003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58004   return (int) Dali::Toolkit::WebView::Property::URL;
58005 }
58006
58007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58008   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58009 }
58010
58011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58012   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58013 }
58014
58015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58016   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58017 }
58018
58019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58020   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58021 }
58022
58023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58024   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58025 }
58026
58027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58028   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58029 }
58030
58031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58032   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58033 }
58034
58035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58036   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58037   std::string *arg2;
58038
58039   arg1 = (Dali::Toolkit::WebView *)jarg1;
58040
58041   if (!jarg2) {
58042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58043     return;
58044   }
58045
58046   std::string jarg2str = std::string(jarg2);
58047   arg2 = &jarg2str;
58048   {
58049     try {
58050       (arg1)->LoadUrl((std::string const &)*arg2);
58051     } CALL_CATCH_EXCEPTION();
58052   }
58053 }
58054
58055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58056   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58057   std::string *arg2;
58058
58059   arg1 = (Dali::Toolkit::WebView *)jarg1;
58060   if (!jarg2) {
58061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58062     return;
58063   }
58064   std::string jarg2str = std::string(jarg2);
58065   arg2 = &jarg2str;
58066   {
58067     try {
58068       (arg1)->LoadHTMLString((std::string const &)*arg2);
58069     } CALL_CATCH_EXCEPTION();
58070   }
58071 }
58072
58073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58074   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58075
58076   arg1 = (Dali::Toolkit::WebView *)jarg1;
58077   {
58078     try {
58079       (arg1)->Reload();
58080     } CALL_CATCH_EXCEPTION();
58081   }
58082 }
58083
58084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58085   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58086
58087   arg1 = (Dali::Toolkit::WebView *)jarg1;
58088   {
58089     try {
58090       (arg1)->StopLoading();
58091     } CALL_CATCH_EXCEPTION();
58092   }
58093 }
58094
58095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58096   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58097
58098   arg1 = (Dali::Toolkit::WebView *)jarg1;
58099   {
58100     try {
58101       (arg1)->Suspend();
58102     } CALL_CATCH_EXCEPTION();
58103   }
58104 }
58105
58106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58107   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58108
58109   arg1 = (Dali::Toolkit::WebView *)jarg1;
58110   {
58111     try {
58112       (arg1)->Resume();
58113     } CALL_CATCH_EXCEPTION();
58114   }
58115 }
58116
58117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58118   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58119
58120   arg1 = (Dali::Toolkit::WebView *)jarg1;
58121   {
58122     try {
58123       (arg1)->GoBack();
58124     } CALL_CATCH_EXCEPTION();
58125   }
58126 }
58127
58128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58129   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58130
58131   arg1 = (Dali::Toolkit::WebView *)jarg1;
58132   {
58133     try {
58134       (arg1)->GoForward();
58135     } CALL_CATCH_EXCEPTION();
58136   }
58137 }
58138
58139 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58140   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58141   bool ret;
58142
58143   arg1 = (Dali::Toolkit::WebView *)jarg1;
58144   {
58145     try {
58146       ret = (arg1)->CanGoBack();
58147     } CALL_CATCH_EXCEPTION(0);
58148   }
58149   return ret;
58150 }
58151
58152 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58153   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58154   bool ret;
58155
58156   arg1 = (Dali::Toolkit::WebView *)jarg1;
58157   {
58158     try {
58159       ret = (arg1)->CanGoForward();
58160     } CALL_CATCH_EXCEPTION(0);
58161   }
58162   return ret;
58163 }
58164
58165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58166   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58167   std::string *arg2;
58168
58169   arg1 = (Dali::Toolkit::WebView *)jarg1;
58170   if (!jarg2) {
58171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58172     return;
58173   }
58174   std::string jarg2_str = std::string(jarg2);
58175   arg2 = &jarg2_str;
58176
58177   {
58178     try {
58179       if (jarg3) {
58180         void (*handler)(char*) = (void (*)(char*)) jarg3;
58181         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58182           handler(SWIG_csharp_string_callback(result.c_str()));
58183         });
58184       } else {
58185         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58186       }
58187     } CALL_CATCH_EXCEPTION();
58188   }
58189 }
58190
58191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58192 {
58193   if (!jarg2) {
58194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58195     return;
58196   }
58197
58198   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58199   std::string exposedObjectName = jarg2;
58200   void (*handler)(char*) = (void (*)(char*)) jarg3;
58201
58202   {
58203     try {
58204       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58205         handler(SWIG_csharp_string_callback(message.c_str()));
58206       });
58207     } CALL_CATCH_EXCEPTION();
58208   }
58209 }
58210
58211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58212   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58213
58214   arg1 = (Dali::Toolkit::WebView *)jarg1;
58215   {
58216     try {
58217       (arg1)->ClearHistory();
58218     } CALL_CATCH_EXCEPTION();
58219   }
58220 }
58221
58222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58223   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58224
58225   arg1 = (Dali::Toolkit::WebView *)jarg1;
58226   {
58227     try {
58228       (arg1)->ClearCache();
58229     } CALL_CATCH_EXCEPTION();
58230   }
58231 }
58232
58233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58234   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58235
58236   arg1 = (Dali::Toolkit::WebView *)jarg1;
58237   {
58238     try {
58239       (arg1)->ClearCookies();
58240     } CALL_CATCH_EXCEPTION();
58241   }
58242 }
58243
58244 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58245     return (Dali::Toolkit::Control *)jarg1;
58246 }
58247
58248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58249   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58250   SignalConverter::WebViewPageLoadSignal* result = NULL;
58251   {
58252     try {
58253       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58254     } CALL_CATCH_EXCEPTION(0);
58255   }
58256   return (void*) result;
58257 }
58258
58259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58260   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58261   SignalConverter::WebViewPageLoadSignal* result = NULL;
58262   {
58263     try {
58264       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58265     } CALL_CATCH_EXCEPTION(0);
58266   }
58267   return (void*) result;
58268 }
58269
58270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58271 {
58272   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58273   {
58274     try {
58275       delete object;
58276     } CALL_CATCH_EXCEPTION();
58277   }
58278 }
58279
58280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58281 {
58282   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58283   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58284   {
58285     try {
58286       proxy->Connect(callback);
58287     } CALL_CATCH_EXCEPTION();
58288   }
58289 }
58290
58291
58292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58293   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58294   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58295   {
58296     try {
58297       proxy->Disconnect(callback);
58298     } CALL_CATCH_EXCEPTION();
58299   }
58300 }
58301
58302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58303   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58304   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58305   {
58306     try {
58307       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58308     } CALL_CATCH_EXCEPTION(0);
58309   }
58310   return (void*) result;
58311 }
58312
58313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58314 {
58315   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58316   {
58317     try {
58318       delete object;
58319     } CALL_CATCH_EXCEPTION();
58320   }
58321 }
58322
58323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58324 {
58325   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58326   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58327   {
58328     try {
58329       proxy->Connect(callback);
58330     } CALL_CATCH_EXCEPTION();
58331   }
58332 }
58333
58334
58335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58336   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58337   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58338   {
58339     try {
58340       proxy->Disconnect(callback);
58341     } CALL_CATCH_EXCEPTION();
58342   }
58343 }
58344
58345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58346   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58347   char * jresult = SWIG_csharp_string_callback((const char *)result);
58348   return jresult;
58349 }
58350
58351 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58352   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58353   return result;
58354 }
58355
58356
58357 struct NativeImageSourcePtrHandle
58358 {
58359   NativeImageSourcePtr Ptr;
58360 };
58361
58362 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58363 {
58364   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58365   return (NativeImageInterface*)(arg1);
58366 }
58367
58368 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58369 {
58370   void* jresult;
58371   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58372   {
58373     try {
58374       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58375     }
58376     catch (std::out_of_range & e) {
58377       {
58378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58379       };
58380     }
58381     catch (std::exception & e) {
58382       {
58383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58384       };
58385     }
58386     catch (Dali::DaliException e) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58389       };
58390     }
58391     catch (...) {
58392       {
58393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58394       };
58395     }
58396   }
58397   jresult = (void *)handle;
58398   return jresult;
58399 }
58400
58401 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58402 {
58403   void* jresult;
58404   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58405   jresult = (void*)( handle->Ptr.Get() );
58406   return jresult;
58407 }
58408
58409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58410   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58411   {
58412     try {
58413       delete arg1;
58414     }
58415     catch (std::out_of_range & e) {
58416       {
58417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58418       };
58419     }
58420     catch (std::exception & e) {
58421       {
58422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58423       };
58424     }
58425     catch (Dali::DaliException e) {
58426       {
58427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58428       };
58429     }
58430     catch (...) {
58431       {
58432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58433       };
58434     }
58435   }
58436 }
58437
58438 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58439 {
58440   void* jresult;
58441   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58442   uint16_t* arg2 = (uint16_t*)(jarg2);
58443   uint16_t* arg3 = (uint16_t*)(jarg3);
58444   uint16_t* arg4 = (uint16_t*)(jarg4);
58445   {
58446     try {
58447       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58448     }
58449     catch (std::out_of_range & e) {
58450       {
58451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58452       };
58453     }
58454     catch (std::exception & e) {
58455       {
58456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58457       };
58458     }
58459     catch (Dali::DaliException e) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58462       };
58463     }
58464     catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58467       };
58468     }
58469   }
58470   return jresult;
58471 }
58472
58473 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58474 {
58475   bool jresult;
58476   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58477
58478   {
58479     try {
58480       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58481     }
58482     catch (std::out_of_range & e) {
58483       {
58484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58485       };
58486     }
58487     catch (std::exception & e) {
58488       {
58489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58490       };
58491     }
58492     catch (Dali::DaliException e) {
58493       {
58494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58495       };
58496     }
58497     catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58500       };
58501     }
58502   }
58503   return jresult;
58504 }
58505
58506
58507 #ifdef __cplusplus
58508 }
58509 #endif