dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318 /* -----------------------------------------------------------------------------
 319  * director_common.swg
 320  *
 321  * This file contains support for director classes which is common between
 322  * languages.
 323  * ----------------------------------------------------------------------------- */
 324
 325 /*
 326   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 327   'Swig' namespace. This could be useful for multi-modules projects.
 328 */
 329 #ifdef SWIG_DIRECTOR_STATIC
 330 /* Force anonymous (static) namespace */
 331 #define Swig
 332 #endif
 333 /* -----------------------------------------------------------------------------
 334  * director.swg
 335  *
 336  * This file contains support for director classes so that C# proxy
 337  * methods can be called from C++.
 338  * ----------------------------------------------------------------------------- */
 339
 340 #if defined(DEBUG_DIRECTOR_OWNED)
 341 #include <iostream>
 342 #endif
 343 #include <string>
 344 #include <exception>
 345
 346 namespace Swig {
 347   /* Director base class - not currently used in C# directors */
 348   class Director {
 349   };
 350
 351   /* Base class for director exceptions */
 352   class DirectorException : public std::exception {
 353   protected:
 354     std::string swig_msg;
 355
 356   public:
 357     DirectorException(const char *msg) : swig_msg(msg) {
 358     }
 359
 360     DirectorException(const std::string &msg) : swig_msg(msg) {
 361     }
 362
 363     virtual ~DirectorException() throw() {
 364     }
 365
 366     const char *what() const throw() {
 367       return swig_msg.c_str();
 368     }
 369   };
 370
 371   /* Pure virtual method exception */
 372   class DirectorPureVirtualException : public DirectorException {
 373   public:
 374     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 375     }
 376   };
 377 }
 378
 379
 380 void SWIG_CSharpException(int code, const char *msg) {
 381   if (code == SWIG_ValueError) {
 382     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 383     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 384   } else {
 385     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 386     switch(code) {
 387     case SWIG_MemoryError:
 388       exception_code = SWIG_CSharpOutOfMemoryException;
 389       break;
 390     case SWIG_IndexError:
 391       exception_code = SWIG_CSharpIndexOutOfRangeException;
 392       break;
 393     case SWIG_DivisionByZero:
 394       exception_code = SWIG_CSharpDivideByZeroException;
 395       break;
 396     case SWIG_IOError:
 397       exception_code = SWIG_CSharpIOException;
 398       break;
 399     case SWIG_OverflowError:
 400       exception_code = SWIG_CSharpOverflowException;
 401       break;
 402     case SWIG_RuntimeError:
 403     case SWIG_TypeError:
 404     case SWIG_SyntaxError:
 405     case SWIG_SystemError:
 406     case SWIG_UnknownError:
 407     default:
 408       exception_code = SWIG_CSharpApplicationException;
 409       break;
 410     }
 411     SWIG_CSharpSetPendingException(exception_code, msg);
 412   }
 413 }
 414
 415
 416 #include <stdexcept>
 417
 418
 419 #define SWIGSTDCALL
 420
 421 #include <time.h>
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429 #include <dali/devel-api/events/wheel-event-devel.h>
 430 #include <dali/devel-api/events/key-event-devel.h>
 431
 432 #include <dali/public-api/math/matrix.h>
 433 #include <dali/public-api/math/matrix3.h>
 434 #include <dali/public-api/math/viewport.h>
 435 #include <dali/public-api/object/property-key.h>
 436 #include <dali/devel-api/object/csharp-type-info.h>
 437 #include <dali/devel-api/object/csharp-type-registry.h>
 438
 439 #include <dali/public-api/adaptor-framework/timer.h>
 440 #include <dali/public-api/adaptor-framework/style-change.h>
 441 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 442
 443 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/control-devel.h>
 451 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 459 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 460 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 461
 462 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 463 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 464 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 465
 466 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 467 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 469
 470 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 471 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 472 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 473
 474 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 475
 476 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 477 #include <dali/devel-api/adaptor-framework/image-loading.h>
 478
 479 #include <dali/public-api/events/mouse-button.h>
 480
 481 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 482 #include "web-view-signal-converter.h"
 483
 484 #include <dali/integration-api/debug.h>
 485
 486 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 487
 488 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 489
 490 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 491
 492
 493 #include <dali/devel-api/update/frame-callback-interface.h>
 494 #include <dali/devel-api/update/update-proxy.h>
 495
 496
 497 // add here SWIG version check
 498
 499 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 500 // disable Swig-dependent warnings
 501
 502 // 'identifier1' has C-linkage specified,
 503 // but returns UDT 'identifier2' which is incompatible with C
 504 #pragma warning(disable: 4190)
 505
 506 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 507 #pragma warning(disable: 4800)
 508
 509 // debug info too long etc etc
 510 #pragma warning(disable: 4786)
 511 #endif
 512
 513
 514 #include <stdexcept>
 515
 516
 517 #include <string>
 518
 519
 520 #include <vector>
 521 #include <algorithm>
 522 #include <stdexcept>
 523
 524
 525 #include <map>
 526 #include <algorithm>
 527 #include <stdexcept>
 528
 529
 530 #include <utility>
 531
 532
 533 typedef float floatp;
 534
 535 SWIGINTERN floatp *new_floatp(){
 536   return new float();
 537 }
 538 SWIGINTERN void delete_floatp(floatp *self){
 539   if (self) delete self;
 540 }
 541 SWIGINTERN void floatp_assign(floatp *self,float value){
 542   *self = value;
 543 }
 544 SWIGINTERN float floatp_value(floatp *self){
 545   return *self;
 546 }
 547 SWIGINTERN float *floatp_cast(floatp *self){
 548   return self;
 549 }
 550 SWIGINTERN floatp *floatp_frompointer(float *t){
 551   return (floatp *) t;
 552 }
 553
 554 typedef int intp;
 555
 556 SWIGINTERN intp *new_intp(){
 557   return new int();
 558 }
 559 SWIGINTERN void delete_intp(intp *self){
 560   if (self) delete self;
 561 }
 562 SWIGINTERN void intp_assign(intp *self,int value){
 563   *self = value;
 564 }
 565 SWIGINTERN int intp_value(intp *self){
 566   return *self;
 567 }
 568 SWIGINTERN int *intp_cast(intp *self){
 569   return self;
 570 }
 571 SWIGINTERN intp *intp_frompointer(int *t){
 572   return (intp *) t;
 573 }
 574
 575 typedef double doublep;
 576
 577 SWIGINTERN doublep *new_doublep(){
 578   return new double();
 579 }
 580 SWIGINTERN void delete_doublep(doublep *self){
 581   if (self) delete self;
 582 }
 583 SWIGINTERN void doublep_assign(doublep *self,double value){
 584   *self = value;
 585 }
 586 SWIGINTERN double doublep_value(doublep *self){
 587   return *self;
 588 }
 589 SWIGINTERN double *doublep_cast(doublep *self){
 590   return self;
 591 }
 592 SWIGINTERN doublep *doublep_frompointer(double *t){
 593   return (doublep *) t;
 594 }
 595
 596 typedef unsigned int uintp;
 597
 598 SWIGINTERN uintp *new_uintp(){
 599   return new unsigned int();
 600 }
 601 SWIGINTERN void delete_uintp(uintp *self){
 602   if (self) delete self;
 603 }
 604 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 605   *self = value;
 606 }
 607 SWIGINTERN unsigned int uintp_value(uintp *self){
 608   return *self;
 609 }
 610 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 611   return self;
 612 }
 613 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 614   return (uintp *) t;
 615 }
 616
 617 typedef unsigned short ushortp;
 618
 619 SWIGINTERN ushortp *new_ushortp(){
 620   return new unsigned short();
 621 }
 622 SWIGINTERN void delete_ushortp(ushortp *self){
 623   if (self) delete self;
 624 }
 625 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 626   *self = value;
 627 }
 628 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 629   return *self;
 630 }
 631 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 632   return self;
 633 }
 634 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 635   return (ushortp *) t;
 636 }
 637
 638 unsigned int int_to_uint(int x) {
 639    return (unsigned int) x;
 640 }
 641
 642
 643 #define CALL_CATCH_EXCEPTION(ret)          \
 644          catch (std::out_of_range& e)            \
 645          {                                                                                                                                  \
 646              SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));   \
 647              return ret;\
 648           }                                                                                                                                 \
 649           catch (std::exception& e)                                                                                         \
 650           {                                                                                                                                 \
 651             SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));\
 652             return ret;\
 653           }                                                                                                                                 \
 654           catch (DaliException e)                                                                                            \
 655           {                                                                                                                                 \
 656             SWIG_CSharpException(SWIG_UnknownError, e.condition);                            \
 657             return ret;\
 658           }                                                                                                                                 \
 659           catch (...)                                                                                                                  \
 660           {                                                                                                                                 \
 661             SWIG_CSharpException(SWIG_UnknownError, "unknown error");                  \
 662             return ret;\
 663           }
 664
 665
 666
 667 using namespace Dali;
 668 using namespace Dali::Toolkit;
 669
 670 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 671 {
 672   bool result = false;
 673   try
 674   {
 675     // C++ code. DALi uses Handle <-> Body design pattern.
 676     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 677     // Handles in DALi can be converted into a boolean type
 678     // to check if the handle has a valid body attached to it.
 679     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 680     if( *self )
 681     {
 682       result = true;
 683     }
 684     else
 685     {
 686       result = false;
 687     }
 688   }
 689   CALL_CATCH_EXCEPTION(false);
 690   return result;
 691 }
 692
 693 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 694 {
 695   bool result = false;
 696   try
 697   {
 698     // C++ code. Check if two handles reference the same implemtion
 699     if( *self == rhs)
 700     {
 701       result = true;
 702     }
 703     else
 704     {
 705       result = false;
 706     }
 707   }
 708   CALL_CATCH_EXCEPTION(false);
 709   return result;
 710 }
 711
 712
 713 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 714      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 715    }
 716 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){
 717      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 718    }
 719 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 720         std::vector< Dali::TouchPoint >* pv = 0;
 721         if (capacity >= 0) {
 722           pv = new std::vector< Dali::TouchPoint >();
 723           pv->reserve(capacity);
 724        } else {
 725           throw std::out_of_range("capacity");
 726        }
 727        return pv;
 728       }
 729 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 730         if (index>=0 && index<(int)self->size())
 731           return (*self)[index];
 732         else
 733           throw std::out_of_range("index");
 734       }
 735 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 736         if (index>=0 && index<(int)self->size())
 737           return (*self)[index];
 738         else
 739           throw std::out_of_range("index");
 740       }
 741 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 742         if (index>=0 && index<(int)self->size())
 743           (*self)[index] = val;
 744         else
 745           throw std::out_of_range("index");
 746       }
 747 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 748         self->insert(self->end(), values.begin(), values.end());
 749       }
 750 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 751         if (index < 0)
 752           throw std::out_of_range("index");
 753         if (count < 0)
 754           throw std::out_of_range("count");
 755         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 756           throw std::invalid_argument("invalid range");
 757         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 760         if (index>=0 && index<(int)self->size()+1)
 761           self->insert(self->begin()+index, x);
 762         else
 763           throw std::out_of_range("index");
 764       }
 765 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 766         if (index>=0 && index<(int)self->size()+1)
 767           self->insert(self->begin()+index, values.begin(), values.end());
 768         else
 769           throw std::out_of_range("index");
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 772         if (index>=0 && index<(int)self->size())
 773           self->erase(self->begin() + index);
 774         else
 775           throw std::out_of_range("index");
 776       }
 777 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 778         if (index < 0)
 779           throw std::out_of_range("index");
 780         if (count < 0)
 781           throw std::out_of_range("count");
 782         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 783           throw std::invalid_argument("invalid range");
 784         self->erase(self->begin()+index, self->begin()+index+count);
 785       }
 786 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 787         if (count < 0)
 788           throw std::out_of_range("count");
 789         return new std::vector< Dali::TouchPoint >(count, value);
 790       }
 791 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 792         std::reverse(self->begin(), self->end());
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 795         if (index < 0)
 796           throw std::out_of_range("index");
 797         if (count < 0)
 798           throw std::out_of_range("count");
 799         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 800           throw std::invalid_argument("invalid range");
 801         std::reverse(self->begin()+index, self->begin()+index+count);
 802       }
 803 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 804         if (index < 0)
 805           throw std::out_of_range("index");
 806         if (index+values.size() > self->size())
 807           throw std::out_of_range("index");
 808         std::copy(values.begin(), values.end(), self->begin()+index);
 809       }
 810 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 811          return self->Empty();
 812       }
 813 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 814         return self->GetConnectionCount();
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 817           self->Connect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 820           self->Disconnect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 823           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 824 /*@SWIG@*/ self->Emit( arg );
 825       }
 826 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 827          return self->Empty();
 828       }
 829 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 830         return self->GetConnectionCount();
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 833           self->Connect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 836           self->Disconnect( func );
 837       }
 838 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 839           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 840 /*@SWIG@*/ self->Emit( arg );
 841       }
 842 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 843          return self->Empty();
 844       }
 845 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){
 846         return self->GetConnectionCount();
 847       }
 848 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 *)){
 849           self->Connect( func );
 850       }
 851 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 *)){
 852           self->Disconnect( func );
 853       }
 854 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){
 855           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 856 /*@SWIG@*/ self->Emit( arg );
 857       }
 858 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 859          return self->Empty();
 860       }
 861 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 862         return self->GetConnectionCount();
 863       }
 864 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 865           self->Connect( func );
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 868           self->Disconnect( func );
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 871           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 872 /*@SWIG@*/ self->Emit( arg );
 873       }
 874 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){
 875          return self->Empty();
 876       }
 877 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){
 878         return self->GetConnectionCount();
 879       }
 880 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 &)){
 881         self->Connect( func );
 882       }
 883 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 &)){
 884         self->Disconnect( func );
 885       }
 886 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){
 887         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 888 /*@SWIG@*/ self->Emit( arg1, arg2 );
 889       }
 890 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){
 891          return self->Empty();
 892       }
 893 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){
 894         return self->GetConnectionCount();
 895       }
 896 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 &)){
 897         self->Connect( func );
 898       }
 899 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 &)){
 900         self->Disconnect( func );
 901       }
 902 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){
 903         return self->Emit( arg1, arg2 );
 904       }
 905 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){
 906          return self->Empty();
 907       }
 908 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){
 909         return self->GetConnectionCount();
 910       }
 911 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 &)){
 912         self->Connect( func );
 913       }
 914 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 &)){
 915         self->Disconnect( func );
 916       }
 917 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){
 918         return self->Emit( arg1, arg2 );
 919       }
 920 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){
 921          return self->Empty();
 922       }
 923 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){
 924         return self->GetConnectionCount();
 925       }
 926 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 &)){
 927         self->Connect( func );
 928       }
 929 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 &)){
 930         self->Disconnect( func );
 931       }
 932 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){
 933         return self->Emit( arg1, arg2 );
 934       }
 935 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 936          return self->Empty();
 937       }
 938 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 939         return self->GetConnectionCount();
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 942           self->Connect( func );
 943       }
 944 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 945           self->Disconnect( func );
 946       }
 947 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 948           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 949 /*@SWIG@*/ self->Emit( arg );
 950       }
 951 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 952          return self->Empty();
 953       }
 954 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){
 955         return self->GetConnectionCount();
 956       }
 957 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 &)){
 958           self->Connect( func );
 959       }
 960 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 &)){
 961           self->Disconnect( func );
 962       }
 963 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){
 964           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 965 /*@SWIG@*/ self->Emit( arg );
 966       }
 967 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 968          return self->Empty();
 969       }
 970 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){
 971         return self->GetConnectionCount();
 972       }
 973 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 &)){
 974           self->Connect( func );
 975       }
 976 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 &)){
 977           self->Disconnect( func );
 978       }
 979 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){
 980           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 981 /*@SWIG@*/ self->Emit( arg );
 982       }
 983 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 984          return self->Empty();
 985       }
 986 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){
 987         return self->GetConnectionCount();
 988       }
 989 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 &)){
 990           self->Connect( func );
 991       }
 992 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 &)){
 993           self->Disconnect( func );
 994       }
 995 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){
 996           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 997 /*@SWIG@*/ self->Emit( arg );
 998       }
 999 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){
1000          return self->Empty();
1001       }
1002 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){
1003         return self->GetConnectionCount();
1004       }
1005 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 &)){
1006         self->Connect( func );
1007       }
1008 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 &)){
1009         self->Disconnect( func );
1010       }
1011 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){
1012         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1013 /*@SWIG@*/ self->Emit( arg1, arg2 );
1014       }
1015 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){
1016          return self->Empty();
1017       }
1018 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){
1019         return self->GetConnectionCount();
1020       }
1021 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 &)){
1022         self->Connect( func );
1023       }
1024 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 &)){
1025         self->Disconnect( func );
1026       }
1027 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){
1028         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1029 /*@SWIG@*/ self->Emit( arg1, arg2 );
1030       }
1031 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){
1032          return self->Empty();
1033       }
1034 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){
1035         return self->GetConnectionCount();
1036       }
1037 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 &)){
1038         self->Connect( func );
1039       }
1040 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 &)){
1041         self->Disconnect( func );
1042       }
1043 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){
1044         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1045 /*@SWIG@*/ self->Emit( arg1, arg2 );
1046       }
1047 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){
1048          return self->Empty();
1049       }
1050 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){
1051         return self->GetConnectionCount();
1052       }
1053 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)){
1054           return self->Connect( func );
1055       }
1056 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)){
1057           self->Disconnect( func );
1058       }
1059 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){
1060           self->Emit( arg1, arg3 );
1061       }
1062 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){
1063          return self->Empty();
1064       }
1065 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){
1066         return self->GetConnectionCount();
1067       }
1068 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)){
1069           return self->Connect( func );
1070       }
1071 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)){
1072           self->Disconnect( func );
1073       }
1074 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){
1075           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1076 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1077       }
1078
1079 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1080          return self->Empty();
1081       }
1082 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1083         return self->GetConnectionCount();
1084       }
1085 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1086           self->Connect( func );
1087       }
1088 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1089           self->Disconnect( func );
1090       }
1091 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1092           return self->Emit();
1093       }
1094
1095 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1096         std::vector< unsigned int >* pv = 0;
1097         if (capacity >= 0) {
1098           pv = new std::vector< unsigned int >();
1099           pv->reserve(capacity);
1100        } else {
1101           throw std::out_of_range("capacity");
1102        }
1103        return pv;
1104       }
1105 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1106         if (index>=0 && index<(int)self->size())
1107           return (*self)[index];
1108         else
1109           throw std::out_of_range("index");
1110       }
1111 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1112         if (index>=0 && index<(int)self->size())
1113           return (*self)[index];
1114         else
1115           throw std::out_of_range("index");
1116       }
1117 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1118         if (index>=0 && index<(int)self->size())
1119           (*self)[index] = val;
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1124         self->insert(self->end(), values.begin(), values.end());
1125       }
1126 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1127         if (index < 0)
1128           throw std::out_of_range("index");
1129         if (count < 0)
1130           throw std::out_of_range("count");
1131         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1132           throw std::invalid_argument("invalid range");
1133         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1136         if (index>=0 && index<(int)self->size()+1)
1137           self->insert(self->begin()+index, x);
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1142         if (index>=0 && index<(int)self->size()+1)
1143           self->insert(self->begin()+index, values.begin(), values.end());
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1148         if (index>=0 && index<(int)self->size())
1149           self->erase(self->begin() + index);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         self->erase(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1163         if (count < 0)
1164           throw std::out_of_range("count");
1165         return new std::vector< unsigned int >(count, value);
1166       }
1167 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1168         std::reverse(self->begin(), self->end());
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1171         if (index < 0)
1172           throw std::out_of_range("index");
1173         if (count < 0)
1174           throw std::out_of_range("count");
1175         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1176           throw std::invalid_argument("invalid range");
1177         std::reverse(self->begin()+index, self->begin()+index+count);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1180         if (index < 0)
1181           throw std::out_of_range("index");
1182         if (index+values.size() > self->size())
1183           throw std::out_of_range("index");
1184         std::copy(values.begin(), values.end(), self->begin()+index);
1185       }
1186 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1187         return std::find(self->begin(), self->end(), value) != self->end();
1188       }
1189 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1190         int index = -1;
1191         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1192         if (it != self->end())
1193           index = (int)(it - self->begin());
1194         return index;
1195       }
1196 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1197         int index = -1;
1198         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1199         if (rit != self->rend())
1200           index = (int)(self->rend() - 1 - rit);
1201         return index;
1202       }
1203 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1204         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1205         if (it != self->end()) {
1206           self->erase(it);
1207           return true;
1208         }
1209         return false;
1210       }
1211 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){
1212         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1213         if (capacity >= 0) {
1214           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1215           pv->reserve(capacity);
1216        } else {
1217           throw std::out_of_range("capacity");
1218        }
1219        return pv;
1220       }
1221 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){
1222         if (index>=0 && index<(int)self->size())
1223           return (*self)[index];
1224         else
1225           throw std::out_of_range("index");
1226       }
1227 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){
1228         if (index>=0 && index<(int)self->size())
1229           return (*self)[index];
1230         else
1231           throw std::out_of_range("index");
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size())
1235           (*self)[index] = val;
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 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){
1240         self->insert(self->end(), values.begin(), values.end());
1241       }
1242 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){
1243         if (index < 0)
1244           throw std::out_of_range("index");
1245         if (count < 0)
1246           throw std::out_of_range("count");
1247         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1248           throw std::invalid_argument("invalid range");
1249         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size()+1)
1253           self->insert(self->begin()+index, x);
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size()+1)
1259           self->insert(self->begin()+index, values.begin(), values.end());
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size())
1265           self->erase(self->begin() + index);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 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){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         self->erase(self->begin()+index, self->begin()+index+count);
1277       }
1278 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){
1279         if (count < 0)
1280           throw std::out_of_range("count");
1281         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1282       }
1283 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){
1284         std::reverse(self->begin(), self->end());
1285       }
1286 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){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         std::reverse(self->begin()+index, self->begin()+index+count);
1294       }
1295 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){
1296         if (index < 0)
1297           throw std::out_of_range("index");
1298         if (index+values.size() > self->size())
1299           throw std::out_of_range("index");
1300         std::copy(values.begin(), values.end(), self->begin()+index);
1301       }
1302 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1303         std::vector< Dali::Actor >* pv = 0;
1304         if (capacity >= 0) {
1305           pv = new std::vector< Dali::Actor >();
1306           pv->reserve(capacity);
1307        } else {
1308           throw std::out_of_range("capacity");
1309        }
1310        return pv;
1311       }
1312 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1313         if (index>=0 && index<(int)self->size())
1314           return (*self)[index];
1315         else
1316           throw std::out_of_range("index");
1317       }
1318 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1319         if (index>=0 && index<(int)self->size())
1320           return (*self)[index];
1321         else
1322           throw std::out_of_range("index");
1323       }
1324 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1325         if (index>=0 && index<(int)self->size())
1326           (*self)[index] = val;
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1331         self->insert(self->end(), values.begin(), values.end());
1332       }
1333 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1334         if (index < 0)
1335           throw std::out_of_range("index");
1336         if (count < 0)
1337           throw std::out_of_range("count");
1338         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1339           throw std::invalid_argument("invalid range");
1340         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1343         if (index>=0 && index<(int)self->size()+1)
1344           self->insert(self->begin()+index, x);
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1349         if (index>=0 && index<(int)self->size()+1)
1350           self->insert(self->begin()+index, values.begin(), values.end());
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1355         if (index>=0 && index<(int)self->size())
1356           self->erase(self->begin() + index);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         self->erase(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1370         if (count < 0)
1371           throw std::out_of_range("count");
1372         return new std::vector< Dali::Actor >(count, value);
1373       }
1374 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1375         std::reverse(self->begin(), self->end());
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1378         if (index < 0)
1379           throw std::out_of_range("index");
1380         if (count < 0)
1381           throw std::out_of_range("count");
1382         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1383           throw std::invalid_argument("invalid range");
1384         std::reverse(self->begin()+index, self->begin()+index+count);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1387         if (index < 0)
1388           throw std::out_of_range("index");
1389         if (index+values.size() > self->size())
1390           throw std::out_of_range("index");
1391         std::copy(values.begin(), values.end(), self->begin()+index);
1392       }
1393 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1394          return self->Empty();
1395       }
1396 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1397         return self->GetConnectionCount();
1398       }
1399 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 &)){
1400           self->Connect( func );
1401       }
1402 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 &)){
1403           self->Disconnect( func );
1404       }
1405 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){
1406           return self->Emit( arg );
1407       }
1408 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){
1409          return self->Empty();
1410       }
1411 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){
1412         return self->GetConnectionCount();
1413       }
1414 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)){
1415         self->Connect( func );
1416       }
1417 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)){
1418         self->Disconnect( func );
1419       }
1420 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){
1421         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1422 /*@SWIG@*/ self->Emit( arg1, arg2 );
1423       }
1424 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1425          return self->Empty();
1426       }
1427 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){
1428         return self->GetConnectionCount();
1429       }
1430 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)){
1431         self->Connect( func );
1432       }
1433 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)){
1434         self->Disconnect( func );
1435       }
1436 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){
1437         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1438 /*@SWIG@*/ self->Emit( arg1, arg2 );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1441          return self->Empty();
1442       }
1443 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1444         return self->GetConnectionCount();
1445       }
1446 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)){
1447         self->Connect( func );
1448       }
1449 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)){
1450         self->Disconnect( func );
1451       }
1452 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){
1453         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1454 /*@SWIG@*/ self->Emit( arg1, arg2 );
1455       }
1456 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){
1457          return self->Empty();
1458       }
1459 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){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463         self->Connect( func );
1464       }
1465 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)){
1466         self->Disconnect( func );
1467       }
1468 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){
1469         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1470 /*@SWIG@*/ self->Emit( arg1, arg2 );
1471       }
1472 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1473          return self->Empty();
1474       }
1475 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1476         return self->GetConnectionCount();
1477       }
1478 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)){
1479           self->Connect( func );
1480       }
1481 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)){
1482           self->Disconnect( func );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1485           return self->Emit( arg );
1486       }
1487 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1488          return self->Empty();
1489       }
1490 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1491         return self->GetConnectionCount();
1492       }
1493 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)){
1494           self->Connect( func );
1495       }
1496 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)){
1497           self->Disconnect( func );
1498       }
1499 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1500           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1501 /*@SWIG@*/ self->Emit( arg );
1502       }
1503 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){
1504          return self->Empty();
1505       }
1506 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){
1507         return self->GetConnectionCount();
1508       }
1509 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)){
1510           return self->Connect( func );
1511       }
1512 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)){
1513           self->Disconnect( func );
1514       }
1515 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){
1516           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1517 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1518       }
1519 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1520          return self->Empty();
1521       }
1522 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1523         return self->GetConnectionCount();
1524       }
1525 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)){
1526           self->Connect( func );
1527       }
1528 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)){
1529           self->Disconnect( func );
1530       }
1531 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1532           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1533 /*@SWIG@*/ self->Emit( arg );
1534       }
1535 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){
1536          return self->Empty();
1537       }
1538 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){
1539         return self->GetConnectionCount();
1540       }
1541 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)){
1542           return self->Connect( func );
1543       }
1544 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)){
1545           self->Disconnect( func );
1546       }
1547 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){
1548           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1549 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1550       }
1551 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){
1552          return self->Empty();
1553       }
1554 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){
1555         return self->GetConnectionCount();
1556       }
1557 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 &)){
1558           self->Connect( func );
1559       }
1560 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 &)){
1561           self->Disconnect( func );
1562       }
1563 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){
1564           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1565 /*@SWIG@*/ self->Emit( arg );
1566       }
1567 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1568          return self->Empty();
1569       }
1570 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){
1571         return self->GetConnectionCount();
1572       }
1573 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 &)){
1574           self->Connect( func );
1575       }
1576 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 &)){
1577           self->Disconnect( func );
1578       }
1579 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){
1580           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1581 /*@SWIG@*/ self->Emit( arg );
1582       }
1583
1584
1585 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){
1586          return self->Empty();
1587       }
1588 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){
1589         return self->GetConnectionCount();
1590       }
1591 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 &)){
1592         self->Connect( func );
1593       }
1594 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 &)){
1595         self->Disconnect( func );
1596       }
1597 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){
1598         return self->Emit( arg1, arg2 );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1601          return self->Empty();
1602       }
1603 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1604         return self->GetConnectionCount();
1605       }
1606 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)){
1607           self->Connect( func );
1608       }
1609 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)){
1610           self->Disconnect( func );
1611       }
1612 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1613           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1614 /*@SWIG@*/ self->Emit( arg );
1615       }
1616 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1617          return self->Empty();
1618       }
1619 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1620         return self->GetConnectionCount();
1621       }
1622 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 &)){
1623           self->Connect( func );
1624       }
1625 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 &)){
1626           self->Disconnect( func );
1627       }
1628 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){
1629           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1630 /*@SWIG@*/ self->Emit( arg );
1631       }
1632 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1633          return self->Empty();
1634       }
1635 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){
1636         return self->GetConnectionCount();
1637       }
1638 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)){
1639         self->Connect( func );
1640       }
1641 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)){
1642         self->Disconnect( func );
1643       }
1644 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){
1645         return self->Emit( arg1, arg2 );
1646       }
1647 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1648          return self->Empty();
1649       }
1650 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){
1651         return self->GetConnectionCount();
1652       }
1653 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)){
1654         self->Connect( func );
1655       }
1656 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)){
1657         self->Disconnect( func );
1658       }
1659 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){
1660         return self->Emit( arg1, arg2 );
1661       }
1662
1663 /* ---------------------------------------------------
1664  * C++ director class methods
1665  * --------------------------------------------------- */
1666
1667 #include "dali_wrap.h"
1668
1669 /*
1670  *  Widget director
1671  */
1672 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1673   swig_init_callbacks();
1674 }
1675
1676 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1677 }
1678
1679 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1680   char * jcontentInfo = 0 ;
1681   void * jwindow  ;
1682
1683   if (!swig_callbackOnCreate) {
1684     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1685     return;
1686   } else {
1687     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1688     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1689     swig_callbackOnCreate(jcontentInfo, jwindow);
1690   }
1691 }
1692
1693 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1694   char * jcontentInfo = 0 ;
1695   int jtype  ;
1696
1697   if (!swig_callbackOnTerminate) {
1698     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1699     return;
1700   } else {
1701     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1702     jtype = (int)type;
1703     swig_callbackOnTerminate(jcontentInfo, jtype);
1704   }
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnPause() {
1708   if (!swig_callbackOnPause) {
1709     Dali::Internal::Adaptor::Widget::OnPause();
1710     return;
1711   } else {
1712     swig_callbackOnPause();
1713   }
1714 }
1715
1716 void SwigDirector_WidgetImpl::OnResume() {
1717   if (!swig_callbackOnResume) {
1718     Dali::Internal::Adaptor::Widget::OnResume();
1719     return;
1720   } else {
1721     swig_callbackOnResume();
1722   }
1723 }
1724
1725 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1726   void * jwindow  ;
1727
1728   if (!swig_callbackOnResize) {
1729     Dali::Internal::Adaptor::Widget::OnResize(window);
1730     return;
1731   } else {
1732     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1733     swig_callbackOnResize(jwindow);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1738   char * jcontentInfo = 0 ;
1739   int jforce  ;
1740
1741   if (!swig_callbackOnUpdate) {
1742     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1743     return;
1744   } else {
1745     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1746     jforce = force;
1747     swig_callbackOnUpdate(jcontentInfo, jforce);
1748   }
1749 }
1750
1751 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1752   void * jslotObserver = 0 ;
1753   void * jcallback = 0 ;
1754
1755   if (!swig_callbackSignalConnected) {
1756     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1757     return;
1758   } else {
1759     jslotObserver = (void *) slotObserver;
1760     jcallback = (void *) callback;
1761     swig_callbackSignalConnected(jslotObserver, jcallback);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1766   void * jslotObserver = 0 ;
1767   void * jcallback = 0 ;
1768
1769   if (!swig_callbackSignalDisconnected) {
1770     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1771     return;
1772   } else {
1773     jslotObserver = (void *) slotObserver;
1774     jcallback = (void *) callback;
1775     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1776   }
1777 }
1778
1779 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) {
1780
1781   swig_callbackOnCreate = callbackOnCreate;
1782   swig_callbackOnTerminate = callbackOnTerminate;
1783   swig_callbackOnPause = callbackOnPause;
1784   swig_callbackOnResume = callbackOnResume;
1785   swig_callbackOnResize = callbackOnResize;
1786   swig_callbackOnUpdate = callbackOnUpdate;
1787   swig_callbackSignalConnected = callbackSignalConnected;
1788   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1789 }
1790
1791 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1792   swig_callbackOnCreate = 0;
1793   swig_callbackOnTerminate = 0;
1794   swig_callbackOnPause = 0;
1795   swig_callbackOnResume = 0;
1796   swig_callbackOnResize = 0;
1797   swig_callbackOnUpdate = 0;
1798   swig_callbackSignalConnected = 0;
1799   swig_callbackSignalDisconnected = 0;
1800 }
1801
1802
1803 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1804   swig_init_callbacks();
1805 }
1806
1807 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1808
1809 }
1810
1811
1812 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1813   int jdepth  ;
1814
1815   if (!swig_callbackOnSceneConnection) {
1816     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1817     return;
1818   } else {
1819     jdepth = depth;
1820     swig_callbackOnSceneConnection(jdepth);
1821   }
1822 }
1823
1824 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1825   if (!swig_callbackOnSceneDisconnection) {
1826     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1827     return;
1828   } else {
1829     swig_callbackOnSceneDisconnection();
1830   }
1831 }
1832
1833 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1834   void * jchild = 0 ;
1835
1836   if (!swig_callbackOnChildAdd) {
1837     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1838     return;
1839   } else {
1840     jchild = (Dali::Actor *) &child;
1841     swig_callbackOnChildAdd(jchild);
1842   }
1843 }
1844
1845 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1846   void * jchild = 0 ;
1847
1848   if (!swig_callbackOnChildRemove) {
1849     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1850     return;
1851   } else {
1852     jchild = (Dali::Actor *) &child;
1853     swig_callbackOnChildRemove(jchild);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1858   int jindex  ;
1859   void * jpropertyValue  ;
1860
1861   if (!swig_callbackOnPropertySet) {
1862     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1863     return;
1864   } else {
1865     jindex = index;
1866     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1867     swig_callbackOnPropertySet(jindex, jpropertyValue);
1868   }
1869 }
1870
1871 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1872   void * jtargetSize = 0 ;
1873
1874   if (!swig_callbackOnSizeSet) {
1875     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1876     return;
1877   } else {
1878     jtargetSize = (Dali::Vector3 *) &targetSize;
1879     swig_callbackOnSizeSet(jtargetSize);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1884   void * janimation = 0 ;
1885   void * jtargetSize = 0 ;
1886
1887   if (!swig_callbackOnSizeAnimation) {
1888     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1889     return;
1890   } else {
1891     janimation = (Dali::Animation *) &animation;
1892     jtargetSize = (Dali::Vector3 *) &targetSize;
1893     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1894   }
1895 }
1896
1897 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1898   bool c_result = SwigValueInit< bool >() ;
1899   unsigned int jresult = 0 ;
1900   void * jarg0 = 0 ;
1901
1902   if (!swig_callbackOnHoverEvent) {
1903     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1904   } else {
1905     jarg0 = (Dali::HoverEvent *) &event;
1906     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1907     c_result = jresult ? true : false;
1908   }
1909   return c_result;
1910 }
1911
1912 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1913   bool c_result = SwigValueInit< bool >() ;
1914   unsigned int jresult = 0 ;
1915   void * jarg0 = 0 ;
1916
1917   if (!swig_callbackOnKeyEvent) {
1918     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1919   } else {
1920     jarg0 = (Dali::KeyEvent *) &event;
1921     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1922     c_result = jresult ? true : false;
1923   }
1924   return c_result;
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnWheelEvent) {
1933     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1934   } else {
1935     jarg0 = (Dali::WheelEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1943   void * jsize = 0 ;
1944   void * jcontainer = 0 ;
1945
1946   if (!swig_callbackOnRelayout) {
1947     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1948     return;
1949   } else {
1950     jsize = (Dali::Vector2 *) &size;
1951     jcontainer = (Dali::RelayoutContainer *) &container;
1952     swig_callbackOnRelayout(jsize, jcontainer);
1953   }
1954 }
1955
1956 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1957   int jpolicy  ;
1958   int jdimension  ;
1959
1960   if (!swig_callbackOnSetResizePolicy) {
1961     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1962     return;
1963   } else {
1964     jpolicy = (int)policy;
1965     jdimension = (int)dimension;
1966     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1967   }
1968 }
1969
1970 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1971   Dali::Vector3 c_result ;
1972   void * jresult = 0 ;
1973
1974   if (!swig_callbackGetNaturalSize) {
1975     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1976   } else {
1977     jresult = (void *) swig_callbackGetNaturalSize();
1978     if (!jresult) {
1979       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1980       return c_result;
1981     }
1982     c_result = *(Dali::Vector3 *)jresult;
1983   }
1984   return c_result;
1985 }
1986
1987 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1988   float c_result = SwigValueInit< float >() ;
1989   float jresult = 0 ;
1990   void * jchild = 0 ;
1991   int jdimension  ;
1992
1993   if (!swig_callbackCalculateChildSize) {
1994     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1995   } else {
1996     jchild = (Dali::Actor *) &child;
1997     jdimension = (int)dimension;
1998     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1999     c_result = (float)jresult;
2000   }
2001   return c_result;
2002 }
2003
2004 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2005   float c_result = SwigValueInit< float >() ;
2006   float jresult = 0 ;
2007   float jwidth  ;
2008
2009   if (!swig_callbackGetHeightForWidth) {
2010     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2011   } else {
2012     jwidth = width;
2013     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2014     c_result = (float)jresult;
2015   }
2016   return c_result;
2017 }
2018
2019 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2020   float c_result = SwigValueInit< float >() ;
2021   float jresult = 0 ;
2022   float jheight  ;
2023
2024   if (!swig_callbackGetWidthForHeight) {
2025     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2026   } else {
2027     jheight = height;
2028     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2029     c_result = (float)jresult;
2030   }
2031   return c_result;
2032 }
2033
2034 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2035   bool c_result = SwigValueInit< bool >() ;
2036   unsigned int jresult = 0 ;
2037   int jdimension  ;
2038
2039   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2040     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2041   } else {
2042     jdimension = (int)dimension;
2043     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2044     c_result = jresult ? true : false;
2045   }
2046   return c_result;
2047 }
2048
2049 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2050   int jdimension  ;
2051
2052   if (!swig_callbackOnCalculateRelayoutSize) {
2053     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2054     return;
2055   } else {
2056     jdimension = (int)dimension;
2057     swig_callbackOnCalculateRelayoutSize(jdimension);
2058   }
2059 }
2060
2061 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2062   float jsize  ;
2063   int jdimension  ;
2064
2065   if (!swig_callbackOnLayoutNegotiated) {
2066     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2067     return;
2068   } else {
2069     jsize = size;
2070     jdimension = (int)dimension;
2071     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2072   }
2073 }
2074
2075 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2076   return Dali::CustomActorImpl::GetExtension();
2077 }
2078
2079 void SwigDirector_ViewImpl::OnInitialize() {
2080   if (!swig_callbackOnInitialize) {
2081     Dali::Toolkit::Internal::Control::OnInitialize();
2082     return;
2083   } else {
2084     swig_callbackOnInitialize();
2085   }
2086 }
2087
2088 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2089   void * jstyleManager  ;
2090   int jchange  ;
2091
2092   if (!swig_callbackOnStyleChange) {
2093     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2094     return;
2095   } else {
2096     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2097     jchange = (int)change;
2098     swig_callbackOnStyleChange(jstyleManager, jchange);
2099   }
2100 }
2101
2102 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2103   bool c_result = SwigValueInit< bool >() ;
2104   unsigned int jresult = 0 ;
2105
2106   if (!swig_callbackOnAccessibilityActivated) {
2107     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2108   } else {
2109     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2110     c_result = jresult ? true : false;
2111   }
2112   return c_result;
2113 }
2114
2115 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2116   bool c_result = SwigValueInit< bool >() ;
2117   unsigned int jresult = 0 ;
2118   void * jgesture  ;
2119
2120   if (!swig_callbackOnAccessibilityPan) {
2121     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2122   } else {
2123     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2124     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2125     c_result = jresult ? true : false;
2126   }
2127   return c_result;
2128 }
2129
2130 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2131   bool c_result = SwigValueInit< bool >() ;
2132   unsigned int jresult = 0 ;
2133   unsigned int jisIncrease  ;
2134
2135   if (!swig_callbackOnAccessibilityValueChange) {
2136     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2137   } else {
2138     jisIncrease = isIncrease;
2139     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2140     c_result = jresult ? true : false;
2141   }
2142   return c_result;
2143 }
2144
2145 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2146   bool c_result = SwigValueInit< bool >() ;
2147   unsigned int jresult = 0 ;
2148
2149   if (!swig_callbackOnAccessibilityZoom) {
2150     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2151   } else {
2152     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2153     c_result = jresult ? true : false;
2154   }
2155   return c_result;
2156 }
2157
2158 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2159   if (!swig_callbackOnKeyInputFocusGained) {
2160     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2161     return;
2162   } else {
2163     swig_callbackOnKeyInputFocusGained();
2164   }
2165 }
2166
2167 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2168   if (!swig_callbackOnKeyInputFocusLost) {
2169     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2170     return;
2171   } else {
2172     swig_callbackOnKeyInputFocusLost();
2173   }
2174 }
2175
2176 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2177   Dali::Actor c_result ;
2178   void * jresult = 0 ;
2179   void * jcurrentFocusedActor  ;
2180   int jdirection  ;
2181   unsigned int jloopEnabled  ;
2182
2183   if (!swig_callbackGetNextKeyboardFocusableActor) {
2184     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2185   } else {
2186     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2187     jdirection = (int)direction;
2188     jloopEnabled = loopEnabled;
2189     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2190     if (!jresult) {
2191       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2192       return c_result;
2193     }
2194     c_result = *(Dali::Actor *)jresult;
2195   }
2196   return c_result;
2197 }
2198
2199 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2200   void * jcommitedFocusableActor  ;
2201
2202   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2203     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2204     return;
2205   } else {
2206     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2207     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2208   }
2209 }
2210
2211 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2212   bool c_result = SwigValueInit< bool >() ;
2213   unsigned int jresult = 0 ;
2214
2215   if (!swig_callbackOnKeyboardEnter) {
2216     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2217   } else {
2218     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2219     c_result = jresult ? true : false;
2220   }
2221   return c_result;
2222 }
2223
2224 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2225   void * jpinch = 0 ;
2226
2227   if (!swig_callbackOnPinch) {
2228     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2229     return;
2230   } else {
2231     jpinch = (Dali::PinchGesture *) &pinch;
2232     swig_callbackOnPinch(jpinch);
2233   }
2234 }
2235
2236 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2237   void * jpan = 0 ;
2238
2239   if (!swig_callbackOnPan) {
2240     Dali::Toolkit::Internal::Control::OnPan(pan);
2241     return;
2242   } else {
2243     jpan = (Dali::PanGesture *) &pan;
2244     swig_callbackOnPan(jpan);
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2249   void * jtap = 0 ;
2250
2251   if (!swig_callbackOnTap) {
2252     Dali::Toolkit::Internal::Control::OnTap(tap);
2253     return;
2254   } else {
2255     jtap = (Dali::TapGesture *) &tap;
2256     swig_callbackOnTap(jtap);
2257   }
2258 }
2259
2260 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2261   void * jlongPress = 0 ;
2262
2263   if (!swig_callbackOnLongPress) {
2264     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2265     return;
2266   } else {
2267     jlongPress = (Dali::LongPressGesture *) &longPress;
2268     swig_callbackOnLongPress(jlongPress);
2269   }
2270 }
2271
2272 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2273   void * jslotObserver = 0 ;
2274   void * jcallback = 0 ;
2275
2276   if (!swig_callbackSignalConnected) {
2277     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2278     return;
2279   } else {
2280     jslotObserver = (void *) slotObserver;
2281     jcallback = (void *) callback;
2282     swig_callbackSignalConnected(jslotObserver, jcallback);
2283   }
2284 }
2285
2286 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2287   void * jslotObserver = 0 ;
2288   void * jcallback = 0 ;
2289
2290   if (!swig_callbackSignalDisconnected) {
2291     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2292     return;
2293   } else {
2294     jslotObserver = (void *) slotObserver;
2295     jcallback = (void *) callback;
2296     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2297   }
2298 }
2299
2300 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2301   return Dali::Toolkit::Internal::Control::GetControlExtension();
2302 }
2303
2304 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2305   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2306   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2307   swig_callbackOnChildAdd = callbackOnChildAdd;
2308   swig_callbackOnChildRemove = callbackOnChildRemove;
2309   swig_callbackOnPropertySet = callbackOnPropertySet;
2310   swig_callbackOnSizeSet = callbackOnSizeSet;
2311   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2312   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2313   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2314   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2315   swig_callbackOnRelayout = callbackOnRelayout;
2316   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2317   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2318   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2319   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2320   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2321   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2322   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2323   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2324   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2325   swig_callbackOnInitialize = callbackOnInitialize;
2326   swig_callbackOnStyleChange = callbackOnStyleChange;
2327   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2328   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2329   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2330   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2331   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2332   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2333   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2334   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2335   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2336   swig_callbackOnPinch = callbackOnPinch;
2337   swig_callbackOnPan = callbackOnPan;
2338   swig_callbackOnTap = callbackOnTap;
2339   swig_callbackOnLongPress = callbackOnLongPress;
2340   swig_callbackSignalConnected = callbackSignalConnected;
2341   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2342 }
2343
2344 void SwigDirector_ViewImpl::swig_init_callbacks() {
2345   swig_callbackOnSceneConnection = 0;
2346   swig_callbackOnSceneDisconnection = 0;
2347   swig_callbackOnChildAdd = 0;
2348   swig_callbackOnChildRemove = 0;
2349   swig_callbackOnPropertySet = 0;
2350   swig_callbackOnSizeSet = 0;
2351   swig_callbackOnSizeAnimation = 0;
2352   swig_callbackOnHoverEvent = 0;
2353   swig_callbackOnKeyEvent = 0;
2354   swig_callbackOnWheelEvent = 0;
2355   swig_callbackOnRelayout = 0;
2356   swig_callbackOnSetResizePolicy = 0;
2357   swig_callbackGetNaturalSize = 0;
2358   swig_callbackCalculateChildSize = 0;
2359   swig_callbackGetHeightForWidth = 0;
2360   swig_callbackGetWidthForHeight = 0;
2361   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2362   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2363   swig_callbackOnCalculateRelayoutSize = 0;
2364   swig_callbackOnLayoutNegotiated = 0;
2365   swig_callbackOnInitialize = 0;
2366   swig_callbackOnStyleChange = 0;
2367   swig_callbackOnAccessibilityActivated = 0;
2368   swig_callbackOnAccessibilityPan = 0;
2369   swig_callbackOnAccessibilityValueChange = 0;
2370   swig_callbackOnAccessibilityZoom = 0;
2371   swig_callbackOnKeyInputFocusGained = 0;
2372   swig_callbackOnKeyInputFocusLost = 0;
2373   swig_callbackGetNextKeyboardFocusableActor = 0;
2374   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2375   swig_callbackOnKeyboardEnter = 0;
2376   swig_callbackOnPinch = 0;
2377   swig_callbackOnPan = 0;
2378   swig_callbackOnTap = 0;
2379   swig_callbackOnLongPress = 0;
2380   swig_callbackSignalConnected = 0;
2381   swig_callbackSignalDisconnected = 0;
2382 }
2383
2384 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2385   swig_init_callbacks();
2386 }
2387
2388 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2389
2390 }
2391
2392
2393 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2394   unsigned int c_result = SwigValueInit< unsigned int >() ;
2395   unsigned int jresult = 0 ;
2396
2397   if (!swig_callbackGetNumberOfItems) {
2398     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2399   } else {
2400     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2401     c_result = (unsigned int)jresult;
2402   }
2403   return c_result;
2404 }
2405
2406 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2407   Dali::Actor c_result ;
2408   void * jresult = 0 ;
2409   unsigned int jitemId  ;
2410
2411   if (!swig_callbackNewItem) {
2412     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2413   } else {
2414     jitemId = itemId;
2415     jresult = (void *) swig_callbackNewItem(jitemId);
2416     if (!jresult) {
2417       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2418       return c_result;
2419     }
2420     c_result = *(Dali::Actor *)jresult;
2421   }
2422   return c_result;
2423 }
2424
2425 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2426   unsigned int jitemId  ;
2427   void * jactor  ;
2428
2429   if (!swig_callbackItemReleased) {
2430     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2431     return;
2432   } else {
2433     jitemId = itemId;
2434     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2435     swig_callbackItemReleased(jitemId, jactor);
2436   }
2437 }
2438
2439 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2440   return Dali::Toolkit::ItemFactory::GetExtension();
2441 }
2442
2443 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2444   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2445   swig_callbackNewItem = callbackNewItem;
2446   swig_callbackItemReleased = callbackItemReleased;
2447 }
2448
2449 void SwigDirector_ItemFactory::swig_init_callbacks() {
2450   swig_callbackGetNumberOfItems = 0;
2451   swig_callbackNewItem = 0;
2452   swig_callbackItemReleased = 0;
2453 }
2454
2455 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2456   swig_init_callbacks();
2457 }
2458
2459 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2460
2461 }
2462
2463
2464 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2465   Dali::Actor c_result ;
2466   void * jresult = 0 ;
2467   void * jcurrent  ;
2468   void * jproposed  ;
2469   int jdirection  ;
2470
2471   if (!swig_callbackGetNextFocusableActor) {
2472     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2473   } else {
2474     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2475     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2476     jdirection = (int)direction;
2477     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2478     if (!jresult) {
2479       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__);
2480       return c_result;
2481     }
2482     c_result = *(Dali::Actor *)jresult;
2483   }
2484   return c_result;
2485 }
2486
2487 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2488   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2489 }
2490
2491 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2492   swig_callbackGetNextFocusableActor = 0;
2493 }
2494
2495 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2496   swig_callbackOnUpdate = 0;
2497 }
2498
2499 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2500
2501 }
2502
2503 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2504   swig_callbackOnUpdate = callbackUpdate;
2505 }
2506
2507
2508 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2509   void * jcurrent  ;
2510
2511   if (!swig_callbackOnUpdate) {
2512     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2513   } else {
2514     Dali::UpdateProxy* proxy = &updateProxy;
2515     jcurrent = (void *)proxy;
2516     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2517     if (!jcurrent) {
2518       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2519       return;
2520     }
2521   }
2522   return;
2523 }
2524
2525
2526 #ifdef __cplusplus
2527 extern "C" {
2528 #endif
2529
2530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2531   void * jresult ;
2532   floatp *result = 0 ;
2533
2534   {
2535     try {
2536       result = (floatp *)new_floatp();
2537     } CALL_CATCH_EXCEPTION(0);
2538   }
2539   jresult = (void *)result;
2540   return jresult;
2541 }
2542
2543
2544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2545   floatp *arg1 = (floatp *) 0 ;
2546
2547   arg1 = (floatp *)jarg1;
2548   {
2549     try {
2550       delete_floatp(arg1);
2551     } CALL_CATCH_EXCEPTION();
2552   }
2553
2554 }
2555
2556
2557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2558   floatp *arg1 = (floatp *) 0 ;
2559   float arg2 ;
2560
2561   arg1 = (floatp *)jarg1;
2562   arg2 = (float)jarg2;
2563   {
2564     try {
2565       floatp_assign(arg1,arg2);
2566     } CALL_CATCH_EXCEPTION();
2567   }
2568
2569 }
2570
2571
2572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2573   float jresult ;
2574   floatp *arg1 = (floatp *) 0 ;
2575   float result;
2576
2577   arg1 = (floatp *)jarg1;
2578   {
2579     try {
2580       result = (float)floatp_value(arg1);
2581     } CALL_CATCH_EXCEPTION(0);
2582   }
2583   jresult = result;
2584   return jresult;
2585 }
2586
2587
2588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2589   void * jresult ;
2590   floatp *arg1 = (floatp *) 0 ;
2591   float *result = 0 ;
2592
2593   arg1 = (floatp *)jarg1;
2594   {
2595     try {
2596       result = (float *)floatp_cast(arg1);
2597     } CALL_CATCH_EXCEPTION(0);
2598   }
2599
2600   jresult = (void *)result;
2601   return jresult;
2602 }
2603
2604
2605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2606   void * jresult ;
2607   float *arg1 = (float *) 0 ;
2608   floatp *result = 0 ;
2609
2610   arg1 = (float *)jarg1;
2611   {
2612     try {
2613       result = (floatp *)floatp_frompointer(arg1);
2614     } CALL_CATCH_EXCEPTION(0);
2615   }
2616
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2623   void * jresult ;
2624   intp *result = 0 ;
2625
2626   {
2627     try {
2628       result = (intp *)new_intp();
2629     } CALL_CATCH_EXCEPTION(0);
2630   }
2631
2632   jresult = (void *)result;
2633   return jresult;
2634 }
2635
2636
2637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2638   intp *arg1 = (intp *) 0 ;
2639
2640   arg1 = (intp *)jarg1;
2641   {
2642     try {
2643       delete_intp(arg1);
2644     } CALL_CATCH_EXCEPTION();
2645   }
2646
2647 }
2648
2649
2650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2651   intp *arg1 = (intp *) 0 ;
2652   int arg2 ;
2653
2654   arg1 = (intp *)jarg1;
2655   arg2 = (int)jarg2;
2656   {
2657     try {
2658       intp_assign(arg1,arg2);
2659     } CALL_CATCH_EXCEPTION();
2660   }
2661
2662 }
2663
2664
2665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2666   int jresult ;
2667   intp *arg1 = (intp *) 0 ;
2668   int result;
2669
2670   arg1 = (intp *)jarg1;
2671   {
2672     try {
2673       result = (int)intp_value(arg1);
2674     } CALL_CATCH_EXCEPTION(0);
2675   }
2676
2677   jresult = result;
2678   return jresult;
2679 }
2680
2681
2682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2683   void * jresult ;
2684   intp *arg1 = (intp *) 0 ;
2685   int *result = 0 ;
2686
2687   arg1 = (intp *)jarg1;
2688   {
2689     try {
2690       result = (int *)intp_cast(arg1);
2691     } CALL_CATCH_EXCEPTION(0);
2692   }
2693
2694   jresult = (void *)result;
2695   return jresult;
2696 }
2697
2698
2699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2700   void * jresult ;
2701   int *arg1 = (int *) 0 ;
2702   intp *result = 0 ;
2703
2704   arg1 = (int *)jarg1;
2705   {
2706     try {
2707       result = (intp *)intp_frompointer(arg1);
2708     } CALL_CATCH_EXCEPTION(0);
2709   }
2710
2711   jresult = (void *)result;
2712   return jresult;
2713 }
2714
2715
2716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2717   void * jresult ;
2718   doublep *result = 0 ;
2719
2720   {
2721     try {
2722       result = (doublep *)new_doublep();
2723     } CALL_CATCH_EXCEPTION(0);
2724   }
2725
2726   jresult = (void *)result;
2727   return jresult;
2728 }
2729
2730
2731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2732   doublep *arg1 = (doublep *) 0 ;
2733
2734   arg1 = (doublep *)jarg1;
2735   {
2736     try {
2737       delete_doublep(arg1);
2738     } CALL_CATCH_EXCEPTION();
2739   }
2740
2741 }
2742
2743
2744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2745   doublep *arg1 = (doublep *) 0 ;
2746   double arg2 ;
2747
2748   arg1 = (doublep *)jarg1;
2749   arg2 = (double)jarg2;
2750   {
2751     try {
2752       doublep_assign(arg1,arg2);
2753     } CALL_CATCH_EXCEPTION();
2754   }
2755
2756 }
2757
2758
2759 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2760   double jresult ;
2761   doublep *arg1 = (doublep *) 0 ;
2762   double result;
2763
2764   arg1 = (doublep *)jarg1;
2765   {
2766     try {
2767       result = (double)doublep_value(arg1);
2768     } CALL_CATCH_EXCEPTION(0);
2769   }
2770
2771   jresult = result;
2772   return jresult;
2773 }
2774
2775
2776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2777   void * jresult ;
2778   doublep *arg1 = (doublep *) 0 ;
2779   double *result = 0 ;
2780
2781   arg1 = (doublep *)jarg1;
2782   {
2783     try {
2784       result = (double *)doublep_cast(arg1);
2785     } CALL_CATCH_EXCEPTION(0);
2786   }
2787
2788   jresult = (void *)result;
2789   return jresult;
2790 }
2791
2792
2793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2794   void * jresult ;
2795   double *arg1 = (double *) 0 ;
2796   doublep *result = 0 ;
2797
2798   arg1 = (double *)jarg1;
2799   {
2800     try {
2801       result = (doublep *)doublep_frompointer(arg1);
2802     } CALL_CATCH_EXCEPTION(0);
2803   }
2804
2805   jresult = (void *)result;
2806   return jresult;
2807 }
2808
2809
2810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2811   void * jresult ;
2812   uintp *result = 0 ;
2813
2814   {
2815     try {
2816       result = (uintp *)new_uintp();
2817     } CALL_CATCH_EXCEPTION(0);
2818   }
2819
2820   jresult = (void *)result;
2821   return jresult;
2822 }
2823
2824
2825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2826   uintp *arg1 = (uintp *) 0 ;
2827
2828   arg1 = (uintp *)jarg1;
2829   {
2830     try {
2831       delete_uintp(arg1);
2832     } CALL_CATCH_EXCEPTION();
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2839   uintp *arg1 = (uintp *) 0 ;
2840   unsigned int arg2 ;
2841
2842   arg1 = (uintp *)jarg1;
2843   arg2 = (unsigned int)jarg2;
2844   {
2845     try {
2846       uintp_assign(arg1,arg2);
2847     } CALL_CATCH_EXCEPTION();
2848   }
2849
2850 }
2851
2852
2853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2854   unsigned int jresult ;
2855   uintp *arg1 = (uintp *) 0 ;
2856   unsigned int result;
2857
2858   arg1 = (uintp *)jarg1;
2859   {
2860     try {
2861       result = (unsigned int)uintp_value(arg1);
2862     } CALL_CATCH_EXCEPTION(0);
2863   }
2864
2865   jresult = result;
2866   return jresult;
2867 }
2868
2869
2870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2871   void * jresult ;
2872   uintp *arg1 = (uintp *) 0 ;
2873   unsigned int *result = 0 ;
2874
2875   arg1 = (uintp *)jarg1;
2876   {
2877     try {
2878       result = (unsigned int *)uintp_cast(arg1);
2879     } CALL_CATCH_EXCEPTION(0);
2880   }
2881
2882   jresult = (void *)result;
2883   return jresult;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2888   void * jresult ;
2889   unsigned int *arg1 = (unsigned int *) 0 ;
2890   uintp *result = 0 ;
2891
2892   arg1 = (unsigned int *)jarg1;
2893   {
2894     try {
2895       result = (uintp *)uintp_frompointer(arg1);
2896     } CALL_CATCH_EXCEPTION(0);
2897   }
2898
2899   jresult = (void *)result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2905   void * jresult ;
2906   ushortp *result = 0 ;
2907
2908   {
2909     try {
2910       result = (ushortp *)new_ushortp();
2911     } CALL_CATCH_EXCEPTION(0);
2912   }
2913
2914   jresult = (void *)result;
2915   return jresult;
2916 }
2917
2918
2919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2920   ushortp *arg1 = (ushortp *) 0 ;
2921
2922   arg1 = (ushortp *)jarg1;
2923   {
2924     try {
2925       delete_ushortp(arg1);
2926     } CALL_CATCH_EXCEPTION();
2927   }
2928
2929 }
2930
2931
2932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2933   ushortp *arg1 = (ushortp *) 0 ;
2934   unsigned short arg2 ;
2935
2936   arg1 = (ushortp *)jarg1;
2937   arg2 = (unsigned short)jarg2;
2938   {
2939     try {
2940       ushortp_assign(arg1,arg2);
2941     } CALL_CATCH_EXCEPTION();
2942   }
2943
2944 }
2945
2946
2947 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2948   unsigned short jresult ;
2949   ushortp *arg1 = (ushortp *) 0 ;
2950   unsigned short result;
2951
2952   arg1 = (ushortp *)jarg1;
2953   {
2954     try {
2955       result = (unsigned short)ushortp_value(arg1);
2956     } CALL_CATCH_EXCEPTION(0);
2957   }
2958
2959   jresult = result;
2960   return jresult;
2961 }
2962
2963
2964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2965   void * jresult ;
2966   ushortp *arg1 = (ushortp *) 0 ;
2967   unsigned short *result = 0 ;
2968
2969   arg1 = (ushortp *)jarg1;
2970   {
2971     try {
2972       result = (unsigned short *)ushortp_cast(arg1);
2973     } CALL_CATCH_EXCEPTION(0);
2974   }
2975
2976   jresult = (void *)result;
2977   return jresult;
2978 }
2979
2980
2981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2982   void * jresult ;
2983   unsigned short *arg1 = (unsigned short *) 0 ;
2984   ushortp *result = 0 ;
2985
2986   arg1 = (unsigned short *)jarg1;
2987   {
2988     try {
2989       result = (ushortp *)ushortp_frompointer(arg1);
2990     } CALL_CATCH_EXCEPTION(0);
2991   }
2992
2993   jresult = (void *)result;
2994   return jresult;
2995 }
2996
2997
2998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2999   unsigned int jresult ;
3000   int arg1 ;
3001   unsigned int result;
3002
3003   arg1 = (int)jarg1;
3004   {
3005     try {
3006       result = (unsigned int)int_to_uint(arg1);
3007     } CALL_CATCH_EXCEPTION(0);
3008   }
3009
3010   jresult = result;
3011   return jresult;
3012 }
3013
3014
3015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3016   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3017
3018   arg1 = (Dali::RefObject *)jarg1;
3019   {
3020     try {
3021       (arg1)->Reference();
3022     } CALL_CATCH_EXCEPTION();
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3029   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3030
3031   arg1 = (Dali::RefObject *)jarg1;
3032   {
3033     try {
3034       (arg1)->Unreference();
3035     } CALL_CATCH_EXCEPTION();
3036   }
3037
3038 }
3039
3040
3041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3042   int jresult ;
3043   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3044   int result;
3045
3046   arg1 = (Dali::RefObject *)jarg1;
3047   {
3048     try {
3049       result = (int)(arg1)->ReferenceCount();
3050     } CALL_CATCH_EXCEPTION(0);
3051   }
3052
3053   jresult = result;
3054   return jresult;
3055 }
3056
3057
3058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3059   void * jresult ;
3060   Dali::Any *result = 0 ;
3061
3062   {
3063     try {
3064       result = (Dali::Any *)new Dali::Any();
3065     } CALL_CATCH_EXCEPTION(0);
3066   }
3067
3068   jresult = (void *)result;
3069   return jresult;
3070 }
3071
3072
3073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3074   Dali::Any *arg1 = (Dali::Any *) 0 ;
3075
3076   arg1 = (Dali::Any *)jarg1;
3077   {
3078     try {
3079       delete arg1;
3080     } CALL_CATCH_EXCEPTION();
3081   }
3082
3083 }
3084
3085
3086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3087   char *arg1 = (char *) 0 ;
3088
3089   arg1 = (char *)jarg1;
3090   {
3091     try {
3092       Dali::Any::AssertAlways((char const *)arg1);
3093     } CALL_CATCH_EXCEPTION();
3094   }
3095
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3100   void * jresult ;
3101   Dali::Any *arg1 = 0 ;
3102   Dali::Any *result = 0 ;
3103
3104   arg1 = (Dali::Any *)jarg1;
3105   if (!arg1) {
3106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3107     return 0;
3108   }
3109   {
3110     try {
3111       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3112     } CALL_CATCH_EXCEPTION(0);
3113   }
3114
3115   jresult = (void *)result;
3116   return jresult;
3117 }
3118
3119
3120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3121   void * jresult ;
3122   Dali::Any *arg1 = (Dali::Any *) 0 ;
3123   Dali::Any *arg2 = 0 ;
3124   Dali::Any *result = 0 ;
3125
3126   arg1 = (Dali::Any *)jarg1;
3127   arg2 = (Dali::Any *)jarg2;
3128   if (!arg2) {
3129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3130     return 0;
3131   }
3132   {
3133     try {
3134       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3135     } CALL_CATCH_EXCEPTION(0);
3136   }
3137
3138   jresult = (void *)result;
3139   return jresult;
3140 }
3141
3142
3143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3144   void * jresult ;
3145   Dali::Any *arg1 = (Dali::Any *) 0 ;
3146   std::type_info *result = 0 ;
3147
3148   arg1 = (Dali::Any *)jarg1;
3149   {
3150     try {
3151       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3152     } CALL_CATCH_EXCEPTION(0);
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3161   unsigned int jresult ;
3162   Dali::Any *arg1 = (Dali::Any *) 0 ;
3163   bool result;
3164
3165   arg1 = (Dali::Any *)jarg1;
3166   {
3167     try {
3168       result = (bool)((Dali::Any const *)arg1)->Empty();
3169     } CALL_CATCH_EXCEPTION(0);
3170   }
3171
3172   jresult = result;
3173   return jresult;
3174 }
3175
3176
3177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3178   void * jresult ;
3179   std::type_info *arg1 = 0 ;
3180   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3181   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3182   Dali::Any::AnyContainerBase *result = 0 ;
3183
3184   arg1 = (std::type_info *)jarg1;
3185   if (!arg1) {
3186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3187     return 0;
3188   }
3189   arg2 = (Dali::Any::CloneFunc)jarg2;
3190   arg3 = (Dali::Any::DeleteFunc)jarg3;
3191   {
3192     try {
3193       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3194     } CALL_CATCH_EXCEPTION(0);
3195   }
3196
3197   jresult = (void *)result;
3198   return jresult;
3199 }
3200
3201
3202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3203   void * jresult ;
3204   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3205   std::type_info *result = 0 ;
3206
3207   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3208   {
3209     try {
3210       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3211     } CALL_CATCH_EXCEPTION(0);
3212   }
3213
3214   jresult = (void *)result;
3215   return jresult;
3216 }
3217
3218
3219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3220   void * jresult ;
3221   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3222   ::std::type_info *result = 0 ;
3223
3224   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3225   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3226   jresult = (void *)result;
3227   return jresult;
3228 }
3229
3230
3231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3232   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3233   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3234
3235   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3236   arg2 = (Dali::Any::CloneFunc)jarg2;
3237   if (arg1) (arg1)->mCloneFunc = arg2;
3238 }
3239
3240
3241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3242   void * jresult ;
3243   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3244   Dali::Any::CloneFunc result;
3245
3246   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3247   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3248   jresult = (void *)result;
3249   return jresult;
3250 }
3251
3252
3253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3254   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3255   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3256
3257   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3258   arg2 = (Dali::Any::DeleteFunc)jarg2;
3259   if (arg1) (arg1)->mDeleteFunc = arg2;
3260 }
3261
3262
3263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3264   void * jresult ;
3265   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3266   Dali::Any::DeleteFunc result;
3267
3268   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3269   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3270   jresult = (void *)result;
3271   return jresult;
3272 }
3273
3274
3275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3276   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3277
3278   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3279   {
3280     try {
3281       delete arg1;
3282     } CALL_CATCH_EXCEPTION();
3283   }
3284
3285 }
3286
3287
3288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3289   Dali::Any *arg1 = (Dali::Any *) 0 ;
3290   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3291
3292   arg1 = (Dali::Any *)jarg1;
3293   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3294   if (arg1) (arg1)->mContainer = arg2;
3295 }
3296
3297
3298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3299   void * jresult ;
3300   Dali::Any *arg1 = (Dali::Any *) 0 ;
3301   Dali::Any::AnyContainerBase *result = 0 ;
3302
3303   arg1 = (Dali::Any *)jarg1;
3304   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3305   jresult = (void *)result;
3306   return jresult;
3307 }
3308
3309
3310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3311   char *arg1 = (char *) 0 ;
3312   char *arg2 = (char *) 0 ;
3313
3314   arg1 = (char *)jarg1;
3315   arg2 = (char *)jarg2;
3316   {
3317     try {
3318       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3319     } CALL_CATCH_EXCEPTION();
3320   }
3321
3322 }
3323
3324
3325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3326   void * jresult ;
3327   char *arg1 = (char *) 0 ;
3328   char *arg2 = (char *) 0 ;
3329   Dali::DaliException *result = 0 ;
3330
3331   arg1 = (char *)jarg1;
3332   arg2 = (char *)jarg2;
3333   {
3334     try {
3335       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3336     } CALL_CATCH_EXCEPTION(0);
3337   }
3338
3339   jresult = (void *)result;
3340   return jresult;
3341 }
3342
3343
3344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3345   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3346   std::string arg2 = std::string(jarg2);
3347
3348   arg1 = (Dali::DaliException *)jarg1;
3349   {
3350     if (!arg2.empty()) {
3351       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3352     } else {
3353       arg1->location = 0;
3354     }
3355   }
3356 }
3357
3358 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3359   char * jresult ;
3360   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3361   char *result = 0 ;
3362
3363   arg1 = (Dali::DaliException *)jarg1;
3364   result = (char *) ((arg1)->location);
3365   jresult = SWIG_csharp_string_callback((const char *)result);
3366   return jresult;
3367 }
3368
3369
3370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3371   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3372   std::string arg2 = std::string(jarg2);
3373
3374   arg1 = (Dali::DaliException *)jarg1;
3375   {
3376     if (!arg2.empty()) {
3377       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3378     } else {
3379       arg1->condition = 0;
3380     }
3381   }
3382 }
3383
3384
3385 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3386   char * jresult ;
3387   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3388   char *result = 0 ;
3389
3390   arg1 = (Dali::DaliException *)jarg1;
3391   result = (char *) ((arg1)->condition);
3392   jresult = SWIG_csharp_string_callback((const char *)result);
3393   return jresult;
3394 }
3395
3396
3397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3398   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3399
3400   arg1 = (Dali::DaliException *)jarg1;
3401   {
3402     try {
3403       delete arg1;
3404     } CALL_CATCH_EXCEPTION();
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3411   void * jresult ;
3412   Dali::Vector2 *result = 0 ;
3413
3414   {
3415     try {
3416       result = (Dali::Vector2 *)new Dali::Vector2();
3417     } CALL_CATCH_EXCEPTION(0);
3418   }
3419
3420   jresult = (void *)result;
3421   return jresult;
3422 }
3423
3424
3425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3426   void * jresult ;
3427   float arg1 ;
3428   float arg2 ;
3429   Dali::Vector2 *result = 0 ;
3430
3431   arg1 = (float)jarg1;
3432   arg2 = (float)jarg2;
3433   {
3434     try {
3435       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3436     } CALL_CATCH_EXCEPTION(0);
3437   }
3438
3439   jresult = (void *)result;
3440   return jresult;
3441 }
3442
3443
3444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3445   void * jresult ;
3446   float *arg1 = (float *) 0 ;
3447   Dali::Vector2 *result = 0 ;
3448
3449   arg1 = jarg1;
3450   {
3451     try {
3452       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3453     } CALL_CATCH_EXCEPTION(0);
3454   }
3455
3456   jresult = (void *)result;
3457
3458
3459   return jresult;
3460 }
3461
3462
3463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3464   void * jresult ;
3465   Dali::Vector3 *arg1 = 0 ;
3466   Dali::Vector2 *result = 0 ;
3467
3468   arg1 = (Dali::Vector3 *)jarg1;
3469   if (!arg1) {
3470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3471     return 0;
3472   }
3473   {
3474     try {
3475       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3476     } CALL_CATCH_EXCEPTION(0);
3477   }
3478
3479   jresult = (void *)result;
3480   return jresult;
3481 }
3482
3483
3484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3485   void * jresult ;
3486   Dali::Vector4 *arg1 = 0 ;
3487   Dali::Vector2 *result = 0 ;
3488
3489   arg1 = (Dali::Vector4 *)jarg1;
3490   if (!arg1) {
3491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3492     return 0;
3493   }
3494   {
3495     try {
3496       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3497     } CALL_CATCH_EXCEPTION(0);
3498   }
3499
3500   jresult = (void *)result;
3501   return jresult;
3502 }
3503
3504
3505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3506   void * jresult ;
3507   Dali::Vector2 *result = 0 ;
3508
3509   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3510   jresult = (void *)result;
3511   return jresult;
3512 }
3513
3514
3515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3516   void * jresult ;
3517   Dali::Vector2 *result = 0 ;
3518
3519   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3520   jresult = (void *)result;
3521   return jresult;
3522 }
3523
3524
3525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3526   void * jresult ;
3527   Dali::Vector2 *result = 0 ;
3528
3529   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3530   jresult = (void *)result;
3531   return jresult;
3532 }
3533
3534
3535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3536   void * jresult ;
3537   Dali::Vector2 *result = 0 ;
3538
3539   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3540   jresult = (void *)result;
3541   return jresult;
3542 }
3543
3544
3545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3546   void * jresult ;
3547   Dali::Vector2 *result = 0 ;
3548
3549   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3556   void * jresult ;
3557   Dali::Vector2 *result = 0 ;
3558
3559   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3560   jresult = (void *)result;
3561   return jresult;
3562 }
3563
3564
3565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3566   void * jresult ;
3567   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3568   float *arg2 = (float *) 0 ;
3569   Dali::Vector2 *result = 0 ;
3570
3571   arg1 = (Dali::Vector2 *)jarg1;
3572   arg2 = jarg2;
3573   {
3574     try {
3575       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3576     } CALL_CATCH_EXCEPTION(0);
3577   }
3578
3579   jresult = (void *)result;
3580
3581
3582   return jresult;
3583 }
3584
3585
3586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3587   void * jresult ;
3588   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3589   Dali::Vector3 *arg2 = 0 ;
3590   Dali::Vector2 *result = 0 ;
3591
3592   arg1 = (Dali::Vector2 *)jarg1;
3593   arg2 = (Dali::Vector3 *)jarg2;
3594   if (!arg2) {
3595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3596     return 0;
3597   }
3598   {
3599     try {
3600       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3601     } CALL_CATCH_EXCEPTION(0);
3602   }
3603
3604   jresult = (void *)result;
3605   return jresult;
3606 }
3607
3608
3609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3610   void * jresult ;
3611   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3612   Dali::Vector4 *arg2 = 0 ;
3613   Dali::Vector2 *result = 0 ;
3614
3615   arg1 = (Dali::Vector2 *)jarg1;
3616   arg2 = (Dali::Vector4 *)jarg2;
3617   if (!arg2) {
3618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3619     return 0;
3620   }
3621   {
3622     try {
3623       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3624     } CALL_CATCH_EXCEPTION(0);
3625   }
3626
3627   jresult = (void *)result;
3628   return jresult;
3629 }
3630
3631
3632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3633   void * jresult ;
3634   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3635   Dali::Vector2 *arg2 = 0 ;
3636   Dali::Vector2 result;
3637
3638   arg1 = (Dali::Vector2 *)jarg1;
3639   arg2 = (Dali::Vector2 *)jarg2;
3640   if (!arg2) {
3641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3642     return 0;
3643   }
3644   {
3645     try {
3646       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3647     } CALL_CATCH_EXCEPTION(0);
3648   }
3649
3650   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3651   return jresult;
3652 }
3653
3654
3655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3656   void * jresult ;
3657   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3658   Dali::Vector2 *arg2 = 0 ;
3659   Dali::Vector2 *result = 0 ;
3660
3661   arg1 = (Dali::Vector2 *)jarg1;
3662   arg2 = (Dali::Vector2 *)jarg2;
3663   if (!arg2) {
3664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3665     return 0;
3666   }
3667   {
3668     try {
3669       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3670     } CALL_CATCH_EXCEPTION(0);
3671   }
3672
3673   jresult = (void *)result;
3674   return jresult;
3675 }
3676
3677
3678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3679   void * jresult ;
3680   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3681   Dali::Vector2 *arg2 = 0 ;
3682   Dali::Vector2 result;
3683
3684   arg1 = (Dali::Vector2 *)jarg1;
3685   arg2 = (Dali::Vector2 *)jarg2;
3686   if (!arg2) {
3687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3688     return 0;
3689   }
3690   {
3691     try {
3692       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3693     } CALL_CATCH_EXCEPTION(0);
3694   }
3695
3696   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3697   return jresult;
3698 }
3699
3700
3701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3702   void * jresult ;
3703   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3704   Dali::Vector2 *arg2 = 0 ;
3705   Dali::Vector2 *result = 0 ;
3706
3707   arg1 = (Dali::Vector2 *)jarg1;
3708   arg2 = (Dali::Vector2 *)jarg2;
3709   if (!arg2) {
3710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3711     return 0;
3712   }
3713   {
3714     try {
3715       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3716     } CALL_CATCH_EXCEPTION(0);
3717   }
3718
3719   jresult = (void *)result;
3720   return jresult;
3721 }
3722
3723
3724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3725   void * jresult ;
3726   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3727   Dali::Vector2 *arg2 = 0 ;
3728   Dali::Vector2 result;
3729
3730   arg1 = (Dali::Vector2 *)jarg1;
3731   arg2 = (Dali::Vector2 *)jarg2;
3732   if (!arg2) {
3733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3734     return 0;
3735   }
3736   {
3737     try {
3738       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3739     } CALL_CATCH_EXCEPTION(0);
3740   }
3741
3742   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3743   return jresult;
3744 }
3745
3746
3747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3748   void * jresult ;
3749   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3750   float arg2 ;
3751   Dali::Vector2 result;
3752
3753   arg1 = (Dali::Vector2 *)jarg1;
3754   arg2 = (float)jarg2;
3755   {
3756     try {
3757       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3758     } CALL_CATCH_EXCEPTION(0);
3759   }
3760
3761   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3762   return jresult;
3763 }
3764
3765
3766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3767   void * jresult ;
3768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3769   Dali::Vector2 *arg2 = 0 ;
3770   Dali::Vector2 *result = 0 ;
3771
3772   arg1 = (Dali::Vector2 *)jarg1;
3773   arg2 = (Dali::Vector2 *)jarg2;
3774   if (!arg2) {
3775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3776     return 0;
3777   }
3778   {
3779     try {
3780       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3781     } CALL_CATCH_EXCEPTION(0);
3782   }
3783
3784   jresult = (void *)result;
3785   return jresult;
3786 }
3787
3788
3789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3790   void * jresult ;
3791   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3792   float arg2 ;
3793   Dali::Vector2 *result = 0 ;
3794
3795   arg1 = (Dali::Vector2 *)jarg1;
3796   arg2 = (float)jarg2;
3797   {
3798     try {
3799       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3800     } CALL_CATCH_EXCEPTION(0);
3801   }
3802
3803   jresult = (void *)result;
3804   return jresult;
3805 }
3806
3807
3808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3809   void * jresult ;
3810   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3811   Dali::Vector2 *arg2 = 0 ;
3812   Dali::Vector2 result;
3813
3814   arg1 = (Dali::Vector2 *)jarg1;
3815   arg2 = (Dali::Vector2 *)jarg2;
3816   if (!arg2) {
3817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3818     return 0;
3819   }
3820   {
3821     try {
3822       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3823     } CALL_CATCH_EXCEPTION(0);
3824   }
3825
3826   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3827   return jresult;
3828 }
3829
3830
3831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3832   void * jresult ;
3833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3834   float arg2 ;
3835   Dali::Vector2 result;
3836
3837   arg1 = (Dali::Vector2 *)jarg1;
3838   arg2 = (float)jarg2;
3839   {
3840     try {
3841       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3842     } CALL_CATCH_EXCEPTION(0);
3843   }
3844
3845   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3846   return jresult;
3847 }
3848
3849
3850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3851   void * jresult ;
3852   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3853   Dali::Vector2 *arg2 = 0 ;
3854   Dali::Vector2 *result = 0 ;
3855
3856   arg1 = (Dali::Vector2 *)jarg1;
3857   arg2 = (Dali::Vector2 *)jarg2;
3858   if (!arg2) {
3859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3860     return 0;
3861   }
3862   {
3863     try {
3864       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3865     } CALL_CATCH_EXCEPTION(0);
3866   }
3867
3868   jresult = (void *)result;
3869   return jresult;
3870 }
3871
3872
3873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3874   void * jresult ;
3875   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3876   float arg2 ;
3877   Dali::Vector2 *result = 0 ;
3878
3879   arg1 = (Dali::Vector2 *)jarg1;
3880   arg2 = (float)jarg2;
3881   {
3882     try {
3883       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3884     } CALL_CATCH_EXCEPTION(0);
3885   }
3886
3887   jresult = (void *)result;
3888   return jresult;
3889 }
3890
3891
3892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3893   void * jresult ;
3894   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3895   Dali::Vector2 result;
3896
3897   arg1 = (Dali::Vector2 *)jarg1;
3898   {
3899     try {
3900       result = ((Dali::Vector2 const *)arg1)->operator -();
3901     } CALL_CATCH_EXCEPTION(0);
3902   }
3903
3904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3905   return jresult;
3906 }
3907
3908
3909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3910   unsigned int jresult ;
3911   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3912   Dali::Vector2 *arg2 = 0 ;
3913   bool result;
3914
3915   arg1 = (Dali::Vector2 *)jarg1;
3916   arg2 = (Dali::Vector2 *)jarg2;
3917   if (!arg2) {
3918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3919     return 0;
3920   }
3921   {
3922     try {
3923       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3924     } CALL_CATCH_EXCEPTION(0);
3925   }
3926
3927   jresult = result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3933   unsigned int jresult ;
3934   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3935   Dali::Vector2 *arg2 = 0 ;
3936   bool result;
3937
3938   arg1 = (Dali::Vector2 *)jarg1;
3939   arg2 = (Dali::Vector2 *)jarg2;
3940   if (!arg2) {
3941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3942     return 0;
3943   }
3944   {
3945     try {
3946       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3947     } CALL_CATCH_EXCEPTION(0);
3948   }
3949
3950   jresult = result;
3951   return jresult;
3952 }
3953
3954
3955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3956   float jresult ;
3957   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3958   unsigned int arg2 ;
3959   float *result = 0 ;
3960
3961   arg1 = (Dali::Vector2 *)jarg1;
3962   arg2 = (unsigned int)jarg2;
3963   {
3964     try {
3965       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3966     } CALL_CATCH_EXCEPTION(0);
3967   }
3968
3969   jresult = *result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3975   float jresult ;
3976   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3977   float result;
3978
3979   arg1 = (Dali::Vector2 *)jarg1;
3980   {
3981     try {
3982       result = (float)((Dali::Vector2 const *)arg1)->Length();
3983     } CALL_CATCH_EXCEPTION(0);
3984   }
3985
3986   jresult = result;
3987   return jresult;
3988 }
3989
3990
3991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3992   float jresult ;
3993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3994   float result;
3995
3996   arg1 = (Dali::Vector2 *)jarg1;
3997   {
3998     try {
3999       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4000     } CALL_CATCH_EXCEPTION(0);
4001   }
4002
4003   jresult = result;
4004   return jresult;
4005 }
4006
4007
4008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4009   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4010
4011   arg1 = (Dali::Vector2 *)jarg1;
4012   {
4013     try {
4014       (arg1)->Normalize();
4015     } CALL_CATCH_EXCEPTION();
4016   }
4017
4018 }
4019
4020
4021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4022   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4023   Dali::Vector2 *arg2 = 0 ;
4024   Dali::Vector2 *arg3 = 0 ;
4025
4026   arg1 = (Dali::Vector2 *)jarg1;
4027   arg2 = (Dali::Vector2 *)jarg2;
4028   if (!arg2) {
4029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4030     return ;
4031   }
4032   arg3 = (Dali::Vector2 *)jarg3;
4033   if (!arg3) {
4034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4035     return ;
4036   }
4037   {
4038     try {
4039       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4040     } CALL_CATCH_EXCEPTION();
4041   }
4042
4043 }
4044
4045
4046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4047   void * jresult ;
4048   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4049   float *result = 0 ;
4050
4051   arg1 = (Dali::Vector2 *)jarg1;
4052   {
4053     try {
4054       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4055     } CALL_CATCH_EXCEPTION(0);
4056   }
4057
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4065   float arg2 ;
4066
4067   arg1 = (Dali::Vector2 *)jarg1;
4068   arg2 = (float)jarg2;
4069   if (arg1) (arg1)->x = arg2;
4070 }
4071
4072
4073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4074   float jresult ;
4075   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4076   float result;
4077
4078   arg1 = (Dali::Vector2 *)jarg1;
4079   result = (float) ((arg1)->x);
4080   jresult = result;
4081   return jresult;
4082 }
4083
4084
4085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4086   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4087   float arg2 ;
4088
4089   arg1 = (Dali::Vector2 *)jarg1;
4090   arg2 = (float)jarg2;
4091   if (arg1) (arg1)->width = arg2;
4092 }
4093
4094
4095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4096   float jresult ;
4097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4098   float result;
4099
4100   arg1 = (Dali::Vector2 *)jarg1;
4101   result = (float) ((arg1)->width);
4102   jresult = result;
4103   return jresult;
4104 }
4105
4106
4107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4108   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4109   float arg2 ;
4110
4111   arg1 = (Dali::Vector2 *)jarg1;
4112   arg2 = (float)jarg2;
4113   if (arg1) (arg1)->y = arg2;
4114 }
4115
4116
4117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4118   float jresult ;
4119   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4120   float result;
4121
4122   arg1 = (Dali::Vector2 *)jarg1;
4123   result = (float) ((arg1)->y);
4124   jresult = result;
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4130   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4131   float arg2 ;
4132
4133   arg1 = (Dali::Vector2 *)jarg1;
4134   arg2 = (float)jarg2;
4135   if (arg1) (arg1)->height = arg2;
4136 }
4137
4138
4139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4140   float jresult ;
4141   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4142   float result;
4143
4144   arg1 = (Dali::Vector2 *)jarg1;
4145   result = (float) ((arg1)->height);
4146   jresult = result;
4147   return jresult;
4148 }
4149
4150
4151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4152   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4153
4154   arg1 = (Dali::Vector2 *)jarg1;
4155   {
4156     try {
4157       delete arg1;
4158     } CALL_CATCH_EXCEPTION();
4159   }
4160
4161 }
4162
4163
4164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4165   void * jresult ;
4166   Dali::Vector2 *arg1 = 0 ;
4167   Dali::Vector2 *arg2 = 0 ;
4168   Dali::Vector2 result;
4169
4170   arg1 = (Dali::Vector2 *)jarg1;
4171   if (!arg1) {
4172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4173     return 0;
4174   }
4175   arg2 = (Dali::Vector2 *)jarg2;
4176   if (!arg2) {
4177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4178     return 0;
4179   }
4180   {
4181     try {
4182       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4183     } CALL_CATCH_EXCEPTION(0);
4184   }
4185
4186   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4187   return jresult;
4188 }
4189
4190
4191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4192   void * jresult ;
4193   Dali::Vector2 *arg1 = 0 ;
4194   Dali::Vector2 *arg2 = 0 ;
4195   Dali::Vector2 result;
4196
4197   arg1 = (Dali::Vector2 *)jarg1;
4198   if (!arg1) {
4199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4200     return 0;
4201   }
4202   arg2 = (Dali::Vector2 *)jarg2;
4203   if (!arg2) {
4204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4205     return 0;
4206   }
4207   {
4208     try {
4209       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4210     } CALL_CATCH_EXCEPTION(0);
4211   }
4212
4213   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4214   return jresult;
4215 }
4216
4217
4218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4219   void * jresult ;
4220   Dali::Vector2 *arg1 = 0 ;
4221   float *arg2 = 0 ;
4222   float *arg3 = 0 ;
4223   float temp2 ;
4224   float temp3 ;
4225   Dali::Vector2 result;
4226
4227   arg1 = (Dali::Vector2 *)jarg1;
4228   if (!arg1) {
4229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4230     return 0;
4231   }
4232   temp2 = (float)jarg2;
4233   arg2 = &temp2;
4234   temp3 = (float)jarg3;
4235   arg3 = &temp3;
4236   {
4237     try {
4238       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4239     } CALL_CATCH_EXCEPTION(0);
4240   }
4241
4242   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4243   return jresult;
4244 }
4245
4246
4247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4248   void * jresult ;
4249   Dali::Vector3 *result = 0 ;
4250
4251   {
4252     try {
4253       result = (Dali::Vector3 *)new Dali::Vector3();
4254     } CALL_CATCH_EXCEPTION(0);
4255   }
4256
4257   jresult = (void *)result;
4258   return jresult;
4259 }
4260
4261
4262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4263   void * jresult ;
4264   float arg1 ;
4265   float arg2 ;
4266   float arg3 ;
4267   Dali::Vector3 *result = 0 ;
4268
4269   arg1 = (float)jarg1;
4270   arg2 = (float)jarg2;
4271   arg3 = (float)jarg3;
4272   {
4273     try {
4274       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4275     } CALL_CATCH_EXCEPTION(0);
4276   }
4277
4278   jresult = (void *)result;
4279   return jresult;
4280 }
4281
4282
4283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4284   void * jresult ;
4285   float *arg1 = (float *) 0 ;
4286   Dali::Vector3 *result = 0 ;
4287
4288   arg1 = jarg1;
4289   {
4290     try {
4291       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4292     } CALL_CATCH_EXCEPTION(0);
4293   }
4294
4295   jresult = (void *)result;
4296
4297
4298   return jresult;
4299 }
4300
4301
4302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4303   void * jresult ;
4304   Dali::Vector2 *arg1 = 0 ;
4305   Dali::Vector3 *result = 0 ;
4306
4307   arg1 = (Dali::Vector2 *)jarg1;
4308   if (!arg1) {
4309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4310     return 0;
4311   }
4312   {
4313     try {
4314       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4315     } CALL_CATCH_EXCEPTION(0);
4316   }
4317
4318   jresult = (void *)result;
4319   return jresult;
4320 }
4321
4322
4323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4324   void * jresult ;
4325   Dali::Vector4 *arg1 = 0 ;
4326   Dali::Vector3 *result = 0 ;
4327
4328   arg1 = (Dali::Vector4 *)jarg1;
4329   if (!arg1) {
4330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4331     return 0;
4332   }
4333   {
4334     try {
4335       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4336     } CALL_CATCH_EXCEPTION(0);
4337   }
4338
4339   jresult = (void *)result;
4340   return jresult;
4341 }
4342
4343
4344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4345   void * jresult ;
4346   Dali::Vector3 *result = 0 ;
4347
4348   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4349   jresult = (void *)result;
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4355   void * jresult ;
4356   Dali::Vector3 *result = 0 ;
4357
4358   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4359   jresult = (void *)result;
4360   return jresult;
4361 }
4362
4363
4364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4365   void * jresult ;
4366   Dali::Vector3 *result = 0 ;
4367
4368   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4369   jresult = (void *)result;
4370   return jresult;
4371 }
4372
4373
4374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4375   void * jresult ;
4376   Dali::Vector3 *result = 0 ;
4377
4378   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4379   jresult = (void *)result;
4380   return jresult;
4381 }
4382
4383
4384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4385   void * jresult ;
4386   Dali::Vector3 *result = 0 ;
4387
4388   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4389   jresult = (void *)result;
4390   return jresult;
4391 }
4392
4393
4394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4395   void * jresult ;
4396   Dali::Vector3 *result = 0 ;
4397
4398   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4399   jresult = (void *)result;
4400   return jresult;
4401 }
4402
4403
4404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4405   void * jresult ;
4406   Dali::Vector3 *result = 0 ;
4407
4408   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4415   void * jresult ;
4416   Dali::Vector3 *result = 0 ;
4417
4418   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4419   jresult = (void *)result;
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4425   void * jresult ;
4426   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4427   float *arg2 = (float *) 0 ;
4428   Dali::Vector3 *result = 0 ;
4429
4430   arg1 = (Dali::Vector3 *)jarg1;
4431   arg2 = jarg2;
4432   {
4433     try {
4434       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4435     } CALL_CATCH_EXCEPTION(0);
4436   }
4437
4438   jresult = (void *)result;
4439
4440
4441   return jresult;
4442 }
4443
4444
4445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4446   void * jresult ;
4447   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4448   Dali::Vector2 *arg2 = 0 ;
4449   Dali::Vector3 *result = 0 ;
4450
4451   arg1 = (Dali::Vector3 *)jarg1;
4452   arg2 = (Dali::Vector2 *)jarg2;
4453   if (!arg2) {
4454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4455     return 0;
4456   }
4457   {
4458     try {
4459       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4460     } CALL_CATCH_EXCEPTION(0);
4461   }
4462
4463   jresult = (void *)result;
4464   return jresult;
4465 }
4466
4467
4468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4469   void * jresult ;
4470   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4471   Dali::Vector4 *arg2 = 0 ;
4472   Dali::Vector3 *result = 0 ;
4473
4474   arg1 = (Dali::Vector3 *)jarg1;
4475   arg2 = (Dali::Vector4 *)jarg2;
4476   if (!arg2) {
4477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4478     return 0;
4479   }
4480   {
4481     try {
4482       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4483     } CALL_CATCH_EXCEPTION(0);
4484   }
4485
4486   jresult = (void *)result;
4487   return jresult;
4488 }
4489
4490
4491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4492   void * jresult ;
4493   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4494   Dali::Vector3 *arg2 = 0 ;
4495   Dali::Vector3 result;
4496
4497   arg1 = (Dali::Vector3 *)jarg1;
4498   arg2 = (Dali::Vector3 *)jarg2;
4499   if (!arg2) {
4500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4501     return 0;
4502   }
4503   {
4504     try {
4505       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4506     } CALL_CATCH_EXCEPTION(0);
4507   }
4508
4509   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4510   return jresult;
4511 }
4512
4513
4514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4515   void * jresult ;
4516   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4517   Dali::Vector3 *arg2 = 0 ;
4518   Dali::Vector3 *result = 0 ;
4519
4520   arg1 = (Dali::Vector3 *)jarg1;
4521   arg2 = (Dali::Vector3 *)jarg2;
4522   if (!arg2) {
4523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4524     return 0;
4525   }
4526   {
4527     try {
4528       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4529     } CALL_CATCH_EXCEPTION(0);
4530   }
4531
4532   jresult = (void *)result;
4533   return jresult;
4534 }
4535
4536
4537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4538   void * jresult ;
4539   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4540   Dali::Vector3 *arg2 = 0 ;
4541   Dali::Vector3 result;
4542
4543   arg1 = (Dali::Vector3 *)jarg1;
4544   arg2 = (Dali::Vector3 *)jarg2;
4545   if (!arg2) {
4546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4547     return 0;
4548   }
4549   {
4550     try {
4551       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4552     } CALL_CATCH_EXCEPTION(0);
4553   }
4554
4555   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4556   return jresult;
4557 }
4558
4559
4560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4561   void * jresult ;
4562   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4563   Dali::Vector3 *arg2 = 0 ;
4564   Dali::Vector3 *result = 0 ;
4565
4566   arg1 = (Dali::Vector3 *)jarg1;
4567   arg2 = (Dali::Vector3 *)jarg2;
4568   if (!arg2) {
4569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4570     return 0;
4571   }
4572   {
4573     try {
4574       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4575     } CALL_CATCH_EXCEPTION(0);
4576   }
4577
4578   jresult = (void *)result;
4579   return jresult;
4580 }
4581
4582
4583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4584   void * jresult ;
4585   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4586   Dali::Vector3 *arg2 = 0 ;
4587   Dali::Vector3 result;
4588
4589   arg1 = (Dali::Vector3 *)jarg1;
4590   arg2 = (Dali::Vector3 *)jarg2;
4591   if (!arg2) {
4592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4593     return 0;
4594   }
4595   {
4596     try {
4597       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4598     } CALL_CATCH_EXCEPTION(0);
4599   }
4600
4601   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4602   return jresult;
4603 }
4604
4605
4606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4607   void * jresult ;
4608   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4609   float arg2 ;
4610   Dali::Vector3 result;
4611
4612   arg1 = (Dali::Vector3 *)jarg1;
4613   arg2 = (float)jarg2;
4614   {
4615     try {
4616       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4617     } CALL_CATCH_EXCEPTION(0);
4618   }
4619
4620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4621   return jresult;
4622 }
4623
4624
4625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4626   void * jresult ;
4627   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4628   Dali::Vector3 *arg2 = 0 ;
4629   Dali::Vector3 *result = 0 ;
4630
4631   arg1 = (Dali::Vector3 *)jarg1;
4632   arg2 = (Dali::Vector3 *)jarg2;
4633   if (!arg2) {
4634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4635     return 0;
4636   }
4637   {
4638     try {
4639       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4640     } CALL_CATCH_EXCEPTION(0);
4641   }
4642
4643   jresult = (void *)result;
4644   return jresult;
4645 }
4646
4647
4648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4649   void * jresult ;
4650   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4651   float arg2 ;
4652   Dali::Vector3 *result = 0 ;
4653
4654   arg1 = (Dali::Vector3 *)jarg1;
4655   arg2 = (float)jarg2;
4656   {
4657     try {
4658       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4659     } CALL_CATCH_EXCEPTION(0);
4660   }
4661
4662   jresult = (void *)result;
4663   return jresult;
4664 }
4665
4666
4667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4668   void * jresult ;
4669   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4670   Dali::Quaternion *arg2 = 0 ;
4671   Dali::Vector3 *result = 0 ;
4672
4673   arg1 = (Dali::Vector3 *)jarg1;
4674   arg2 = (Dali::Quaternion *)jarg2;
4675   if (!arg2) {
4676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4677     return 0;
4678   }
4679   {
4680     try {
4681       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4682     } CALL_CATCH_EXCEPTION(0);
4683   }
4684
4685   jresult = (void *)result;
4686   return jresult;
4687 }
4688
4689
4690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4691   void * jresult ;
4692   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4693   Dali::Vector3 *arg2 = 0 ;
4694   Dali::Vector3 result;
4695
4696   arg1 = (Dali::Vector3 *)jarg1;
4697   arg2 = (Dali::Vector3 *)jarg2;
4698   if (!arg2) {
4699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4700     return 0;
4701   }
4702   {
4703     try {
4704       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4705     } CALL_CATCH_EXCEPTION(0);
4706   }
4707
4708   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4709   return jresult;
4710 }
4711
4712
4713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4714   void * jresult ;
4715   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4716   float arg2 ;
4717   Dali::Vector3 result;
4718
4719   arg1 = (Dali::Vector3 *)jarg1;
4720   arg2 = (float)jarg2;
4721   {
4722     try {
4723       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4724     } CALL_CATCH_EXCEPTION(0);
4725   }
4726
4727   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4728   return jresult;
4729 }
4730
4731
4732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4733   void * jresult ;
4734   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4735   Dali::Vector3 *arg2 = 0 ;
4736   Dali::Vector3 *result = 0 ;
4737
4738   arg1 = (Dali::Vector3 *)jarg1;
4739   arg2 = (Dali::Vector3 *)jarg2;
4740   if (!arg2) {
4741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4742     return 0;
4743   }
4744   {
4745     try {
4746       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4747     } CALL_CATCH_EXCEPTION(0);
4748   }
4749
4750   jresult = (void *)result;
4751   return jresult;
4752 }
4753
4754
4755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4756   void * jresult ;
4757   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4758   float arg2 ;
4759   Dali::Vector3 *result = 0 ;
4760
4761   arg1 = (Dali::Vector3 *)jarg1;
4762   arg2 = (float)jarg2;
4763   {
4764     try {
4765       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4766     } CALL_CATCH_EXCEPTION(0);
4767   }
4768
4769   jresult = (void *)result;
4770   return jresult;
4771 }
4772
4773
4774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4775   void * jresult ;
4776   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4777   Dali::Vector3 result;
4778
4779   arg1 = (Dali::Vector3 *)jarg1;
4780   {
4781     try {
4782       result = ((Dali::Vector3 const *)arg1)->operator -();
4783     } CALL_CATCH_EXCEPTION(0);
4784   }
4785
4786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4787   return jresult;
4788 }
4789
4790
4791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4792   unsigned int jresult ;
4793   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4794   Dali::Vector3 *arg2 = 0 ;
4795   bool result;
4796
4797   arg1 = (Dali::Vector3 *)jarg1;
4798   arg2 = (Dali::Vector3 *)jarg2;
4799   if (!arg2) {
4800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4801     return 0;
4802   }
4803   {
4804     try {
4805       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4806     } CALL_CATCH_EXCEPTION(0);
4807   }
4808
4809   jresult = result;
4810   return jresult;
4811 }
4812
4813
4814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4815   unsigned int jresult ;
4816   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4817   Dali::Vector3 *arg2 = 0 ;
4818   bool result;
4819
4820   arg1 = (Dali::Vector3 *)jarg1;
4821   arg2 = (Dali::Vector3 *)jarg2;
4822   if (!arg2) {
4823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4824     return 0;
4825   }
4826   {
4827     try {
4828       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4829     } CALL_CATCH_EXCEPTION(0);
4830   }
4831
4832   jresult = result;
4833   return jresult;
4834 }
4835
4836
4837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4838   float jresult ;
4839   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4840   unsigned int arg2 ;
4841   float *result = 0 ;
4842
4843   arg1 = (Dali::Vector3 *)jarg1;
4844   arg2 = (unsigned int)jarg2;
4845   {
4846     try {
4847       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4848     } CALL_CATCH_EXCEPTION(0);
4849   }
4850
4851   jresult = *result;
4852   return jresult;
4853 }
4854
4855
4856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4857   float jresult ;
4858   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4859   Dali::Vector3 *arg2 = 0 ;
4860   float result;
4861
4862   arg1 = (Dali::Vector3 *)jarg1;
4863   arg2 = (Dali::Vector3 *)jarg2;
4864   if (!arg2) {
4865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4866     return 0;
4867   }
4868   {
4869     try {
4870       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4871     } CALL_CATCH_EXCEPTION(0);
4872   }
4873
4874   jresult = result;
4875   return jresult;
4876 }
4877
4878
4879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4880   void * jresult ;
4881   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4882   Dali::Vector3 *arg2 = 0 ;
4883   Dali::Vector3 result;
4884
4885   arg1 = (Dali::Vector3 *)jarg1;
4886   arg2 = (Dali::Vector3 *)jarg2;
4887   if (!arg2) {
4888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4889     return 0;
4890   }
4891   {
4892     try {
4893       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4894     } CALL_CATCH_EXCEPTION(0);
4895   }
4896
4897   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4903   float jresult ;
4904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4905   float result;
4906
4907   arg1 = (Dali::Vector3 *)jarg1;
4908   {
4909     try {
4910       result = (float)((Dali::Vector3 const *)arg1)->Length();
4911     } CALL_CATCH_EXCEPTION(0);
4912   }
4913
4914   jresult = result;
4915   return jresult;
4916 }
4917
4918
4919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4920   float jresult ;
4921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4922   float result;
4923
4924   arg1 = (Dali::Vector3 *)jarg1;
4925   {
4926     try {
4927       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4928     } CALL_CATCH_EXCEPTION(0);
4929   }
4930
4931   jresult = result;
4932   return jresult;
4933 }
4934
4935
4936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4938
4939   arg1 = (Dali::Vector3 *)jarg1;
4940   {
4941     try {
4942       (arg1)->Normalize();
4943     } CALL_CATCH_EXCEPTION();
4944   }
4945
4946 }
4947
4948
4949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4951   Dali::Vector3 *arg2 = 0 ;
4952   Dali::Vector3 *arg3 = 0 ;
4953
4954   arg1 = (Dali::Vector3 *)jarg1;
4955   arg2 = (Dali::Vector3 *)jarg2;
4956   if (!arg2) {
4957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4958     return ;
4959   }
4960   arg3 = (Dali::Vector3 *)jarg3;
4961   if (!arg3) {
4962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4963     return ;
4964   }
4965   {
4966     try {
4967       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4968     } CALL_CATCH_EXCEPTION();
4969   }
4970
4971 }
4972
4973
4974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4975   void * jresult ;
4976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4977   float *result = 0 ;
4978
4979   arg1 = (Dali::Vector3 *)jarg1;
4980   {
4981     try {
4982       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4983     } CALL_CATCH_EXCEPTION(0);
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4992   void * jresult ;
4993   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4994   Dali::Vector2 *result = 0 ;
4995
4996   arg1 = (Dali::Vector3 *)jarg1;
4997   {
4998     try {
4999       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
5000     } CALL_CATCH_EXCEPTION(0);
5001   }
5002
5003   jresult = (void *)result;
5004   return jresult;
5005 }
5006
5007
5008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
5009   void * jresult ;
5010   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5011   Dali::Vector2 *result = 0 ;
5012
5013   arg1 = (Dali::Vector3 *)jarg1;
5014   {
5015     try {
5016       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
5017     } CALL_CATCH_EXCEPTION(0);
5018   }
5019
5020   jresult = (void *)result;
5021   return jresult;
5022 }
5023
5024
5025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
5026   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5027   float arg2 ;
5028
5029   arg1 = (Dali::Vector3 *)jarg1;
5030   arg2 = (float)jarg2;
5031   if (arg1) (arg1)->x = arg2;
5032 }
5033
5034
5035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
5036   float jresult ;
5037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5038   float result;
5039
5040   arg1 = (Dali::Vector3 *)jarg1;
5041   result = (float) ((arg1)->x);
5042   jresult = result;
5043   return jresult;
5044 }
5045
5046
5047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
5048   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5049   float arg2 ;
5050
5051   arg1 = (Dali::Vector3 *)jarg1;
5052   arg2 = (float)jarg2;
5053   if (arg1) (arg1)->width = arg2;
5054 }
5055
5056
5057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
5058   float jresult ;
5059   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5060   float result;
5061
5062   arg1 = (Dali::Vector3 *)jarg1;
5063   result = (float) ((arg1)->width);
5064   jresult = result;
5065   return jresult;
5066 }
5067
5068
5069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
5070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5071   float arg2 ;
5072
5073   arg1 = (Dali::Vector3 *)jarg1;
5074   arg2 = (float)jarg2;
5075   if (arg1) (arg1)->r = arg2;
5076 }
5077
5078
5079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
5080   float jresult ;
5081   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5082   float result;
5083
5084   arg1 = (Dali::Vector3 *)jarg1;
5085   result = (float) ((arg1)->r);
5086   jresult = result;
5087   return jresult;
5088 }
5089
5090
5091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
5092   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5093   float arg2 ;
5094
5095   arg1 = (Dali::Vector3 *)jarg1;
5096   arg2 = (float)jarg2;
5097   if (arg1) (arg1)->y = arg2;
5098 }
5099
5100
5101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
5102   float jresult ;
5103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5104   float result;
5105
5106   arg1 = (Dali::Vector3 *)jarg1;
5107   result = (float) ((arg1)->y);
5108   jresult = result;
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
5114   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5115   float arg2 ;
5116
5117   arg1 = (Dali::Vector3 *)jarg1;
5118   arg2 = (float)jarg2;
5119   if (arg1) (arg1)->height = arg2;
5120 }
5121
5122
5123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
5124   float jresult ;
5125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5126   float result;
5127
5128   arg1 = (Dali::Vector3 *)jarg1;
5129   result = (float) ((arg1)->height);
5130   jresult = result;
5131   return jresult;
5132 }
5133
5134
5135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5136   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5137   float arg2 ;
5138
5139   arg1 = (Dali::Vector3 *)jarg1;
5140   arg2 = (float)jarg2;
5141   if (arg1) (arg1)->g = arg2;
5142 }
5143
5144
5145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5146   float jresult ;
5147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5148   float result;
5149
5150   arg1 = (Dali::Vector3 *)jarg1;
5151   result = (float) ((arg1)->g);
5152   jresult = result;
5153   return jresult;
5154 }
5155
5156
5157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
5158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5159   float arg2 ;
5160
5161   arg1 = (Dali::Vector3 *)jarg1;
5162   arg2 = (float)jarg2;
5163   if (arg1) (arg1)->z = arg2;
5164 }
5165
5166
5167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
5168   float jresult ;
5169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5170   float result;
5171
5172   arg1 = (Dali::Vector3 *)jarg1;
5173   result = (float) ((arg1)->z);
5174   jresult = result;
5175   return jresult;
5176 }
5177
5178
5179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
5180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5181   float arg2 ;
5182
5183   arg1 = (Dali::Vector3 *)jarg1;
5184   arg2 = (float)jarg2;
5185   if (arg1) (arg1)->depth = arg2;
5186 }
5187
5188
5189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
5190   float jresult ;
5191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5192   float result;
5193
5194   arg1 = (Dali::Vector3 *)jarg1;
5195   result = (float) ((arg1)->depth);
5196   jresult = result;
5197   return jresult;
5198 }
5199
5200
5201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5203   float arg2 ;
5204
5205   arg1 = (Dali::Vector3 *)jarg1;
5206   arg2 = (float)jarg2;
5207   if (arg1) (arg1)->b = arg2;
5208 }
5209
5210
5211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5212   float jresult ;
5213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5214   float result;
5215
5216   arg1 = (Dali::Vector3 *)jarg1;
5217   result = (float) ((arg1)->b);
5218   jresult = result;
5219   return jresult;
5220 }
5221
5222
5223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5225
5226   arg1 = (Dali::Vector3 *)jarg1;
5227   {
5228     try {
5229       delete arg1;
5230     } CALL_CATCH_EXCEPTION();
5231   }
5232
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5237   void * jresult ;
5238   Dali::Vector3 *arg1 = 0 ;
5239   Dali::Vector3 *arg2 = 0 ;
5240   Dali::Vector3 result;
5241
5242   arg1 = (Dali::Vector3 *)jarg1;
5243   if (!arg1) {
5244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5245     return 0;
5246   }
5247   arg2 = (Dali::Vector3 *)jarg2;
5248   if (!arg2) {
5249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5250     return 0;
5251   }
5252   {
5253     try {
5254       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5255     } CALL_CATCH_EXCEPTION(0);
5256   }
5257
5258   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5259   return jresult;
5260 }
5261
5262
5263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5264   void * jresult ;
5265   Dali::Vector3 *arg1 = 0 ;
5266   Dali::Vector3 *arg2 = 0 ;
5267   Dali::Vector3 result;
5268
5269   arg1 = (Dali::Vector3 *)jarg1;
5270   if (!arg1) {
5271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5272     return 0;
5273   }
5274   arg2 = (Dali::Vector3 *)jarg2;
5275   if (!arg2) {
5276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5277     return 0;
5278   }
5279   {
5280     try {
5281       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5282     } CALL_CATCH_EXCEPTION(0);
5283   }
5284
5285   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5286   return jresult;
5287 }
5288
5289
5290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5291   void * jresult ;
5292   Dali::Vector3 *arg1 = 0 ;
5293   float *arg2 = 0 ;
5294   float *arg3 = 0 ;
5295   float temp2 ;
5296   float temp3 ;
5297   Dali::Vector3 result;
5298
5299   arg1 = (Dali::Vector3 *)jarg1;
5300   if (!arg1) {
5301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5302     return 0;
5303   }
5304   temp2 = (float)jarg2;
5305   arg2 = &temp2;
5306   temp3 = (float)jarg3;
5307   arg3 = &temp3;
5308   {
5309     try {
5310       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5311     } CALL_CATCH_EXCEPTION(0);
5312   }
5313
5314   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5320   void * jresult ;
5321   Dali::Vector4 *result = 0 ;
5322
5323   {
5324     try {
5325       result = (Dali::Vector4 *)new Dali::Vector4();
5326     } CALL_CATCH_EXCEPTION(0);
5327   }
5328
5329   jresult = (void *)result;
5330   return jresult;
5331 }
5332
5333
5334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5335   void * jresult ;
5336   float arg1 ;
5337   float arg2 ;
5338   float arg3 ;
5339   float arg4 ;
5340   Dali::Vector4 *result = 0 ;
5341
5342   arg1 = (float)jarg1;
5343   arg2 = (float)jarg2;
5344   arg3 = (float)jarg3;
5345   arg4 = (float)jarg4;
5346   {
5347     try {
5348       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5349     } CALL_CATCH_EXCEPTION(0);
5350   }
5351
5352   jresult = (void *)result;
5353   return jresult;
5354 }
5355
5356
5357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5358   void * jresult ;
5359   float *arg1 = (float *) 0 ;
5360   Dali::Vector4 *result = 0 ;
5361
5362   arg1 = jarg1;
5363   {
5364     try {
5365       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5366     } CALL_CATCH_EXCEPTION(0);
5367   }
5368
5369   jresult = (void *)result;
5370
5371
5372   return jresult;
5373 }
5374
5375
5376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5377   void * jresult ;
5378   Dali::Vector2 *arg1 = 0 ;
5379   Dali::Vector4 *result = 0 ;
5380
5381   arg1 = (Dali::Vector2 *)jarg1;
5382   if (!arg1) {
5383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5384     return 0;
5385   }
5386   {
5387     try {
5388       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5389     } CALL_CATCH_EXCEPTION(0);
5390   }
5391
5392   jresult = (void *)result;
5393   return jresult;
5394 }
5395
5396
5397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5398   void * jresult ;
5399   Dali::Vector3 *arg1 = 0 ;
5400   Dali::Vector4 *result = 0 ;
5401
5402   arg1 = (Dali::Vector3 *)jarg1;
5403   if (!arg1) {
5404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5405     return 0;
5406   }
5407   {
5408     try {
5409       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5410     } CALL_CATCH_EXCEPTION(0);
5411   }
5412
5413   jresult = (void *)result;
5414   return jresult;
5415 }
5416
5417
5418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5419   void * jresult ;
5420   Dali::Vector4 *result = 0 ;
5421
5422   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5423   jresult = (void *)result;
5424   return jresult;
5425 }
5426
5427
5428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5429   void * jresult ;
5430   Dali::Vector4 *result = 0 ;
5431
5432   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5433   jresult = (void *)result;
5434   return jresult;
5435 }
5436
5437
5438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5439   void * jresult ;
5440   Dali::Vector4 *result = 0 ;
5441
5442   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5443   jresult = (void *)result;
5444   return jresult;
5445 }
5446
5447
5448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5449   void * jresult ;
5450   Dali::Vector4 *result = 0 ;
5451
5452   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5453   jresult = (void *)result;
5454   return jresult;
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5459   void * jresult ;
5460   Dali::Vector4 *result = 0 ;
5461
5462   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5463   jresult = (void *)result;
5464   return jresult;
5465 }
5466
5467
5468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5469   void * jresult ;
5470   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5471   float *arg2 = (float *) 0 ;
5472   Dali::Vector4 *result = 0 ;
5473
5474   arg1 = (Dali::Vector4 *)jarg1;
5475   arg2 = jarg2;
5476   {
5477     try {
5478       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5479     } CALL_CATCH_EXCEPTION(0);
5480   }
5481
5482   jresult = (void *)result;
5483
5484
5485   return jresult;
5486 }
5487
5488
5489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5490   void * jresult ;
5491   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5492   Dali::Vector2 *arg2 = 0 ;
5493   Dali::Vector4 *result = 0 ;
5494
5495   arg1 = (Dali::Vector4 *)jarg1;
5496   arg2 = (Dali::Vector2 *)jarg2;
5497   if (!arg2) {
5498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5499     return 0;
5500   }
5501   {
5502     try {
5503       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5504     } CALL_CATCH_EXCEPTION(0);
5505   }
5506
5507   jresult = (void *)result;
5508   return jresult;
5509 }
5510
5511
5512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5513   void * jresult ;
5514   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5515   Dali::Vector3 *arg2 = 0 ;
5516   Dali::Vector4 *result = 0 ;
5517
5518   arg1 = (Dali::Vector4 *)jarg1;
5519   arg2 = (Dali::Vector3 *)jarg2;
5520   if (!arg2) {
5521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5522     return 0;
5523   }
5524   {
5525     try {
5526       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5527     } CALL_CATCH_EXCEPTION(0);
5528   }
5529
5530   jresult = (void *)result;
5531   return jresult;
5532 }
5533
5534
5535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5536   void * jresult ;
5537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5538   Dali::Vector4 *arg2 = 0 ;
5539   Dali::Vector4 result;
5540
5541   arg1 = (Dali::Vector4 *)jarg1;
5542   arg2 = (Dali::Vector4 *)jarg2;
5543   if (!arg2) {
5544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5545     return 0;
5546   }
5547   {
5548     try {
5549       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5550     } CALL_CATCH_EXCEPTION(0);
5551   }
5552
5553   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5554   return jresult;
5555 }
5556
5557
5558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5559   void * jresult ;
5560   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5561   Dali::Vector4 *arg2 = 0 ;
5562   Dali::Vector4 *result = 0 ;
5563
5564   arg1 = (Dali::Vector4 *)jarg1;
5565   arg2 = (Dali::Vector4 *)jarg2;
5566   if (!arg2) {
5567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5568     return 0;
5569   }
5570   {
5571     try {
5572       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5573     } CALL_CATCH_EXCEPTION(0);
5574   }
5575
5576   jresult = (void *)result;
5577   return jresult;
5578 }
5579
5580
5581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5582   void * jresult ;
5583   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5584   Dali::Vector4 *arg2 = 0 ;
5585   Dali::Vector4 result;
5586
5587   arg1 = (Dali::Vector4 *)jarg1;
5588   arg2 = (Dali::Vector4 *)jarg2;
5589   if (!arg2) {
5590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5591     return 0;
5592   }
5593   {
5594     try {
5595       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5596     } CALL_CATCH_EXCEPTION(0);
5597   }
5598
5599   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5600   return jresult;
5601 }
5602
5603
5604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5605   void * jresult ;
5606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5607   Dali::Vector4 *arg2 = 0 ;
5608   Dali::Vector4 *result = 0 ;
5609
5610   arg1 = (Dali::Vector4 *)jarg1;
5611   arg2 = (Dali::Vector4 *)jarg2;
5612   if (!arg2) {
5613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5614     return 0;
5615   }
5616   {
5617     try {
5618       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5619     } CALL_CATCH_EXCEPTION(0);
5620   }
5621
5622   jresult = (void *)result;
5623   return jresult;
5624 }
5625
5626
5627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5628   void * jresult ;
5629   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5630   Dali::Vector4 *arg2 = 0 ;
5631   Dali::Vector4 result;
5632
5633   arg1 = (Dali::Vector4 *)jarg1;
5634   arg2 = (Dali::Vector4 *)jarg2;
5635   if (!arg2) {
5636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5637     return 0;
5638   }
5639   {
5640     try {
5641       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5642     } CALL_CATCH_EXCEPTION(0);
5643   }
5644
5645   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5646   return jresult;
5647 }
5648
5649
5650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5651   void * jresult ;
5652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5653   float arg2 ;
5654   Dali::Vector4 result;
5655
5656   arg1 = (Dali::Vector4 *)jarg1;
5657   arg2 = (float)jarg2;
5658   {
5659     try {
5660       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5661     } CALL_CATCH_EXCEPTION(0);
5662   }
5663
5664   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5665   return jresult;
5666 }
5667
5668
5669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5670   void * jresult ;
5671   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5672   Dali::Vector4 *arg2 = 0 ;
5673   Dali::Vector4 *result = 0 ;
5674
5675   arg1 = (Dali::Vector4 *)jarg1;
5676   arg2 = (Dali::Vector4 *)jarg2;
5677   if (!arg2) {
5678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5679     return 0;
5680   }
5681   {
5682     try {
5683       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5684     } CALL_CATCH_EXCEPTION(0);
5685   }
5686
5687   jresult = (void *)result;
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5693   void * jresult ;
5694   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5695   float arg2 ;
5696   Dali::Vector4 *result = 0 ;
5697
5698   arg1 = (Dali::Vector4 *)jarg1;
5699   arg2 = (float)jarg2;
5700   {
5701     try {
5702       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5703     } CALL_CATCH_EXCEPTION(0);
5704   }
5705
5706   jresult = (void *)result;
5707   return jresult;
5708 }
5709
5710
5711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5712   void * jresult ;
5713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5714   Dali::Vector4 *arg2 = 0 ;
5715   Dali::Vector4 result;
5716
5717   arg1 = (Dali::Vector4 *)jarg1;
5718   arg2 = (Dali::Vector4 *)jarg2;
5719   if (!arg2) {
5720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5721     return 0;
5722   }
5723   {
5724     try {
5725       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5726     } CALL_CATCH_EXCEPTION(0);
5727   }
5728
5729   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5730   return jresult;
5731 }
5732
5733
5734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5735   void * jresult ;
5736   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5737   float arg2 ;
5738   Dali::Vector4 result;
5739
5740   arg1 = (Dali::Vector4 *)jarg1;
5741   arg2 = (float)jarg2;
5742   {
5743     try {
5744       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5745     } CALL_CATCH_EXCEPTION(0);
5746   }
5747
5748   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5754   void * jresult ;
5755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5756   Dali::Vector4 *arg2 = 0 ;
5757   Dali::Vector4 *result = 0 ;
5758
5759   arg1 = (Dali::Vector4 *)jarg1;
5760   arg2 = (Dali::Vector4 *)jarg2;
5761   if (!arg2) {
5762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5763     return 0;
5764   }
5765   {
5766     try {
5767       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5768     } CALL_CATCH_EXCEPTION(0);
5769   }
5770
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5777   void * jresult ;
5778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5779   float arg2 ;
5780   Dali::Vector4 *result = 0 ;
5781
5782   arg1 = (Dali::Vector4 *)jarg1;
5783   arg2 = (float)jarg2;
5784   {
5785     try {
5786       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5787     } CALL_CATCH_EXCEPTION(0);
5788   }
5789
5790   jresult = (void *)result;
5791   return jresult;
5792 }
5793
5794
5795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5796   void * jresult ;
5797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5798   Dali::Vector4 result;
5799
5800   arg1 = (Dali::Vector4 *)jarg1;
5801   {
5802     try {
5803       result = ((Dali::Vector4 const *)arg1)->operator -();
5804     } CALL_CATCH_EXCEPTION(0);
5805   }
5806
5807   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5808   return jresult;
5809 }
5810
5811
5812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5813   unsigned int jresult ;
5814   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5815   Dali::Vector4 *arg2 = 0 ;
5816   bool result;
5817
5818   arg1 = (Dali::Vector4 *)jarg1;
5819   arg2 = (Dali::Vector4 *)jarg2;
5820   if (!arg2) {
5821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5822     return 0;
5823   }
5824   {
5825     try {
5826       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5827     } CALL_CATCH_EXCEPTION(0);
5828   }
5829
5830   jresult = result;
5831   return jresult;
5832 }
5833
5834
5835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5836   unsigned int jresult ;
5837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5838   Dali::Vector4 *arg2 = 0 ;
5839   bool result;
5840
5841   arg1 = (Dali::Vector4 *)jarg1;
5842   arg2 = (Dali::Vector4 *)jarg2;
5843   if (!arg2) {
5844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5845     return 0;
5846   }
5847   {
5848     try {
5849       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5850     } CALL_CATCH_EXCEPTION(0);
5851   }
5852
5853   jresult = result;
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5859   float jresult ;
5860   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5861   unsigned int arg2 ;
5862   float *result = 0 ;
5863
5864   arg1 = (Dali::Vector4 *)jarg1;
5865   arg2 = (unsigned int)jarg2;
5866   {
5867     try {
5868       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5869     } CALL_CATCH_EXCEPTION(0);
5870   }
5871
5872   jresult = *result;
5873   return jresult;
5874 }
5875
5876
5877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5878   float jresult ;
5879   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5880   Dali::Vector3 *arg2 = 0 ;
5881   float result;
5882
5883   arg1 = (Dali::Vector4 *)jarg1;
5884   arg2 = (Dali::Vector3 *)jarg2;
5885   if (!arg2) {
5886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5887     return 0;
5888   }
5889   {
5890     try {
5891       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5892     } CALL_CATCH_EXCEPTION(0);
5893   }
5894
5895   jresult = result;
5896   return jresult;
5897 }
5898
5899
5900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5901   float jresult ;
5902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5903   Dali::Vector4 *arg2 = 0 ;
5904   float result;
5905
5906   arg1 = (Dali::Vector4 *)jarg1;
5907   arg2 = (Dali::Vector4 *)jarg2;
5908   if (!arg2) {
5909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5910     return 0;
5911   }
5912   {
5913     try {
5914       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5915     } CALL_CATCH_EXCEPTION(0);
5916   }
5917
5918   jresult = result;
5919   return jresult;
5920 }
5921
5922
5923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5924   float jresult ;
5925   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5926   Dali::Vector4 *arg2 = 0 ;
5927   float result;
5928
5929   arg1 = (Dali::Vector4 *)jarg1;
5930   arg2 = (Dali::Vector4 *)jarg2;
5931   if (!arg2) {
5932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5933     return 0;
5934   }
5935   {
5936     try {
5937       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5938     } CALL_CATCH_EXCEPTION(0);
5939   }
5940
5941   jresult = result;
5942   return jresult;
5943 }
5944
5945
5946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5947   void * jresult ;
5948   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5949   Dali::Vector4 *arg2 = 0 ;
5950   Dali::Vector4 result;
5951
5952   arg1 = (Dali::Vector4 *)jarg1;
5953   arg2 = (Dali::Vector4 *)jarg2;
5954   if (!arg2) {
5955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5956     return 0;
5957   }
5958   {
5959     try {
5960       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5961     } CALL_CATCH_EXCEPTION(0);
5962   }
5963
5964   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5965   return jresult;
5966 }
5967
5968
5969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5970   float jresult ;
5971   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5972   float result;
5973
5974   arg1 = (Dali::Vector4 *)jarg1;
5975   {
5976     try {
5977       result = (float)((Dali::Vector4 const *)arg1)->Length();
5978     } CALL_CATCH_EXCEPTION(0);
5979   }
5980
5981   jresult = result;
5982   return jresult;
5983 }
5984
5985
5986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5987   float jresult ;
5988   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5989   float result;
5990
5991   arg1 = (Dali::Vector4 *)jarg1;
5992   {
5993     try {
5994       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5995     } CALL_CATCH_EXCEPTION(0);
5996   }
5997
5998   jresult = result;
5999   return jresult;
6000 }
6001
6002
6003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
6004   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6005
6006   arg1 = (Dali::Vector4 *)jarg1;
6007   {
6008     try {
6009       (arg1)->Normalize();
6010     } CALL_CATCH_EXCEPTION();
6011   }
6012
6013 }
6014
6015
6016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6017   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6018   Dali::Vector4 *arg2 = 0 ;
6019   Dali::Vector4 *arg3 = 0 ;
6020
6021   arg1 = (Dali::Vector4 *)jarg1;
6022   arg2 = (Dali::Vector4 *)jarg2;
6023   if (!arg2) {
6024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6025     return ;
6026   }
6027   arg3 = (Dali::Vector4 *)jarg3;
6028   if (!arg3) {
6029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6030     return ;
6031   }
6032   {
6033     try {
6034       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
6035     } CALL_CATCH_EXCEPTION();
6036   }
6037
6038 }
6039
6040
6041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
6042   void * jresult ;
6043   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6044   float *result = 0 ;
6045
6046   arg1 = (Dali::Vector4 *)jarg1;
6047   {
6048     try {
6049       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
6050     } CALL_CATCH_EXCEPTION(0);
6051   }
6052
6053   jresult = (void *)result;
6054   return jresult;
6055 }
6056
6057
6058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
6059   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6060   float arg2 ;
6061
6062   arg1 = (Dali::Vector4 *)jarg1;
6063   arg2 = (float)jarg2;
6064   if (arg1) (arg1)->x = arg2;
6065 }
6066
6067
6068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
6069   float jresult ;
6070   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6071   float result;
6072
6073   arg1 = (Dali::Vector4 *)jarg1;
6074   result = (float) ((arg1)->x);
6075   jresult = result;
6076   return jresult;
6077 }
6078
6079
6080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
6081   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6082   float arg2 ;
6083
6084   arg1 = (Dali::Vector4 *)jarg1;
6085   arg2 = (float)jarg2;
6086   if (arg1) (arg1)->r = arg2;
6087 }
6088
6089
6090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
6091   float jresult ;
6092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6093   float result;
6094
6095   arg1 = (Dali::Vector4 *)jarg1;
6096   result = (float) ((arg1)->r);
6097   jresult = result;
6098   return jresult;
6099 }
6100
6101
6102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
6103   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6104   float arg2 ;
6105
6106   arg1 = (Dali::Vector4 *)jarg1;
6107   arg2 = (float)jarg2;
6108   if (arg1) (arg1)->s = arg2;
6109 }
6110
6111
6112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
6113   float jresult ;
6114   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6115   float result;
6116
6117   arg1 = (Dali::Vector4 *)jarg1;
6118   result = (float) ((arg1)->s);
6119   jresult = result;
6120   return jresult;
6121 }
6122
6123
6124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
6125   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6126   float arg2 ;
6127
6128   arg1 = (Dali::Vector4 *)jarg1;
6129   arg2 = (float)jarg2;
6130   if (arg1) (arg1)->y = arg2;
6131 }
6132
6133
6134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
6135   float jresult ;
6136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6137   float result;
6138
6139   arg1 = (Dali::Vector4 *)jarg1;
6140   result = (float) ((arg1)->y);
6141   jresult = result;
6142   return jresult;
6143 }
6144
6145
6146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6147   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6148   float arg2 ;
6149
6150   arg1 = (Dali::Vector4 *)jarg1;
6151   arg2 = (float)jarg2;
6152   if (arg1) (arg1)->g = arg2;
6153 }
6154
6155
6156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6157   float jresult ;
6158   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6159   float result;
6160
6161   arg1 = (Dali::Vector4 *)jarg1;
6162   result = (float) ((arg1)->g);
6163   jresult = result;
6164   return jresult;
6165 }
6166
6167
6168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6169   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6170   float arg2 ;
6171
6172   arg1 = (Dali::Vector4 *)jarg1;
6173   arg2 = (float)jarg2;
6174   if (arg1) (arg1)->t = arg2;
6175 }
6176
6177
6178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6179   float jresult ;
6180   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6181   float result;
6182
6183   arg1 = (Dali::Vector4 *)jarg1;
6184   result = (float) ((arg1)->t);
6185   jresult = result;
6186   return jresult;
6187 }
6188
6189
6190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
6191   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6192   float arg2 ;
6193
6194   arg1 = (Dali::Vector4 *)jarg1;
6195   arg2 = (float)jarg2;
6196   if (arg1) (arg1)->z = arg2;
6197 }
6198
6199
6200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
6201   float jresult ;
6202   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6203   float result;
6204
6205   arg1 = (Dali::Vector4 *)jarg1;
6206   result = (float) ((arg1)->z);
6207   jresult = result;
6208   return jresult;
6209 }
6210
6211
6212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6214   float arg2 ;
6215
6216   arg1 = (Dali::Vector4 *)jarg1;
6217   arg2 = (float)jarg2;
6218   if (arg1) (arg1)->b = arg2;
6219 }
6220
6221
6222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6223   float jresult ;
6224   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6225   float result;
6226
6227   arg1 = (Dali::Vector4 *)jarg1;
6228   result = (float) ((arg1)->b);
6229   jresult = result;
6230   return jresult;
6231 }
6232
6233
6234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6235   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6236   float arg2 ;
6237
6238   arg1 = (Dali::Vector4 *)jarg1;
6239   arg2 = (float)jarg2;
6240   if (arg1) (arg1)->p = arg2;
6241 }
6242
6243
6244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6245   float jresult ;
6246   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6247   float result;
6248
6249   arg1 = (Dali::Vector4 *)jarg1;
6250   result = (float) ((arg1)->p);
6251   jresult = result;
6252   return jresult;
6253 }
6254
6255
6256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6257   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6258   float arg2 ;
6259
6260   arg1 = (Dali::Vector4 *)jarg1;
6261   arg2 = (float)jarg2;
6262   if (arg1) (arg1)->w = arg2;
6263 }
6264
6265
6266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6267   float jresult ;
6268   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6269   float result;
6270
6271   arg1 = (Dali::Vector4 *)jarg1;
6272   result = (float) ((arg1)->w);
6273   jresult = result;
6274   return jresult;
6275 }
6276
6277
6278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6279   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6280   float arg2 ;
6281
6282   arg1 = (Dali::Vector4 *)jarg1;
6283   arg2 = (float)jarg2;
6284   if (arg1) (arg1)->a = arg2;
6285 }
6286
6287
6288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6289   float jresult ;
6290   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6291   float result;
6292
6293   arg1 = (Dali::Vector4 *)jarg1;
6294   result = (float) ((arg1)->a);
6295   jresult = result;
6296   return jresult;
6297 }
6298
6299
6300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6301   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6302   float arg2 ;
6303
6304   arg1 = (Dali::Vector4 *)jarg1;
6305   arg2 = (float)jarg2;
6306   if (arg1) (arg1)->q = arg2;
6307 }
6308
6309
6310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6311   float jresult ;
6312   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6313   float result;
6314
6315   arg1 = (Dali::Vector4 *)jarg1;
6316   result = (float) ((arg1)->q);
6317   jresult = result;
6318   return jresult;
6319 }
6320
6321
6322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6323   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6324
6325   arg1 = (Dali::Vector4 *)jarg1;
6326   {
6327     try {
6328       delete arg1;
6329     } CALL_CATCH_EXCEPTION();
6330   }
6331
6332 }
6333
6334
6335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6336   void * jresult ;
6337   Dali::Vector4 *arg1 = 0 ;
6338   Dali::Vector4 *arg2 = 0 ;
6339   Dali::Vector4 result;
6340
6341   arg1 = (Dali::Vector4 *)jarg1;
6342   if (!arg1) {
6343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6344     return 0;
6345   }
6346   arg2 = (Dali::Vector4 *)jarg2;
6347   if (!arg2) {
6348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6349     return 0;
6350   }
6351   {
6352     try {
6353       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6354     } CALL_CATCH_EXCEPTION(0);
6355   }
6356
6357   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6358   return jresult;
6359 }
6360
6361
6362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6363   void * jresult ;
6364   Dali::Vector4 *arg1 = 0 ;
6365   Dali::Vector4 *arg2 = 0 ;
6366   Dali::Vector4 result;
6367
6368   arg1 = (Dali::Vector4 *)jarg1;
6369   if (!arg1) {
6370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6371     return 0;
6372   }
6373   arg2 = (Dali::Vector4 *)jarg2;
6374   if (!arg2) {
6375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6376     return 0;
6377   }
6378   {
6379     try {
6380       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6381     } CALL_CATCH_EXCEPTION(0);
6382   }
6383
6384   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6385   return jresult;
6386 }
6387
6388
6389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6390   void * jresult ;
6391   Dali::Vector4 *arg1 = 0 ;
6392   float *arg2 = 0 ;
6393   float *arg3 = 0 ;
6394   float temp2 ;
6395   float temp3 ;
6396   Dali::Vector4 result;
6397
6398   arg1 = (Dali::Vector4 *)jarg1;
6399   if (!arg1) {
6400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6401     return 0;
6402   }
6403   temp2 = (float)jarg2;
6404   arg2 = &temp2;
6405   temp3 = (float)jarg3;
6406   arg3 = &temp3;
6407   {
6408     try {
6409       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6410     } CALL_CATCH_EXCEPTION(0);
6411   }
6412
6413   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6414   return jresult;
6415 }
6416
6417
6418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6419   void * jresult ;
6420   Dali::Uint16Pair *result = 0 ;
6421
6422   {
6423     try {
6424       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6425     } CALL_CATCH_EXCEPTION(0);
6426   }
6427
6428   jresult = (void *)result;
6429   return jresult;
6430 }
6431
6432
6433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6434   void * jresult ;
6435   uint32_t arg1 ;
6436   uint32_t arg2 ;
6437   Dali::Uint16Pair *result = 0 ;
6438
6439   arg1 = (uint32_t)jarg1;
6440   arg2 = (uint32_t)jarg2;
6441   {
6442     try {
6443       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6444     } CALL_CATCH_EXCEPTION(0);
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6453   void * jresult ;
6454   Dali::Uint16Pair *arg1 = 0 ;
6455   Dali::Uint16Pair *result = 0 ;
6456
6457   arg1 = (Dali::Uint16Pair *)jarg1;
6458   if (!arg1) {
6459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6460     return 0;
6461   }
6462   {
6463     try {
6464       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6465     } CALL_CATCH_EXCEPTION(0);
6466   }
6467
6468   jresult = (void *)result;
6469   return jresult;
6470 }
6471
6472
6473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6475   uint16_t arg2 ;
6476
6477   arg1 = (Dali::Uint16Pair *)jarg1;
6478   arg2 = (uint16_t)jarg2;
6479   {
6480     try {
6481       (arg1)->SetWidth(arg2);
6482     } CALL_CATCH_EXCEPTION();
6483   }
6484
6485 }
6486
6487
6488 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6489   unsigned short jresult ;
6490   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6491   uint16_t result;
6492
6493   arg1 = (Dali::Uint16Pair *)jarg1;
6494   {
6495     try {
6496       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6497     } CALL_CATCH_EXCEPTION(0);
6498   }
6499
6500   jresult = result;
6501   return jresult;
6502 }
6503
6504
6505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6506   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6507   uint16_t arg2 ;
6508
6509   arg1 = (Dali::Uint16Pair *)jarg1;
6510   arg2 = (uint16_t)jarg2;
6511   {
6512     try {
6513       (arg1)->SetHeight(arg2);
6514     } CALL_CATCH_EXCEPTION();
6515   }
6516
6517 }
6518
6519
6520 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6521   unsigned short jresult ;
6522   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6523   uint16_t result;
6524
6525   arg1 = (Dali::Uint16Pair *)jarg1;
6526   {
6527     try {
6528       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6529     } CALL_CATCH_EXCEPTION(0);
6530   }
6531
6532   jresult = result;
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6538   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6539   uint16_t arg2 ;
6540
6541   arg1 = (Dali::Uint16Pair *)jarg1;
6542   arg2 = (uint16_t)jarg2;
6543   {
6544     try {
6545       (arg1)->SetX(arg2);
6546     } CALL_CATCH_EXCEPTION();
6547   }
6548
6549 }
6550
6551
6552 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6553   unsigned short jresult ;
6554   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6555   uint16_t result;
6556
6557   arg1 = (Dali::Uint16Pair *)jarg1;
6558   {
6559     try {
6560       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6561     } CALL_CATCH_EXCEPTION(0);
6562   }
6563
6564   jresult = result;
6565   return jresult;
6566 }
6567
6568
6569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6570   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6571   uint16_t arg2 ;
6572
6573   arg1 = (Dali::Uint16Pair *)jarg1;
6574   arg2 = (uint16_t)jarg2;
6575   {
6576     try {
6577       (arg1)->SetY(arg2);
6578     } CALL_CATCH_EXCEPTION();
6579   }
6580
6581 }
6582
6583
6584 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6585   unsigned short jresult ;
6586   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6587   uint16_t result;
6588
6589   arg1 = (Dali::Uint16Pair *)jarg1;
6590   {
6591     try {
6592       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6593     } CALL_CATCH_EXCEPTION(0);
6594   }
6595
6596   jresult = result;
6597   return jresult;
6598 }
6599
6600
6601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6602   void * jresult ;
6603   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6604   Dali::Uint16Pair *arg2 = 0 ;
6605   Dali::Uint16Pair *result = 0 ;
6606
6607   arg1 = (Dali::Uint16Pair *)jarg1;
6608   arg2 = (Dali::Uint16Pair *)jarg2;
6609   if (!arg2) {
6610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6611     return 0;
6612   }
6613   {
6614     try {
6615       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6616     } CALL_CATCH_EXCEPTION(0);
6617   }
6618
6619   jresult = (void *)result;
6620   return jresult;
6621 }
6622
6623
6624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6625   unsigned int jresult ;
6626   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6627   Dali::Uint16Pair *arg2 = 0 ;
6628   bool result;
6629
6630   arg1 = (Dali::Uint16Pair *)jarg1;
6631   arg2 = (Dali::Uint16Pair *)jarg2;
6632   if (!arg2) {
6633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6634     return 0;
6635   }
6636   {
6637     try {
6638       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6639     } CALL_CATCH_EXCEPTION(0);
6640   }
6641
6642   jresult = result;
6643   return jresult;
6644 }
6645
6646
6647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6648   unsigned int jresult ;
6649   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6650   Dali::Uint16Pair *arg2 = 0 ;
6651   bool result;
6652
6653   arg1 = (Dali::Uint16Pair *)jarg1;
6654   arg2 = (Dali::Uint16Pair *)jarg2;
6655   if (!arg2) {
6656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6657     return 0;
6658   }
6659   {
6660     try {
6661       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6662     } CALL_CATCH_EXCEPTION(0);
6663   }
6664
6665   jresult = result;
6666   return jresult;
6667 }
6668
6669
6670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6671   unsigned int jresult ;
6672   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6673   Dali::Uint16Pair *arg2 = 0 ;
6674   bool result;
6675
6676   arg1 = (Dali::Uint16Pair *)jarg1;
6677   arg2 = (Dali::Uint16Pair *)jarg2;
6678   if (!arg2) {
6679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6680     return 0;
6681   }
6682   {
6683     try {
6684       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6685     } CALL_CATCH_EXCEPTION(0);
6686   }
6687
6688   jresult = result;
6689   return jresult;
6690 }
6691
6692
6693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6694   unsigned int jresult ;
6695   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6696   Dali::Uint16Pair *arg2 = 0 ;
6697   bool result;
6698
6699   arg1 = (Dali::Uint16Pair *)jarg1;
6700   arg2 = (Dali::Uint16Pair *)jarg2;
6701   if (!arg2) {
6702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6703     return 0;
6704   }
6705   {
6706     try {
6707       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6708     } CALL_CATCH_EXCEPTION(0);
6709   }
6710
6711   jresult = result;
6712   return jresult;
6713 }
6714
6715
6716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6717   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6718
6719   arg1 = (Dali::Uint16Pair *)jarg1;
6720   {
6721     try {
6722       delete arg1;
6723     } CALL_CATCH_EXCEPTION();
6724   }
6725
6726 }
6727
6728
6729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6730   void * jresult ;
6731   Dali::Degree *result = 0 ;
6732
6733   {
6734     try {
6735       result = (Dali::Degree *)new Dali::Degree();
6736     } CALL_CATCH_EXCEPTION(0);
6737   }
6738
6739   jresult = (void *)result;
6740   return jresult;
6741 }
6742
6743
6744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6745   void * jresult ;
6746   float arg1 ;
6747   Dali::Degree *result = 0 ;
6748
6749   arg1 = (float)jarg1;
6750   {
6751     try {
6752       result = (Dali::Degree *)new Dali::Degree(arg1);
6753     } CALL_CATCH_EXCEPTION(0);
6754   }
6755
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6762   void * jresult ;
6763   Dali::Radian arg1 ;
6764   Dali::Radian *argp1 ;
6765   Dali::Degree *result = 0 ;
6766
6767   argp1 = (Dali::Radian *)jarg1;
6768   if (!argp1) {
6769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6770     return 0;
6771   }
6772   arg1 = *argp1;
6773   {
6774     try {
6775       result = (Dali::Degree *)new Dali::Degree(arg1);
6776     } CALL_CATCH_EXCEPTION(0);
6777   }
6778
6779   jresult = (void *)result;
6780   return jresult;
6781 }
6782
6783
6784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6785   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6786   float arg2 ;
6787
6788   arg1 = (Dali::Degree *)jarg1;
6789   arg2 = (float)jarg2;
6790   if (arg1) (arg1)->degree = arg2;
6791 }
6792
6793
6794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6795   float jresult ;
6796   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6797   float result;
6798
6799   arg1 = (Dali::Degree *)jarg1;
6800   result = (float) ((arg1)->degree);
6801   jresult = result;
6802   return jresult;
6803 }
6804
6805
6806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6807   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6808
6809   arg1 = (Dali::Degree *)jarg1;
6810   {
6811     try {
6812       delete arg1;
6813     } CALL_CATCH_EXCEPTION();
6814   }
6815
6816 }
6817
6818
6819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6820   void * jresult ;
6821   Dali::Radian *result = 0 ;
6822
6823   result = (Dali::Radian *)&Dali::ANGLE_360;
6824   jresult = (void *)result;
6825   return jresult;
6826 }
6827
6828
6829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6830   void * jresult ;
6831   Dali::Radian *result = 0 ;
6832
6833   result = (Dali::Radian *)&Dali::ANGLE_315;
6834   jresult = (void *)result;
6835   return jresult;
6836 }
6837
6838
6839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6840   void * jresult ;
6841   Dali::Radian *result = 0 ;
6842
6843   result = (Dali::Radian *)&Dali::ANGLE_270;
6844   jresult = (void *)result;
6845   return jresult;
6846 }
6847
6848
6849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6850   void * jresult ;
6851   Dali::Radian *result = 0 ;
6852
6853   result = (Dali::Radian *)&Dali::ANGLE_225;
6854   jresult = (void *)result;
6855   return jresult;
6856 }
6857
6858
6859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6860   void * jresult ;
6861   Dali::Radian *result = 0 ;
6862
6863   result = (Dali::Radian *)&Dali::ANGLE_180;
6864   jresult = (void *)result;
6865   return jresult;
6866 }
6867
6868
6869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6870   void * jresult ;
6871   Dali::Radian *result = 0 ;
6872
6873   result = (Dali::Radian *)&Dali::ANGLE_135;
6874   jresult = (void *)result;
6875   return jresult;
6876 }
6877
6878
6879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6880   void * jresult ;
6881   Dali::Radian *result = 0 ;
6882
6883   result = (Dali::Radian *)&Dali::ANGLE_120;
6884   jresult = (void *)result;
6885   return jresult;
6886 }
6887
6888
6889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6890   void * jresult ;
6891   Dali::Radian *result = 0 ;
6892
6893   result = (Dali::Radian *)&Dali::ANGLE_90;
6894   jresult = (void *)result;
6895   return jresult;
6896 }
6897
6898
6899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6900   void * jresult ;
6901   Dali::Radian *result = 0 ;
6902
6903   result = (Dali::Radian *)&Dali::ANGLE_60;
6904   jresult = (void *)result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6910   void * jresult ;
6911   Dali::Radian *result = 0 ;
6912
6913   result = (Dali::Radian *)&Dali::ANGLE_45;
6914   jresult = (void *)result;
6915   return jresult;
6916 }
6917
6918
6919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6920   void * jresult ;
6921   Dali::Radian *result = 0 ;
6922
6923   result = (Dali::Radian *)&Dali::ANGLE_30;
6924   jresult = (void *)result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6930   void * jresult ;
6931   Dali::Radian *result = 0 ;
6932
6933   result = (Dali::Radian *)&Dali::ANGLE_0;
6934   jresult = (void *)result;
6935   return jresult;
6936 }
6937
6938
6939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6940   unsigned int jresult ;
6941   Dali::Degree *arg1 = 0 ;
6942   Dali::Degree *arg2 = 0 ;
6943   bool result;
6944
6945   arg1 = (Dali::Degree *)jarg1;
6946   if (!arg1) {
6947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6948     return 0;
6949   }
6950   arg2 = (Dali::Degree *)jarg2;
6951   if (!arg2) {
6952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6953     return 0;
6954   }
6955   {
6956     try {
6957       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6958     } CALL_CATCH_EXCEPTION(0);
6959   }
6960
6961   jresult = result;
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6967   unsigned int jresult ;
6968   Dali::Degree *arg1 = 0 ;
6969   Dali::Degree *arg2 = 0 ;
6970   bool result;
6971
6972   arg1 = (Dali::Degree *)jarg1;
6973   if (!arg1) {
6974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6975     return 0;
6976   }
6977   arg2 = (Dali::Degree *)jarg2;
6978   if (!arg2) {
6979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6980     return 0;
6981   }
6982   {
6983     try {
6984       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6985     } CALL_CATCH_EXCEPTION(0);
6986   }
6987
6988   jresult = result;
6989   return jresult;
6990 }
6991
6992
6993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6994   void * jresult ;
6995   Dali::Degree arg1 ;
6996   float arg2 ;
6997   float arg3 ;
6998   Dali::Degree *argp1 ;
6999   Dali::Degree result;
7000
7001   argp1 = (Dali::Degree *)jarg1;
7002   if (!argp1) {
7003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7004     return 0;
7005   }
7006   arg1 = *argp1;
7007   arg2 = (float)jarg2;
7008   arg3 = (float)jarg3;
7009   {
7010     try {
7011       result = Dali::Clamp(arg1,arg2,arg3);
7012     } CALL_CATCH_EXCEPTION(0);
7013   }
7014
7015   jresult = new Dali::Degree((const Dali::Degree &)result);
7016   return jresult;
7017 }
7018
7019
7020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
7021   void * jresult ;
7022   Dali::Radian *result = 0 ;
7023
7024   {
7025     try {
7026       result = (Dali::Radian *)new Dali::Radian();
7027     } CALL_CATCH_EXCEPTION(0);
7028   }
7029
7030   jresult = (void *)result;
7031   return jresult;
7032 }
7033
7034
7035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
7036   void * jresult ;
7037   float arg1 ;
7038   Dali::Radian *result = 0 ;
7039
7040   arg1 = (float)jarg1;
7041   {
7042     try {
7043       result = (Dali::Radian *)new Dali::Radian(arg1);
7044     } CALL_CATCH_EXCEPTION(0);
7045   }
7046
7047   jresult = (void *)result;
7048   return jresult;
7049 }
7050
7051
7052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
7053   void * jresult ;
7054   Dali::Degree arg1 ;
7055   Dali::Degree *argp1 ;
7056   Dali::Radian *result = 0 ;
7057
7058   argp1 = (Dali::Degree *)jarg1;
7059   if (!argp1) {
7060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7061     return 0;
7062   }
7063   arg1 = *argp1;
7064   {
7065     try {
7066       result = (Dali::Radian *)new Dali::Radian(arg1);
7067     } CALL_CATCH_EXCEPTION(0);
7068   }
7069
7070   jresult = (void *)result;
7071   return jresult;
7072 }
7073
7074
7075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
7076   void * jresult ;
7077   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7078   float arg2 ;
7079   Dali::Radian *result = 0 ;
7080
7081   arg1 = (Dali::Radian *)jarg1;
7082   arg2 = (float)jarg2;
7083   {
7084     try {
7085       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7086     } CALL_CATCH_EXCEPTION(0);
7087   }
7088
7089   jresult = (void *)result;
7090   return jresult;
7091 }
7092
7093
7094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
7095   void * jresult ;
7096   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7097   Dali::Degree arg2 ;
7098   Dali::Degree *argp2 ;
7099   Dali::Radian *result = 0 ;
7100
7101   arg1 = (Dali::Radian *)jarg1;
7102   argp2 = (Dali::Degree *)jarg2;
7103   if (!argp2) {
7104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7105     return 0;
7106   }
7107   arg2 = *argp2;
7108   {
7109     try {
7110       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7111     } CALL_CATCH_EXCEPTION(0);
7112   }
7113
7114   jresult = (void *)result;
7115   return jresult;
7116 }
7117
7118
7119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
7120   float jresult ;
7121   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7122   float result;
7123
7124   arg1 = (Dali::Radian *)jarg1;
7125   {
7126     try {
7127       result = (float)((Dali::Radian const *)arg1)->operator float();
7128     } CALL_CATCH_EXCEPTION(0);
7129   }
7130
7131   jresult = result;
7132   return jresult;
7133 }
7134
7135
7136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
7137   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7138   float arg2 ;
7139
7140   arg1 = (Dali::Radian *)jarg1;
7141   arg2 = (float)jarg2;
7142   if (arg1) (arg1)->radian = arg2;
7143 }
7144
7145
7146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
7147   float jresult ;
7148   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7149   float result;
7150
7151   arg1 = (Dali::Radian *)jarg1;
7152   result = (float) ((arg1)->radian);
7153   jresult = result;
7154   return jresult;
7155 }
7156
7157
7158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
7159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7160
7161   arg1 = (Dali::Radian *)jarg1;
7162   {
7163     try {
7164       delete arg1;
7165     } CALL_CATCH_EXCEPTION();
7166   }
7167
7168 }
7169
7170
7171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7172   unsigned int jresult ;
7173   Dali::Radian arg1 ;
7174   Dali::Radian arg2 ;
7175   Dali::Radian *argp1 ;
7176   Dali::Radian *argp2 ;
7177   bool result;
7178
7179   argp1 = (Dali::Radian *)jarg1;
7180   if (!argp1) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7182     return 0;
7183   }
7184   arg1 = *argp1;
7185   argp2 = (Dali::Radian *)jarg2;
7186   if (!argp2) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7188     return 0;
7189   }
7190   arg2 = *argp2;
7191   {
7192     try {
7193       result = (bool)Dali::operator ==(arg1,arg2);
7194     } CALL_CATCH_EXCEPTION(0);
7195   }
7196
7197   jresult = result;
7198   return jresult;
7199 }
7200
7201
7202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7203   unsigned int jresult ;
7204   Dali::Radian arg1 ;
7205   Dali::Radian arg2 ;
7206   Dali::Radian *argp1 ;
7207   Dali::Radian *argp2 ;
7208   bool result;
7209
7210   argp1 = (Dali::Radian *)jarg1;
7211   if (!argp1) {
7212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7213     return 0;
7214   }
7215   arg1 = *argp1;
7216   argp2 = (Dali::Radian *)jarg2;
7217   if (!argp2) {
7218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7219     return 0;
7220   }
7221   arg2 = *argp2;
7222   {
7223     try {
7224       result = (bool)Dali::operator !=(arg1,arg2);
7225     } CALL_CATCH_EXCEPTION(0);
7226   }
7227
7228   jresult = result;
7229   return jresult;
7230 }
7231
7232
7233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7234   unsigned int jresult ;
7235   Dali::Radian arg1 ;
7236   Dali::Degree arg2 ;
7237   Dali::Radian *argp1 ;
7238   Dali::Degree *argp2 ;
7239   bool result;
7240
7241   argp1 = (Dali::Radian *)jarg1;
7242   if (!argp1) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7244     return 0;
7245   }
7246   arg1 = *argp1;
7247   argp2 = (Dali::Degree *)jarg2;
7248   if (!argp2) {
7249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7250     return 0;
7251   }
7252   arg2 = *argp2;
7253   {
7254     try {
7255       result = (bool)Dali::operator ==(arg1,arg2);
7256     } CALL_CATCH_EXCEPTION(0);
7257   }
7258
7259   jresult = result;
7260   return jresult;
7261 }
7262
7263
7264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7265   unsigned int jresult ;
7266   Dali::Radian arg1 ;
7267   Dali::Degree arg2 ;
7268   Dali::Radian *argp1 ;
7269   Dali::Degree *argp2 ;
7270   bool result;
7271
7272   argp1 = (Dali::Radian *)jarg1;
7273   if (!argp1) {
7274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7275     return 0;
7276   }
7277   arg1 = *argp1;
7278   argp2 = (Dali::Degree *)jarg2;
7279   if (!argp2) {
7280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7281     return 0;
7282   }
7283   arg2 = *argp2;
7284   {
7285     try {
7286       result = (bool)Dali::operator !=(arg1,arg2);
7287     } CALL_CATCH_EXCEPTION(0);
7288   }
7289
7290   jresult = result;
7291   return jresult;
7292 }
7293
7294
7295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7296   unsigned int jresult ;
7297   Dali::Degree arg1 ;
7298   Dali::Radian arg2 ;
7299   Dali::Degree *argp1 ;
7300   Dali::Radian *argp2 ;
7301   bool result;
7302
7303   argp1 = (Dali::Degree *)jarg1;
7304   if (!argp1) {
7305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7306     return 0;
7307   }
7308   arg1 = *argp1;
7309   argp2 = (Dali::Radian *)jarg2;
7310   if (!argp2) {
7311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7312     return 0;
7313   }
7314   arg2 = *argp2;
7315   {
7316     try {
7317       result = (bool)Dali::operator ==(arg1,arg2);
7318     } CALL_CATCH_EXCEPTION(0);
7319   }
7320
7321   jresult = result;
7322   return jresult;
7323 }
7324
7325
7326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7327   unsigned int jresult ;
7328   Dali::Degree arg1 ;
7329   Dali::Radian arg2 ;
7330   Dali::Degree *argp1 ;
7331   Dali::Radian *argp2 ;
7332   bool result;
7333
7334   argp1 = (Dali::Degree *)jarg1;
7335   if (!argp1) {
7336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7337     return 0;
7338   }
7339   arg1 = *argp1;
7340   argp2 = (Dali::Radian *)jarg2;
7341   if (!argp2) {
7342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7343     return 0;
7344   }
7345   arg2 = *argp2;
7346   {
7347     try {
7348       result = (bool)Dali::operator !=(arg1,arg2);
7349     } CALL_CATCH_EXCEPTION(0);
7350   }
7351
7352   jresult = result;
7353   return jresult;
7354 }
7355
7356
7357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7358   unsigned int jresult ;
7359   Dali::Radian arg1 ;
7360   Dali::Radian arg2 ;
7361   Dali::Radian *argp1 ;
7362   Dali::Radian *argp2 ;
7363   bool result;
7364
7365   argp1 = (Dali::Radian *)jarg1;
7366   if (!argp1) {
7367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7368     return 0;
7369   }
7370   arg1 = *argp1;
7371   argp2 = (Dali::Radian *)jarg2;
7372   if (!argp2) {
7373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7374     return 0;
7375   }
7376   arg2 = *argp2;
7377   {
7378     try {
7379       result = (bool)Dali::operator >(arg1,arg2);
7380     } CALL_CATCH_EXCEPTION(0);
7381   }
7382
7383   jresult = result;
7384   return jresult;
7385 }
7386
7387
7388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7389   unsigned int jresult ;
7390   Dali::Radian arg1 ;
7391   Dali::Degree arg2 ;
7392   Dali::Radian *argp1 ;
7393   Dali::Degree *argp2 ;
7394   bool result;
7395
7396   argp1 = (Dali::Radian *)jarg1;
7397   if (!argp1) {
7398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7399     return 0;
7400   }
7401   arg1 = *argp1;
7402   argp2 = (Dali::Degree *)jarg2;
7403   if (!argp2) {
7404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7405     return 0;
7406   }
7407   arg2 = *argp2;
7408   {
7409     try {
7410       result = (bool)Dali::operator >(arg1,arg2);
7411     } CALL_CATCH_EXCEPTION(0);
7412   }
7413
7414   jresult = result;
7415   return jresult;
7416 }
7417
7418
7419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7420   unsigned int jresult ;
7421   Dali::Degree arg1 ;
7422   Dali::Radian arg2 ;
7423   Dali::Degree *argp1 ;
7424   Dali::Radian *argp2 ;
7425   bool result;
7426
7427   argp1 = (Dali::Degree *)jarg1;
7428   if (!argp1) {
7429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7430     return 0;
7431   }
7432   arg1 = *argp1;
7433   argp2 = (Dali::Radian *)jarg2;
7434   if (!argp2) {
7435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7436     return 0;
7437   }
7438   arg2 = *argp2;
7439   {
7440     try {
7441       result = (bool)Dali::operator >(arg1,arg2);
7442     } CALL_CATCH_EXCEPTION(0);
7443   }
7444
7445   jresult = result;
7446   return jresult;
7447 }
7448
7449
7450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7451   unsigned int jresult ;
7452   Dali::Radian arg1 ;
7453   Dali::Radian arg2 ;
7454   Dali::Radian *argp1 ;
7455   Dali::Radian *argp2 ;
7456   bool result;
7457
7458   argp1 = (Dali::Radian *)jarg1;
7459   if (!argp1) {
7460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7461     return 0;
7462   }
7463   arg1 = *argp1;
7464   argp2 = (Dali::Radian *)jarg2;
7465   if (!argp2) {
7466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7467     return 0;
7468   }
7469   arg2 = *argp2;
7470   {
7471     try {
7472       result = (bool)Dali::operator <(arg1,arg2);
7473     } CALL_CATCH_EXCEPTION(0);
7474   }
7475
7476   jresult = result;
7477   return jresult;
7478 }
7479
7480
7481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7482   unsigned int jresult ;
7483   Dali::Radian arg1 ;
7484   Dali::Degree arg2 ;
7485   Dali::Radian *argp1 ;
7486   Dali::Degree *argp2 ;
7487   bool result;
7488
7489   argp1 = (Dali::Radian *)jarg1;
7490   if (!argp1) {
7491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7492     return 0;
7493   }
7494   arg1 = *argp1;
7495   argp2 = (Dali::Degree *)jarg2;
7496   if (!argp2) {
7497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7498     return 0;
7499   }
7500   arg2 = *argp2;
7501   {
7502     try {
7503       result = (bool)Dali::operator <(arg1,arg2);
7504     } CALL_CATCH_EXCEPTION(0);
7505   }
7506
7507   jresult = result;
7508   return jresult;
7509 }
7510
7511
7512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7513   unsigned int jresult ;
7514   Dali::Degree arg1 ;
7515   Dali::Radian arg2 ;
7516   Dali::Degree *argp1 ;
7517   Dali::Radian *argp2 ;
7518   bool result;
7519
7520   argp1 = (Dali::Degree *)jarg1;
7521   if (!argp1) {
7522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7523     return 0;
7524   }
7525   arg1 = *argp1;
7526   argp2 = (Dali::Radian *)jarg2;
7527   if (!argp2) {
7528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7529     return 0;
7530   }
7531   arg2 = *argp2;
7532   {
7533     try {
7534       result = (bool)Dali::operator <(arg1,arg2);
7535     } CALL_CATCH_EXCEPTION(0);
7536   }
7537
7538   jresult = result;
7539   return jresult;
7540 }
7541
7542
7543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7544   void * jresult ;
7545   Dali::Radian arg1 ;
7546   float arg2 ;
7547   Dali::Radian *argp1 ;
7548   Dali::Radian result;
7549
7550   argp1 = (Dali::Radian *)jarg1;
7551   if (!argp1) {
7552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7553     return 0;
7554   }
7555   arg1 = *argp1;
7556   arg2 = (float)jarg2;
7557   {
7558     try {
7559       result = Dali::operator *(arg1,arg2);
7560     } CALL_CATCH_EXCEPTION(0);
7561   }
7562
7563   jresult = new Dali::Radian((const Dali::Radian &)result);
7564   return jresult;
7565 }
7566
7567
7568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7569   void * jresult ;
7570   Dali::Radian arg1 ;
7571   Dali::Radian *argp1 ;
7572   Dali::Radian result;
7573
7574   argp1 = (Dali::Radian *)jarg1;
7575   if (!argp1) {
7576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7577     return 0;
7578   }
7579   arg1 = *argp1;
7580   {
7581     try {
7582       result = Dali::operator -(arg1);
7583     } CALL_CATCH_EXCEPTION(0);
7584   }
7585
7586   jresult = new Dali::Radian((const Dali::Radian &)result);
7587   return jresult;
7588 }
7589
7590
7591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7592   void * jresult ;
7593   Dali::Radian arg1 ;
7594   float arg2 ;
7595   float arg3 ;
7596   Dali::Radian *argp1 ;
7597   Dali::Radian result;
7598
7599   argp1 = (Dali::Radian *)jarg1;
7600   if (!argp1) {
7601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7602     return 0;
7603   }
7604   arg1 = *argp1;
7605   arg2 = (float)jarg2;
7606   arg3 = (float)jarg3;
7607   {
7608     try {
7609       result = Dali::Clamp(arg1,arg2,arg3);
7610     } CALL_CATCH_EXCEPTION(0);
7611   }
7612
7613   jresult = new Dali::Radian((const Dali::Radian &)result);
7614   return jresult;
7615 }
7616
7617
7618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
7619   void * jresult ;
7620   Dali::Quaternion *result = 0 ;
7621
7622   {
7623     try {
7624       result = (Dali::Quaternion *)new Dali::Quaternion();
7625     } CALL_CATCH_EXCEPTION(0);
7626   }
7627
7628   jresult = (void *)result;
7629   return jresult;
7630 }
7631
7632
7633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
7634   void * jresult ;
7635   Dali::Radian arg1 ;
7636   Dali::Vector3 *arg2 = 0 ;
7637   Dali::Radian *argp1 ;
7638   Dali::Quaternion *result = 0 ;
7639
7640   argp1 = (Dali::Radian *)jarg1;
7641   if (!argp1) {
7642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7643     return 0;
7644   }
7645   arg1 = *argp1;
7646   arg2 = (Dali::Vector3 *)jarg2;
7647   if (!arg2) {
7648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7649     return 0;
7650   }
7651   {
7652     try {
7653       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
7654     } CALL_CATCH_EXCEPTION(0);
7655   }
7656
7657   jresult = (void *)result;
7658   return jresult;
7659 }
7660
7661
7662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
7663   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7664
7665   arg1 = (Dali::Quaternion *)jarg1;
7666   {
7667     try {
7668       delete arg1;
7669     } CALL_CATCH_EXCEPTION();
7670   }
7671
7672 }
7673
7674
7675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
7676   void * jresult ;
7677   Dali::Quaternion *result = 0 ;
7678
7679   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
7680   jresult = (void *)result;
7681   return jresult;
7682 }
7683
7684
7685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
7686   unsigned int jresult ;
7687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7688   bool result;
7689
7690   arg1 = (Dali::Quaternion *)jarg1;
7691   {
7692     try {
7693       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
7694     } CALL_CATCH_EXCEPTION(0);
7695   }
7696
7697   jresult = result;
7698   return jresult;
7699 }
7700
7701
7702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
7703   unsigned int jresult ;
7704   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7705   Dali::Vector3 *arg2 = 0 ;
7706   Dali::Radian *arg3 = 0 ;
7707   bool result;
7708
7709   arg1 = (Dali::Quaternion *)jarg1;
7710   arg2 = (Dali::Vector3 *)jarg2;
7711   if (!arg2) {
7712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7713     return 0;
7714   }
7715   arg3 = (Dali::Radian *)jarg3;
7716   if (!arg3) {
7717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
7718     return 0;
7719   }
7720   {
7721     try {
7722       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
7723     } CALL_CATCH_EXCEPTION(0);
7724   }
7725
7726   jresult = result;
7727   return jresult;
7728 }
7729
7730
7731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
7732   void * jresult ;
7733   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7734   Dali::Quaternion *arg2 = 0 ;
7735   Dali::Quaternion result;
7736
7737   arg1 = (Dali::Quaternion *)jarg1;
7738   arg2 = (Dali::Quaternion *)jarg2;
7739   if (!arg2) {
7740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7741     return 0;
7742   }
7743   {
7744     try {
7745       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
7746     } CALL_CATCH_EXCEPTION(0);
7747   }
7748
7749   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7750   return jresult;
7751 }
7752
7753
7754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7755   void * jresult ;
7756   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7757   Dali::Quaternion *arg2 = 0 ;
7758   Dali::Quaternion result;
7759
7760   arg1 = (Dali::Quaternion *)jarg1;
7761   arg2 = (Dali::Quaternion *)jarg2;
7762   if (!arg2) {
7763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7764     return 0;
7765   }
7766   {
7767     try {
7768       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
7769     } CALL_CATCH_EXCEPTION(0);
7770   }
7771
7772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7778   void * jresult ;
7779   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7780   Dali::Quaternion *arg2 = 0 ;
7781   Dali::Quaternion result;
7782
7783   arg1 = (Dali::Quaternion *)jarg1;
7784   arg2 = (Dali::Quaternion *)jarg2;
7785   if (!arg2) {
7786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7787     return 0;
7788   }
7789   {
7790     try {
7791       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
7792     } CALL_CATCH_EXCEPTION(0);
7793   }
7794
7795   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7796   return jresult;
7797 }
7798
7799
7800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
7801   void * jresult ;
7802   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7803   Dali::Vector3 *arg2 = 0 ;
7804   Dali::Vector3 result;
7805
7806   arg1 = (Dali::Quaternion *)jarg1;
7807   arg2 = (Dali::Vector3 *)jarg2;
7808   if (!arg2) {
7809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7810     return 0;
7811   }
7812   {
7813     try {
7814       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
7815     } CALL_CATCH_EXCEPTION(0);
7816   }
7817
7818   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7819   return jresult;
7820 }
7821
7822
7823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
7824   void * jresult ;
7825   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7826   Dali::Quaternion *arg2 = 0 ;
7827   Dali::Quaternion result;
7828
7829   arg1 = (Dali::Quaternion *)jarg1;
7830   arg2 = (Dali::Quaternion *)jarg2;
7831   if (!arg2) {
7832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7833     return 0;
7834   }
7835   {
7836     try {
7837       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
7838     } CALL_CATCH_EXCEPTION(0);
7839   }
7840
7841   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7842   return jresult;
7843 }
7844
7845
7846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
7847   void * jresult ;
7848   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7849   float arg2 ;
7850   Dali::Quaternion result;
7851
7852   arg1 = (Dali::Quaternion *)jarg1;
7853   arg2 = (float)jarg2;
7854   {
7855     try {
7856       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
7857     } CALL_CATCH_EXCEPTION(0);
7858   }
7859
7860   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7861   return jresult;
7862 }
7863
7864
7865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
7866   void * jresult ;
7867   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7868   float arg2 ;
7869   Dali::Quaternion result;
7870
7871   arg1 = (Dali::Quaternion *)jarg1;
7872   arg2 = (float)jarg2;
7873   {
7874     try {
7875       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
7876     } CALL_CATCH_EXCEPTION(0);
7877   }
7878
7879   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7880   return jresult;
7881 }
7882
7883
7884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
7885   void * jresult ;
7886   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7887   Dali::Quaternion result;
7888
7889   arg1 = (Dali::Quaternion *)jarg1;
7890   {
7891     try {
7892       result = ((Dali::Quaternion const *)arg1)->operator -();
7893     } CALL_CATCH_EXCEPTION(0);
7894   }
7895
7896   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
7902   void * jresult ;
7903   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7904   Dali::Quaternion *arg2 = 0 ;
7905   Dali::Quaternion *result = 0 ;
7906
7907   arg1 = (Dali::Quaternion *)jarg1;
7908   arg2 = (Dali::Quaternion *)jarg2;
7909   if (!arg2) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7911     return 0;
7912   }
7913   {
7914     try {
7915       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
7916     } CALL_CATCH_EXCEPTION(0);
7917   }
7918
7919   jresult = (void *)result;
7920   return jresult;
7921 }
7922
7923
7924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
7925   void * jresult ;
7926   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7927   Dali::Quaternion *arg2 = 0 ;
7928   Dali::Quaternion *result = 0 ;
7929
7930   arg1 = (Dali::Quaternion *)jarg1;
7931   arg2 = (Dali::Quaternion *)jarg2;
7932   if (!arg2) {
7933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7934     return 0;
7935   }
7936   {
7937     try {
7938       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
7939     } CALL_CATCH_EXCEPTION(0);
7940   }
7941
7942   jresult = (void *)result;
7943   return jresult;
7944 }
7945
7946
7947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7948   void * jresult ;
7949   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7950   Dali::Quaternion *arg2 = 0 ;
7951   Dali::Quaternion *result = 0 ;
7952
7953   arg1 = (Dali::Quaternion *)jarg1;
7954   arg2 = (Dali::Quaternion *)jarg2;
7955   if (!arg2) {
7956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7957     return 0;
7958   }
7959   {
7960     try {
7961       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
7962     } CALL_CATCH_EXCEPTION(0);
7963   }
7964
7965   jresult = (void *)result;
7966   return jresult;
7967 }
7968
7969
7970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7971   void * jresult ;
7972   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7973   float arg2 ;
7974   Dali::Quaternion *result = 0 ;
7975
7976   arg1 = (Dali::Quaternion *)jarg1;
7977   arg2 = (float)jarg2;
7978   {
7979     try {
7980       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
7981     } CALL_CATCH_EXCEPTION(0);
7982   }
7983
7984   jresult = (void *)result;
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
7990   void * jresult ;
7991   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7992   float arg2 ;
7993   Dali::Quaternion *result = 0 ;
7994
7995   arg1 = (Dali::Quaternion *)jarg1;
7996   arg2 = (float)jarg2;
7997   {
7998     try {
7999       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
8000     } CALL_CATCH_EXCEPTION(0);
8001   }
8002
8003   jresult = (void *)result;
8004   return jresult;
8005 }
8006
8007
8008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
8009   unsigned int jresult ;
8010   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8011   Dali::Quaternion *arg2 = 0 ;
8012   bool result;
8013
8014   arg1 = (Dali::Quaternion *)jarg1;
8015   arg2 = (Dali::Quaternion *)jarg2;
8016   if (!arg2) {
8017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8018     return 0;
8019   }
8020   {
8021     try {
8022       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
8023     } CALL_CATCH_EXCEPTION(0);
8024   }
8025
8026   jresult = result;
8027   return jresult;
8028 }
8029
8030
8031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
8032   unsigned int jresult ;
8033   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8034   Dali::Quaternion *arg2 = 0 ;
8035   bool result;
8036
8037   arg1 = (Dali::Quaternion *)jarg1;
8038   arg2 = (Dali::Quaternion *)jarg2;
8039   if (!arg2) {
8040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8041     return 0;
8042   }
8043   {
8044     try {
8045       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
8046     } CALL_CATCH_EXCEPTION(0);
8047   }
8048
8049   jresult = result;
8050   return jresult;
8051 }
8052
8053
8054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
8055   float jresult ;
8056   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8057   float result;
8058
8059   arg1 = (Dali::Quaternion *)jarg1;
8060   {
8061     try {
8062       result = (float)((Dali::Quaternion const *)arg1)->Length();
8063     } CALL_CATCH_EXCEPTION(0);
8064   }
8065
8066   jresult = result;
8067   return jresult;
8068 }
8069
8070
8071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
8072   float jresult ;
8073   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8074   float result;
8075
8076   arg1 = (Dali::Quaternion *)jarg1;
8077   {
8078     try {
8079       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
8080     } CALL_CATCH_EXCEPTION(0);
8081   }
8082
8083   jresult = result;
8084   return jresult;
8085 }
8086
8087
8088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
8089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8090
8091   arg1 = (Dali::Quaternion *)jarg1;
8092   {
8093     try {
8094       (arg1)->Normalize();
8095     } CALL_CATCH_EXCEPTION();
8096   }
8097
8098 }
8099
8100
8101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
8102   void * jresult ;
8103   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8104   Dali::Quaternion result;
8105
8106   arg1 = (Dali::Quaternion *)jarg1;
8107   {
8108     try {
8109       result = ((Dali::Quaternion const *)arg1)->Normalized();
8110     } CALL_CATCH_EXCEPTION(0);
8111   }
8112
8113   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8114   return jresult;
8115 }
8116
8117
8118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
8119   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8120
8121   arg1 = (Dali::Quaternion *)jarg1;
8122   {
8123     try {
8124       (arg1)->Conjugate();
8125     } CALL_CATCH_EXCEPTION();
8126   }
8127
8128 }
8129
8130
8131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
8132   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8133
8134   arg1 = (Dali::Quaternion *)jarg1;
8135   {
8136     try {
8137       (arg1)->Invert();
8138     } CALL_CATCH_EXCEPTION();
8139   }
8140
8141 }
8142
8143
8144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
8145   void * jresult ;
8146   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8147   Dali::Quaternion result;
8148
8149   arg1 = (Dali::Quaternion *)jarg1;
8150   {
8151     try {
8152       result = ((Dali::Quaternion const *)arg1)->Log();
8153     } CALL_CATCH_EXCEPTION(0);
8154   }
8155
8156   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8157   return jresult;
8158 }
8159
8160
8161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
8162   void * jresult ;
8163   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8164   Dali::Quaternion result;
8165
8166   arg1 = (Dali::Quaternion *)jarg1;
8167   {
8168     try {
8169       result = ((Dali::Quaternion const *)arg1)->Exp();
8170     } CALL_CATCH_EXCEPTION(0);
8171   }
8172
8173   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8174   return jresult;
8175 }
8176
8177
8178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
8179   float jresult ;
8180   Dali::Quaternion *arg1 = 0 ;
8181   Dali::Quaternion *arg2 = 0 ;
8182   float result;
8183
8184   arg1 = (Dali::Quaternion *)jarg1;
8185   if (!arg1) {
8186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8187     return 0;
8188   }
8189   arg2 = (Dali::Quaternion *)jarg2;
8190   if (!arg2) {
8191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8192     return 0;
8193   }
8194   {
8195     try {
8196       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8197     } CALL_CATCH_EXCEPTION(0);
8198   }
8199
8200   jresult = result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
8206   void * jresult ;
8207   Dali::Quaternion *arg1 = 0 ;
8208   Dali::Quaternion *arg2 = 0 ;
8209   float arg3 ;
8210   Dali::Quaternion result;
8211
8212   arg1 = (Dali::Quaternion *)jarg1;
8213   if (!arg1) {
8214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8215     return 0;
8216   }
8217   arg2 = (Dali::Quaternion *)jarg2;
8218   if (!arg2) {
8219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8220     return 0;
8221   }
8222   arg3 = (float)jarg3;
8223   {
8224     try {
8225       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8226     } CALL_CATCH_EXCEPTION(0);
8227   }
8228
8229   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8230   return jresult;
8231 }
8232
8233
8234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
8235   void * jresult ;
8236   Dali::Quaternion *arg1 = 0 ;
8237   Dali::Quaternion *arg2 = 0 ;
8238   float arg3 ;
8239   Dali::Quaternion result;
8240
8241   arg1 = (Dali::Quaternion *)jarg1;
8242   if (!arg1) {
8243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8244     return 0;
8245   }
8246   arg2 = (Dali::Quaternion *)jarg2;
8247   if (!arg2) {
8248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8249     return 0;
8250   }
8251   arg3 = (float)jarg3;
8252   {
8253     try {
8254       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8255     } CALL_CATCH_EXCEPTION(0);
8256   }
8257
8258   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8259   return jresult;
8260 }
8261
8262
8263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
8264   void * jresult ;
8265   Dali::Quaternion *arg1 = 0 ;
8266   Dali::Quaternion *arg2 = 0 ;
8267   float arg3 ;
8268   Dali::Quaternion result;
8269
8270   arg1 = (Dali::Quaternion *)jarg1;
8271   if (!arg1) {
8272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8273     return 0;
8274   }
8275   arg2 = (Dali::Quaternion *)jarg2;
8276   if (!arg2) {
8277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8278     return 0;
8279   }
8280   arg3 = (float)jarg3;
8281   {
8282     try {
8283       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8284     } CALL_CATCH_EXCEPTION(0);
8285   }
8286
8287   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8288   return jresult;
8289 }
8290
8291
8292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
8293   void * jresult ;
8294   Dali::Quaternion *arg1 = 0 ;
8295   Dali::Quaternion *arg2 = 0 ;
8296   Dali::Quaternion *arg3 = 0 ;
8297   Dali::Quaternion *arg4 = 0 ;
8298   float arg5 ;
8299   Dali::Quaternion result;
8300
8301   arg1 = (Dali::Quaternion *)jarg1;
8302   if (!arg1) {
8303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8304     return 0;
8305   }
8306   arg2 = (Dali::Quaternion *)jarg2;
8307   if (!arg2) {
8308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8309     return 0;
8310   }
8311   arg3 = (Dali::Quaternion *)jarg3;
8312   if (!arg3) {
8313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8314     return 0;
8315   }
8316   arg4 = (Dali::Quaternion *)jarg4;
8317   if (!arg4) {
8318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8319     return 0;
8320   }
8321   arg5 = (float)jarg5;
8322   {
8323     try {
8324       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
8325     } CALL_CATCH_EXCEPTION(0);
8326   }
8327
8328   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
8334   float jresult ;
8335   Dali::Quaternion *arg1 = 0 ;
8336   Dali::Quaternion *arg2 = 0 ;
8337   float result;
8338
8339   arg1 = (Dali::Quaternion *)jarg1;
8340   if (!arg1) {
8341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8342     return 0;
8343   }
8344   arg2 = (Dali::Quaternion *)jarg2;
8345   if (!arg2) {
8346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8347     return 0;
8348   }
8349   {
8350     try {
8351       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8352     } CALL_CATCH_EXCEPTION(0);
8353   }
8354
8355   jresult = result;
8356   return jresult;
8357 }
8358
8359
8360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
8361   void * jresult ;
8362   Dali::Matrix *result = 0 ;
8363
8364   {
8365     try {
8366       result = (Dali::Matrix *)new Dali::Matrix();
8367     } CALL_CATCH_EXCEPTION(0);
8368   }
8369
8370   jresult = (void *)result;
8371   return jresult;
8372 }
8373
8374
8375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
8376   void * jresult ;
8377   bool arg1 ;
8378   Dali::Matrix *result = 0 ;
8379
8380   arg1 = jarg1 ? true : false;
8381   {
8382     try {
8383       result = (Dali::Matrix *)new Dali::Matrix(arg1);
8384     } CALL_CATCH_EXCEPTION(0);
8385   }
8386
8387   jresult = (void *)result;
8388   return jresult;
8389 }
8390
8391
8392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
8393   void * jresult ;
8394   float *arg1 = (float *) 0 ;
8395   Dali::Matrix *result = 0 ;
8396
8397   arg1 = jarg1;
8398   {
8399     try {
8400       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
8401     } CALL_CATCH_EXCEPTION(0);
8402   }
8403
8404   jresult = (void *)result;
8405
8406
8407   return jresult;
8408 }
8409
8410
8411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
8412   void * jresult ;
8413   Dali::Quaternion *arg1 = 0 ;
8414   Dali::Matrix *result = 0 ;
8415
8416   arg1 = (Dali::Quaternion *)jarg1;
8417   if (!arg1) {
8418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8419     return 0;
8420   }
8421   {
8422     try {
8423       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
8424     } CALL_CATCH_EXCEPTION(0);
8425   }
8426
8427   jresult = (void *)result;
8428   return jresult;
8429 }
8430
8431
8432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
8433   void * jresult ;
8434   Dali::Matrix *arg1 = 0 ;
8435   Dali::Matrix *result = 0 ;
8436
8437   arg1 = (Dali::Matrix *)jarg1;
8438   if (!arg1) {
8439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8440     return 0;
8441   }
8442   {
8443     try {
8444       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
8445     } CALL_CATCH_EXCEPTION(0);
8446   }
8447
8448   jresult = (void *)result;
8449   return jresult;
8450 }
8451
8452
8453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
8454   void * jresult ;
8455   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8456   Dali::Matrix *arg2 = 0 ;
8457   Dali::Matrix *result = 0 ;
8458
8459   arg1 = (Dali::Matrix *)jarg1;
8460   arg2 = (Dali::Matrix *)jarg2;
8461   if (!arg2) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8463     return 0;
8464   }
8465   {
8466     try {
8467       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8468     } CALL_CATCH_EXCEPTION(0);
8469   }
8470
8471   jresult = (void *)result;
8472   return jresult;
8473 }
8474
8475
8476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
8477   void * jresult ;
8478   Dali::Matrix *result = 0 ;
8479
8480   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
8481   jresult = (void *)result;
8482   return jresult;
8483 }
8484
8485
8486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
8487   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8488
8489   arg1 = (Dali::Matrix *)jarg1;
8490   {
8491     try {
8492       (arg1)->SetIdentity();
8493     } CALL_CATCH_EXCEPTION();
8494   }
8495
8496 }
8497
8498
8499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
8500   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8501   Dali::Vector3 *arg2 = 0 ;
8502
8503   arg1 = (Dali::Matrix *)jarg1;
8504   arg2 = (Dali::Vector3 *)jarg2;
8505   if (!arg2) {
8506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8507     return ;
8508   }
8509   {
8510     try {
8511       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
8512     } CALL_CATCH_EXCEPTION();
8513   }
8514
8515 }
8516
8517
8518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
8519   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8520   Dali::Matrix *arg2 = 0 ;
8521
8522   arg1 = (Dali::Matrix *)jarg1;
8523   arg2 = (Dali::Matrix *)jarg2;
8524   if (!arg2) {
8525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8526     return ;
8527   }
8528   {
8529     try {
8530       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
8531     } CALL_CATCH_EXCEPTION();
8532   }
8533
8534 }
8535
8536
8537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
8538   unsigned int jresult ;
8539   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8540   bool result;
8541
8542   arg1 = (Dali::Matrix *)jarg1;
8543   {
8544     try {
8545       result = (bool)(arg1)->Invert();
8546     } CALL_CATCH_EXCEPTION(0);
8547   }
8548
8549   jresult = result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
8555   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8556
8557   arg1 = (Dali::Matrix *)jarg1;
8558   {
8559     try {
8560       (arg1)->Transpose();
8561     } CALL_CATCH_EXCEPTION();
8562   }
8563
8564 }
8565
8566
8567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
8568   void * jresult ;
8569   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8570   Dali::Vector3 result;
8571
8572   arg1 = (Dali::Matrix *)jarg1;
8573   {
8574     try {
8575       result = ((Dali::Matrix const *)arg1)->GetXAxis();
8576     } CALL_CATCH_EXCEPTION(0);
8577   }
8578
8579   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8580   return jresult;
8581 }
8582
8583
8584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
8585   void * jresult ;
8586   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8587   Dali::Vector3 result;
8588
8589   arg1 = (Dali::Matrix *)jarg1;
8590   {
8591     try {
8592       result = ((Dali::Matrix const *)arg1)->GetYAxis();
8593     } CALL_CATCH_EXCEPTION(0);
8594   }
8595
8596   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8597   return jresult;
8598 }
8599
8600
8601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
8602   void * jresult ;
8603   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8604   Dali::Vector3 result;
8605
8606   arg1 = (Dali::Matrix *)jarg1;
8607   {
8608     try {
8609       result = ((Dali::Matrix const *)arg1)->GetZAxis();
8610     } CALL_CATCH_EXCEPTION(0);
8611   }
8612
8613   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8614   return jresult;
8615 }
8616
8617
8618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
8619   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8620   Dali::Vector3 *arg2 = 0 ;
8621
8622   arg1 = (Dali::Matrix *)jarg1;
8623   arg2 = (Dali::Vector3 *)jarg2;
8624   if (!arg2) {
8625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8626     return ;
8627   }
8628   {
8629     try {
8630       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
8631     } CALL_CATCH_EXCEPTION();
8632   }
8633
8634 }
8635
8636
8637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
8638   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8639   Dali::Vector3 *arg2 = 0 ;
8640
8641   arg1 = (Dali::Matrix *)jarg1;
8642   arg2 = (Dali::Vector3 *)jarg2;
8643   if (!arg2) {
8644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8645     return ;
8646   }
8647   {
8648     try {
8649       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
8650     } CALL_CATCH_EXCEPTION();
8651   }
8652
8653 }
8654
8655
8656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
8657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8658   Dali::Vector3 *arg2 = 0 ;
8659
8660   arg1 = (Dali::Matrix *)jarg1;
8661   arg2 = (Dali::Vector3 *)jarg2;
8662   if (!arg2) {
8663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8664     return ;
8665   }
8666   {
8667     try {
8668       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
8669     } CALL_CATCH_EXCEPTION();
8670   }
8671
8672 }
8673
8674
8675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
8676   void * jresult ;
8677   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8678   Dali::Vector4 *result = 0 ;
8679
8680   arg1 = (Dali::Matrix *)jarg1;
8681   {
8682     try {
8683       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
8684     } CALL_CATCH_EXCEPTION(0);
8685   }
8686
8687   jresult = (void *)result;
8688   return jresult;
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
8693   void * jresult ;
8694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8695   Dali::Vector3 *result = 0 ;
8696
8697   arg1 = (Dali::Matrix *)jarg1;
8698   {
8699     try {
8700       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
8701     } CALL_CATCH_EXCEPTION(0);
8702   }
8703
8704   jresult = (void *)result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
8710   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8711   Dali::Vector4 *arg2 = 0 ;
8712
8713   arg1 = (Dali::Matrix *)jarg1;
8714   arg2 = (Dali::Vector4 *)jarg2;
8715   if (!arg2) {
8716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8717     return ;
8718   }
8719   {
8720     try {
8721       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
8722     } CALL_CATCH_EXCEPTION();
8723   }
8724
8725 }
8726
8727
8728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
8729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8730   Dali::Vector3 *arg2 = 0 ;
8731
8732   arg1 = (Dali::Matrix *)jarg1;
8733   arg2 = (Dali::Vector3 *)jarg2;
8734   if (!arg2) {
8735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8736     return ;
8737   }
8738   {
8739     try {
8740       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
8741     } CALL_CATCH_EXCEPTION();
8742   }
8743
8744 }
8745
8746
8747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
8748   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8749
8750   arg1 = (Dali::Matrix *)jarg1;
8751   {
8752     try {
8753       (arg1)->OrthoNormalize();
8754     } CALL_CATCH_EXCEPTION();
8755   }
8756
8757 }
8758
8759
8760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
8761   void * jresult ;
8762   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8763   float *result = 0 ;
8764
8765   arg1 = (Dali::Matrix *)jarg1;
8766   {
8767     try {
8768       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
8769     } CALL_CATCH_EXCEPTION(0);
8770   }
8771
8772   jresult = (void *)result;
8773   return jresult;
8774 }
8775
8776
8777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
8778   Dali::Matrix *arg1 = 0 ;
8779   Dali::Matrix *arg2 = 0 ;
8780   Dali::Matrix *arg3 = 0 ;
8781
8782   arg1 = (Dali::Matrix *)jarg1;
8783   if (!arg1) {
8784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8785     return ;
8786   }
8787   arg2 = (Dali::Matrix *)jarg2;
8788   if (!arg2) {
8789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8790     return ;
8791   }
8792   arg3 = (Dali::Matrix *)jarg3;
8793   if (!arg3) {
8794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8795     return ;
8796   }
8797   {
8798     try {
8799       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
8800     } CALL_CATCH_EXCEPTION();
8801   }
8802
8803 }
8804
8805
8806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
8807   Dali::Matrix *arg1 = 0 ;
8808   Dali::Matrix *arg2 = 0 ;
8809   Dali::Quaternion *arg3 = 0 ;
8810
8811   arg1 = (Dali::Matrix *)jarg1;
8812   if (!arg1) {
8813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8814     return ;
8815   }
8816   arg2 = (Dali::Matrix *)jarg2;
8817   if (!arg2) {
8818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8819     return ;
8820   }
8821   arg3 = (Dali::Quaternion *)jarg3;
8822   if (!arg3) {
8823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8824     return ;
8825   }
8826   {
8827     try {
8828       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
8829     } CALL_CATCH_EXCEPTION();
8830   }
8831
8832 }
8833
8834
8835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
8836   void * jresult ;
8837   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8838   Dali::Vector4 *arg2 = 0 ;
8839   Dali::Vector4 result;
8840
8841   arg1 = (Dali::Matrix *)jarg1;
8842   arg2 = (Dali::Vector4 *)jarg2;
8843   if (!arg2) {
8844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8845     return 0;
8846   }
8847   {
8848     try {
8849       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
8850     } CALL_CATCH_EXCEPTION(0);
8851   }
8852
8853   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8854   return jresult;
8855 }
8856
8857
8858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8859   unsigned int jresult ;
8860   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8861   Dali::Matrix *arg2 = 0 ;
8862   bool result;
8863
8864   arg1 = (Dali::Matrix *)jarg1;
8865   arg2 = (Dali::Matrix *)jarg2;
8866   if (!arg2) {
8867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8868     return 0;
8869   }
8870   {
8871     try {
8872       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8873     } CALL_CATCH_EXCEPTION(0);
8874   }
8875
8876   jresult = result;
8877   return jresult;
8878 }
8879
8880
8881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8882   unsigned int jresult ;
8883   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8884   Dali::Matrix *arg2 = 0 ;
8885   bool result;
8886
8887   arg1 = (Dali::Matrix *)jarg1;
8888   arg2 = (Dali::Matrix *)jarg2;
8889   if (!arg2) {
8890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8891     return 0;
8892   }
8893   {
8894     try {
8895       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8896     } CALL_CATCH_EXCEPTION(0);
8897   }
8898
8899   jresult = result;
8900   return jresult;
8901 }
8902
8903
8904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8905   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8906   Dali::Vector3 *arg2 = 0 ;
8907   Dali::Quaternion *arg3 = 0 ;
8908   Dali::Vector3 *arg4 = 0 ;
8909
8910   arg1 = (Dali::Matrix *)jarg1;
8911   arg2 = (Dali::Vector3 *)jarg2;
8912   if (!arg2) {
8913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8914     return ;
8915   }
8916   arg3 = (Dali::Quaternion *)jarg3;
8917   if (!arg3) {
8918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8919     return ;
8920   }
8921   arg4 = (Dali::Vector3 *)jarg4;
8922   if (!arg4) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8924     return ;
8925   }
8926   {
8927     try {
8928       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8929     } CALL_CATCH_EXCEPTION();
8930   }
8931
8932 }
8933
8934
8935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8937   Dali::Vector3 *arg2 = 0 ;
8938   Dali::Quaternion *arg3 = 0 ;
8939   Dali::Vector3 *arg4 = 0 ;
8940
8941   arg1 = (Dali::Matrix *)jarg1;
8942   arg2 = (Dali::Vector3 *)jarg2;
8943   if (!arg2) {
8944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8945     return ;
8946   }
8947   arg3 = (Dali::Quaternion *)jarg3;
8948   if (!arg3) {
8949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8950     return ;
8951   }
8952   arg4 = (Dali::Vector3 *)jarg4;
8953   if (!arg4) {
8954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8955     return ;
8956   }
8957   {
8958     try {
8959       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8960     } CALL_CATCH_EXCEPTION();
8961   }
8962
8963 }
8964
8965
8966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8967   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8968   Dali::Vector3 *arg2 = 0 ;
8969   Dali::Vector3 *arg3 = 0 ;
8970   Dali::Vector3 *arg4 = 0 ;
8971   Dali::Vector3 *arg5 = 0 ;
8972
8973   arg1 = (Dali::Matrix *)jarg1;
8974   arg2 = (Dali::Vector3 *)jarg2;
8975   if (!arg2) {
8976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8977     return ;
8978   }
8979   arg3 = (Dali::Vector3 *)jarg3;
8980   if (!arg3) {
8981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8982     return ;
8983   }
8984   arg4 = (Dali::Vector3 *)jarg4;
8985   if (!arg4) {
8986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8987     return ;
8988   }
8989   arg5 = (Dali::Vector3 *)jarg5;
8990   if (!arg5) {
8991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8992     return ;
8993   }
8994   {
8995     try {
8996       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8997     } CALL_CATCH_EXCEPTION();
8998   }
8999
9000 }
9001
9002
9003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
9004   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9005   Dali::Vector3 *arg2 = 0 ;
9006   Dali::Quaternion *arg3 = 0 ;
9007   Dali::Vector3 *arg4 = 0 ;
9008
9009   arg1 = (Dali::Matrix *)jarg1;
9010   arg2 = (Dali::Vector3 *)jarg2;
9011   if (!arg2) {
9012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9013     return ;
9014   }
9015   arg3 = (Dali::Quaternion *)jarg3;
9016   if (!arg3) {
9017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
9018     return ;
9019   }
9020   arg4 = (Dali::Vector3 *)jarg4;
9021   if (!arg4) {
9022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9023     return ;
9024   }
9025   {
9026     try {
9027       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
9028     } CALL_CATCH_EXCEPTION();
9029   }
9030
9031 }
9032
9033
9034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
9035   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9036
9037   arg1 = (Dali::Matrix *)jarg1;
9038   {
9039     try {
9040       delete arg1;
9041     } CALL_CATCH_EXCEPTION();
9042   }
9043
9044 }
9045
9046
9047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
9048   void * jresult ;
9049   Dali::Matrix3 *result = 0 ;
9050
9051   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
9052   jresult = (void *)result;
9053   return jresult;
9054 }
9055
9056
9057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
9058   void * jresult ;
9059   Dali::Matrix3 *result = 0 ;
9060
9061   {
9062     try {
9063       result = (Dali::Matrix3 *)new Dali::Matrix3();
9064     } CALL_CATCH_EXCEPTION(0);
9065   }
9066
9067   jresult = (void *)result;
9068   return jresult;
9069 }
9070
9071
9072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
9073   void * jresult ;
9074   Dali::Matrix3 *arg1 = 0 ;
9075   Dali::Matrix3 *result = 0 ;
9076
9077   arg1 = (Dali::Matrix3 *)jarg1;
9078   if (!arg1) {
9079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9080     return 0;
9081   }
9082   {
9083     try {
9084       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
9085     } CALL_CATCH_EXCEPTION(0);
9086   }
9087
9088   jresult = (void *)result;
9089   return jresult;
9090 }
9091
9092
9093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
9094   void * jresult ;
9095   Dali::Matrix *arg1 = 0 ;
9096   Dali::Matrix3 *result = 0 ;
9097
9098   arg1 = (Dali::Matrix *)jarg1;
9099   if (!arg1) {
9100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9101     return 0;
9102   }
9103   {
9104     try {
9105       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
9106     } CALL_CATCH_EXCEPTION(0);
9107   }
9108
9109   jresult = (void *)result;
9110   return jresult;
9111 }
9112
9113
9114 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) {
9115   void * jresult ;
9116   float arg1 ;
9117   float arg2 ;
9118   float arg3 ;
9119   float arg4 ;
9120   float arg5 ;
9121   float arg6 ;
9122   float arg7 ;
9123   float arg8 ;
9124   float arg9 ;
9125   Dali::Matrix3 *result = 0 ;
9126
9127   arg1 = (float)jarg1;
9128   arg2 = (float)jarg2;
9129   arg3 = (float)jarg3;
9130   arg4 = (float)jarg4;
9131   arg5 = (float)jarg5;
9132   arg6 = (float)jarg6;
9133   arg7 = (float)jarg7;
9134   arg8 = (float)jarg8;
9135   arg9 = (float)jarg9;
9136   {
9137     try {
9138       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
9139     } CALL_CATCH_EXCEPTION(0);
9140   }
9141
9142   jresult = (void *)result;
9143   return jresult;
9144 }
9145
9146
9147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
9148   void * jresult ;
9149   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9150   Dali::Matrix3 *arg2 = 0 ;
9151   Dali::Matrix3 *result = 0 ;
9152
9153   arg1 = (Dali::Matrix3 *)jarg1;
9154   arg2 = (Dali::Matrix3 *)jarg2;
9155   if (!arg2) {
9156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9157     return 0;
9158   }
9159   {
9160     try {
9161       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
9162     } CALL_CATCH_EXCEPTION(0);
9163   }
9164
9165   jresult = (void *)result;
9166   return jresult;
9167 }
9168
9169
9170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
9171   void * jresult ;
9172   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9173   Dali::Matrix *arg2 = 0 ;
9174   Dali::Matrix3 *result = 0 ;
9175
9176   arg1 = (Dali::Matrix3 *)jarg1;
9177   arg2 = (Dali::Matrix *)jarg2;
9178   if (!arg2) {
9179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9180     return 0;
9181   }
9182   {
9183     try {
9184       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
9185     } CALL_CATCH_EXCEPTION(0);
9186   }
9187
9188   jresult = (void *)result;
9189   return jresult;
9190 }
9191
9192
9193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
9194   unsigned int jresult ;
9195   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9196   Dali::Matrix3 *arg2 = 0 ;
9197   bool result;
9198
9199   arg1 = (Dali::Matrix3 *)jarg1;
9200   arg2 = (Dali::Matrix3 *)jarg2;
9201   if (!arg2) {
9202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9203     return 0;
9204   }
9205   {
9206     try {
9207       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
9208     } CALL_CATCH_EXCEPTION(0);
9209   }
9210
9211   jresult = result;
9212   return jresult;
9213 }
9214
9215
9216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
9217   unsigned int jresult ;
9218   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9219   Dali::Matrix3 *arg2 = 0 ;
9220   bool result;
9221
9222   arg1 = (Dali::Matrix3 *)jarg1;
9223   arg2 = (Dali::Matrix3 *)jarg2;
9224   if (!arg2) {
9225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9226     return 0;
9227   }
9228   {
9229     try {
9230       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
9231     } CALL_CATCH_EXCEPTION(0);
9232   }
9233
9234   jresult = result;
9235   return jresult;
9236 }
9237
9238
9239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
9240   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9241
9242   arg1 = (Dali::Matrix3 *)jarg1;
9243   {
9244     try {
9245       delete arg1;
9246     } CALL_CATCH_EXCEPTION();
9247   }
9248
9249 }
9250
9251
9252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
9253   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9254
9255   arg1 = (Dali::Matrix3 *)jarg1;
9256   {
9257     try {
9258       (arg1)->SetIdentity();
9259     } CALL_CATCH_EXCEPTION();
9260   }
9261
9262 }
9263
9264
9265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
9266   void * jresult ;
9267   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9268   float *result = 0 ;
9269
9270   arg1 = (Dali::Matrix3 *)jarg1;
9271   {
9272     try {
9273       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
9274     } CALL_CATCH_EXCEPTION(0);
9275   }
9276
9277   jresult = (void *)result;
9278   return jresult;
9279 }
9280
9281
9282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
9283   unsigned int jresult ;
9284   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9285   bool result;
9286
9287   arg1 = (Dali::Matrix3 *)jarg1;
9288   {
9289     try {
9290       result = (bool)(arg1)->Invert();
9291     } CALL_CATCH_EXCEPTION(0);
9292   }
9293
9294   jresult = result;
9295   return jresult;
9296 }
9297
9298
9299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
9300   unsigned int jresult ;
9301   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9302   bool result;
9303
9304   arg1 = (Dali::Matrix3 *)jarg1;
9305   {
9306     try {
9307       result = (bool)(arg1)->Transpose();
9308     } CALL_CATCH_EXCEPTION(0);
9309   }
9310
9311   jresult = result;
9312   return jresult;
9313 }
9314
9315
9316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
9317   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9318   float arg2 ;
9319
9320   arg1 = (Dali::Matrix3 *)jarg1;
9321   arg2 = (float)jarg2;
9322   {
9323     try {
9324       (arg1)->Scale(arg2);
9325     } CALL_CATCH_EXCEPTION();
9326   }
9327
9328 }
9329
9330
9331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
9332   float jresult ;
9333   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9334   float result;
9335
9336   arg1 = (Dali::Matrix3 *)jarg1;
9337   {
9338     try {
9339       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
9340     } CALL_CATCH_EXCEPTION(0);
9341   }
9342
9343   jresult = result;
9344   return jresult;
9345 }
9346
9347
9348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
9349   unsigned int jresult ;
9350   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9351   bool result;
9352
9353   arg1 = (Dali::Matrix3 *)jarg1;
9354   {
9355     try {
9356       result = (bool)(arg1)->ScaledInverseTranspose();
9357     } CALL_CATCH_EXCEPTION(0);
9358   }
9359
9360   jresult = result;
9361   return jresult;
9362 }
9363
9364
9365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
9366   Dali::Matrix3 *arg1 = 0 ;
9367   Dali::Matrix3 *arg2 = 0 ;
9368   Dali::Matrix3 *arg3 = 0 ;
9369
9370   arg1 = (Dali::Matrix3 *)jarg1;
9371   if (!arg1) {
9372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
9373     return ;
9374   }
9375   arg2 = (Dali::Matrix3 *)jarg2;
9376   if (!arg2) {
9377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9378     return ;
9379   }
9380   arg3 = (Dali::Matrix3 *)jarg3;
9381   if (!arg3) {
9382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9383     return ;
9384   }
9385   {
9386     try {
9387       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
9388     } CALL_CATCH_EXCEPTION();
9389   }
9390
9391 }
9392
9393
9394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
9395   float jresult ;
9396   float arg1 ;
9397   float arg2 ;
9398   float result;
9399
9400   arg1 = (float)jarg1;
9401   arg2 = (float)jarg2;
9402   {
9403     try {
9404       result = (float)Dali::Random::Range(arg1,arg2);
9405     } CALL_CATCH_EXCEPTION(0);
9406   }
9407
9408   jresult = result;
9409   return jresult;
9410 }
9411
9412
9413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
9414   void * jresult ;
9415   Dali::Vector4 result;
9416
9417   {
9418     try {
9419       result = Dali::Random::Axis();
9420     } CALL_CATCH_EXCEPTION(0);
9421   }
9422
9423   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
9429   void * jresult ;
9430   Dali::AngleAxis *result = 0 ;
9431
9432   {
9433     try {
9434       result = (Dali::AngleAxis *)new Dali::AngleAxis();
9435     } CALL_CATCH_EXCEPTION(0);
9436   }
9437
9438   jresult = (void *)result;
9439   return jresult;
9440 }
9441
9442
9443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
9444   void * jresult ;
9445   Dali::Radian arg1 ;
9446   Dali::Vector3 *arg2 = 0 ;
9447   Dali::Radian *argp1 ;
9448   Dali::AngleAxis *result = 0 ;
9449
9450   argp1 = (Dali::Radian *)jarg1;
9451   if (!argp1) {
9452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9453     return 0;
9454   }
9455   arg1 = *argp1;
9456   arg2 = (Dali::Vector3 *)jarg2;
9457   if (!arg2) {
9458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9459     return 0;
9460   }
9461   {
9462     try {
9463       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
9464     } CALL_CATCH_EXCEPTION(0);
9465   }
9466
9467   jresult = (void *)result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
9473   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9474   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
9475
9476   arg1 = (Dali::AngleAxis *)jarg1;
9477   arg2 = (Dali::Radian *)jarg2;
9478   if (arg1) (arg1)->angle = *arg2;
9479 }
9480
9481
9482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
9483   void * jresult ;
9484   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9485   Dali::Radian *result = 0 ;
9486
9487   arg1 = (Dali::AngleAxis *)jarg1;
9488   result = (Dali::Radian *)& ((arg1)->angle);
9489   jresult = (void *)result;
9490   return jresult;
9491 }
9492
9493
9494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
9495   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9496   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
9497
9498   arg1 = (Dali::AngleAxis *)jarg1;
9499   arg2 = (Dali::Vector3 *)jarg2;
9500   if (arg1) (arg1)->axis = *arg2;
9501 }
9502
9503
9504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
9505   void * jresult ;
9506   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9507   Dali::Vector3 *result = 0 ;
9508
9509   arg1 = (Dali::AngleAxis *)jarg1;
9510   result = (Dali::Vector3 *)& ((arg1)->axis);
9511   jresult = (void *)result;
9512   return jresult;
9513 }
9514
9515
9516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
9517   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9518
9519   arg1 = (Dali::AngleAxis *)jarg1;
9520   {
9521     try {
9522       delete arg1;
9523     } CALL_CATCH_EXCEPTION();
9524   }
9525
9526 }
9527
9528
9529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9530   unsigned int jresult ;
9531   Dali::AngleAxis *arg1 = 0 ;
9532   Dali::AngleAxis *arg2 = 0 ;
9533   bool result;
9534
9535   arg1 = (Dali::AngleAxis *)jarg1;
9536   if (!arg1) {
9537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9538     return 0;
9539   }
9540   arg2 = (Dali::AngleAxis *)jarg2;
9541   if (!arg2) {
9542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9543     return 0;
9544   }
9545   {
9546     try {
9547       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9548     } CALL_CATCH_EXCEPTION(0);
9549   }
9550
9551   jresult = result;
9552   return jresult;
9553 }
9554
9555
9556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9557   unsigned int jresult ;
9558   unsigned int arg1 ;
9559   unsigned int result;
9560
9561   arg1 = (unsigned int)jarg1;
9562   {
9563     try {
9564       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9565     } CALL_CATCH_EXCEPTION(0);
9566   }
9567
9568   jresult = result;
9569   return jresult;
9570 }
9571
9572
9573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9574   unsigned int jresult ;
9575   unsigned int arg1 ;
9576   bool result;
9577
9578   arg1 = (unsigned int)jarg1;
9579   {
9580     try {
9581       result = (bool)Dali::IsPowerOfTwo(arg1);
9582     } CALL_CATCH_EXCEPTION(0);
9583   }
9584
9585   jresult = result;
9586   return jresult;
9587 }
9588
9589
9590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9591   float jresult ;
9592   float arg1 ;
9593   float arg2 ;
9594   float result;
9595
9596   arg1 = (float)jarg1;
9597   arg2 = (float)jarg2;
9598   {
9599     try {
9600       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9601     } CALL_CATCH_EXCEPTION(0);
9602   }
9603
9604   jresult = result;
9605   return jresult;
9606 }
9607
9608
9609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9610   unsigned int jresult ;
9611   float arg1 ;
9612   bool result;
9613
9614   arg1 = (float)jarg1;
9615   {
9616     try {
9617       result = (bool)Dali::EqualsZero(arg1);
9618     } CALL_CATCH_EXCEPTION(0);
9619   }
9620
9621   jresult = result;
9622   return jresult;
9623 }
9624
9625
9626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9627   unsigned int jresult ;
9628   float arg1 ;
9629   float arg2 ;
9630   bool result;
9631
9632   arg1 = (float)jarg1;
9633   arg2 = (float)jarg2;
9634   {
9635     try {
9636       result = (bool)Dali::Equals(arg1,arg2);
9637     } CALL_CATCH_EXCEPTION(0);
9638   }
9639
9640   jresult = result;
9641   return jresult;
9642 }
9643
9644
9645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9646   unsigned int jresult ;
9647   float arg1 ;
9648   float arg2 ;
9649   float arg3 ;
9650   bool result;
9651
9652   arg1 = (float)jarg1;
9653   arg2 = (float)jarg2;
9654   arg3 = (float)jarg3;
9655   {
9656     try {
9657       result = (bool)Dali::Equals(arg1,arg2,arg3);
9658     } CALL_CATCH_EXCEPTION(0);
9659   }
9660
9661   jresult = result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9667   float jresult ;
9668   float arg1 ;
9669   int arg2 ;
9670   float result;
9671
9672   arg1 = (float)jarg1;
9673   arg2 = (int)jarg2;
9674   {
9675     try {
9676       result = (float)Dali::Round(arg1,arg2);
9677     } CALL_CATCH_EXCEPTION(0);
9678   }
9679
9680   jresult = result;
9681   return jresult;
9682 }
9683
9684
9685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9686   float jresult ;
9687   float arg1 ;
9688   float arg2 ;
9689   float arg3 ;
9690   float result;
9691
9692   arg1 = (float)jarg1;
9693   arg2 = (float)jarg2;
9694   arg3 = (float)jarg3;
9695   {
9696     try {
9697       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9698     } CALL_CATCH_EXCEPTION(0);
9699   }
9700
9701   jresult = result;
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9707   float jresult ;
9708   float arg1 ;
9709   float arg2 ;
9710   float arg3 ;
9711   float arg4 ;
9712   float result;
9713
9714   arg1 = (float)jarg1;
9715   arg2 = (float)jarg2;
9716   arg3 = (float)jarg3;
9717   arg4 = (float)jarg4;
9718   {
9719     try {
9720       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9721     } CALL_CATCH_EXCEPTION(0);
9722   }
9723
9724   jresult = result;
9725   return jresult;
9726 }
9727
9728
9729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9730   int jresult ;
9731   int result;
9732
9733   result = (int)(int)Dali::Property::INVALID_INDEX;
9734   jresult = result;
9735   return jresult;
9736 }
9737
9738
9739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9740   int jresult ;
9741   int result;
9742
9743   result = (int)(int)Dali::Property::INVALID_KEY;
9744   jresult = result;
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9750   int jresult ;
9751   int result;
9752
9753   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9754   jresult = result;
9755   return jresult;
9756 }
9757
9758
9759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9760   void * jresult ;
9761   Dali::Handle *arg1 = 0 ;
9762   Dali::Property::Index arg2 ;
9763   Dali::Property *result = 0 ;
9764
9765   arg1 = (Dali::Handle *)jarg1;
9766   if (!arg1) {
9767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9768     return 0;
9769   }
9770   arg2 = (Dali::Property::Index)jarg2;
9771   {
9772     try {
9773       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9774     } CALL_CATCH_EXCEPTION(0);
9775   }
9776
9777   jresult = (void *)result;
9778   return jresult;
9779 }
9780
9781
9782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9783   void * jresult ;
9784   Dali::Handle *arg1 = 0 ;
9785   Dali::Property::Index arg2 ;
9786   int arg3 ;
9787   Dali::Property *result = 0 ;
9788
9789   arg1 = (Dali::Handle *)jarg1;
9790   if (!arg1) {
9791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9792     return 0;
9793   }
9794   arg2 = (Dali::Property::Index)jarg2;
9795   arg3 = (int)jarg3;
9796   {
9797     try {
9798       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9799     } CALL_CATCH_EXCEPTION(0);
9800   }
9801
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9808   void * jresult ;
9809   Dali::Handle *arg1 = 0 ;
9810   std::string *arg2 = 0 ;
9811   Dali::Property *result = 0 ;
9812
9813   arg1 = (Dali::Handle *)jarg1;
9814   if (!arg1) {
9815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9816     return 0;
9817   }
9818   if (!jarg2) {
9819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9820     return 0;
9821   }
9822   std::string arg2_str(jarg2);
9823   arg2 = &arg2_str;
9824   {
9825     try {
9826       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
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_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9839   void * jresult ;
9840   Dali::Handle *arg1 = 0 ;
9841   std::string *arg2 = 0 ;
9842   int arg3 ;
9843   Dali::Property *result = 0 ;
9844
9845   arg1 = (Dali::Handle *)jarg1;
9846   if (!arg1) {
9847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9848     return 0;
9849   }
9850   if (!jarg2) {
9851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9852     return 0;
9853   }
9854   std::string arg2_str(jarg2);
9855   arg2 = &arg2_str;
9856   arg3 = (int)jarg3;
9857   {
9858     try {
9859       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9860     } CALL_CATCH_EXCEPTION(0);
9861   }
9862
9863   jresult = (void *)result;
9864
9865   //argout typemap for const std::string&
9866
9867   return jresult;
9868 }
9869
9870
9871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9872   Dali::Property *arg1 = (Dali::Property *) 0 ;
9873
9874   arg1 = (Dali::Property *)jarg1;
9875   {
9876     try {
9877       delete arg1;
9878     } CALL_CATCH_EXCEPTION();
9879   }
9880
9881 }
9882
9883
9884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9885   Dali::Property *arg1 = (Dali::Property *) 0 ;
9886   Dali::Handle *arg2 = 0 ;
9887
9888   arg1 = (Dali::Property *)jarg1;
9889   arg2 = (Dali::Handle *)jarg2;
9890   if (!arg2) {
9891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9892     return ;
9893   }
9894   if (arg1) (arg1)->object = *arg2;
9895 }
9896
9897
9898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9899   void * jresult ;
9900   Dali::Property *arg1 = (Dali::Property *) 0 ;
9901   Dali::Handle *result = 0 ;
9902
9903   arg1 = (Dali::Property *)jarg1;
9904   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9905   jresult = (void *)result;
9906   return jresult;
9907 }
9908
9909
9910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9911   Dali::Property *arg1 = (Dali::Property *) 0 ;
9912   Dali::Property::Index arg2 ;
9913
9914   arg1 = (Dali::Property *)jarg1;
9915   arg2 = (Dali::Property::Index)jarg2;
9916   if (arg1) (arg1)->propertyIndex = arg2;
9917 }
9918
9919
9920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9921   int jresult ;
9922   Dali::Property *arg1 = (Dali::Property *) 0 ;
9923   Dali::Property::Index result;
9924
9925   arg1 = (Dali::Property *)jarg1;
9926   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9927   jresult = result;
9928   return jresult;
9929 }
9930
9931
9932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9933   Dali::Property *arg1 = (Dali::Property *) 0 ;
9934   int arg2 ;
9935
9936   arg1 = (Dali::Property *)jarg1;
9937   arg2 = (int)jarg2;
9938   if (arg1) (arg1)->componentIndex = arg2;
9939 }
9940
9941
9942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9943   int jresult ;
9944   Dali::Property *arg1 = (Dali::Property *) 0 ;
9945   int result;
9946
9947   arg1 = (Dali::Property *)jarg1;
9948   result = (int) ((arg1)->componentIndex);
9949   jresult = result;
9950   return jresult;
9951 }
9952
9953
9954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9955   void * jresult ;
9956   Dali::Property::Array *result = 0 ;
9957
9958   {
9959     try {
9960       result = (Dali::Property::Array *)new Dali::Property::Array();
9961     } CALL_CATCH_EXCEPTION(0);
9962   }
9963
9964   jresult = (void *)result;
9965   return jresult;
9966 }
9967
9968
9969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9970   void * jresult ;
9971   Dali::Property::Array *arg1 = 0 ;
9972   Dali::Property::Array *result = 0 ;
9973
9974   arg1 = (Dali::Property::Array *)jarg1;
9975   if (!arg1) {
9976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9977     return 0;
9978   }
9979   {
9980     try {
9981       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9982     } CALL_CATCH_EXCEPTION(0);
9983   }
9984
9985   jresult = (void *)result;
9986   return jresult;
9987 }
9988
9989
9990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9991   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9992
9993   arg1 = (Dali::Property::Array *)jarg1;
9994   {
9995     try {
9996       delete arg1;
9997     } CALL_CATCH_EXCEPTION();
9998   }
9999
10000 }
10001
10002
10003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
10004   unsigned long jresult ;
10005   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10006   Dali::Property::Array::SizeType result;
10007
10008   arg1 = (Dali::Property::Array *)jarg1;
10009   {
10010     try {
10011       result = ((Dali::Property::Array const *)arg1)->Size();
10012     } CALL_CATCH_EXCEPTION(0);
10013   }
10014
10015   jresult = (unsigned long)result;
10016   return jresult;
10017 }
10018
10019
10020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
10021   unsigned long jresult ;
10022   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10023   Dali::Property::Array::SizeType result;
10024
10025   arg1 = (Dali::Property::Array *)jarg1;
10026   {
10027     try {
10028       result = ((Dali::Property::Array const *)arg1)->Count();
10029     } CALL_CATCH_EXCEPTION(0);
10030   }
10031
10032   jresult = (unsigned long)result;
10033   return jresult;
10034 }
10035
10036
10037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
10038   unsigned int jresult ;
10039   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10040   bool result;
10041
10042   arg1 = (Dali::Property::Array *)jarg1;
10043   {
10044     try {
10045       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
10046     } CALL_CATCH_EXCEPTION(0);
10047   }
10048
10049   jresult = result;
10050   return jresult;
10051 }
10052
10053
10054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
10055   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10056
10057   arg1 = (Dali::Property::Array *)jarg1;
10058   {
10059     try {
10060       (arg1)->Clear();
10061     } CALL_CATCH_EXCEPTION();
10062   }
10063
10064 }
10065
10066
10067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
10068   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10069   Dali::Property::Array::SizeType arg2 ;
10070
10071   arg1 = (Dali::Property::Array *)jarg1;
10072   arg2 = (Dali::Property::Array::SizeType)jarg2;
10073   {
10074     try {
10075       (arg1)->Reserve(arg2);
10076     } CALL_CATCH_EXCEPTION();
10077   }
10078
10079 }
10080
10081
10082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
10083   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10084   Dali::Property::Array::SizeType arg2 ;
10085
10086   arg1 = (Dali::Property::Array *)jarg1;
10087   arg2 = (Dali::Property::Array::SizeType)jarg2;
10088   {
10089     try {
10090       (arg1)->Resize(arg2);
10091     } CALL_CATCH_EXCEPTION();
10092   }
10093
10094 }
10095
10096
10097 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
10098   unsigned long jresult ;
10099   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10100   Dali::Property::Array::SizeType result;
10101
10102   arg1 = (Dali::Property::Array *)jarg1;
10103   {
10104     try {
10105       result = (arg1)->Capacity();
10106     } CALL_CATCH_EXCEPTION(0);
10107   }
10108
10109   jresult = (unsigned long)result;
10110   return jresult;
10111 }
10112
10113
10114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
10115   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10116   Dali::Property::Value *arg2 = 0 ;
10117
10118   arg1 = (Dali::Property::Array *)jarg1;
10119   arg2 = (Dali::Property::Value *)jarg2;
10120   if (!arg2) {
10121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10122     return ;
10123   }
10124   {
10125     try {
10126       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
10127     } CALL_CATCH_EXCEPTION();
10128   }
10129
10130 }
10131
10132
10133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
10134   void * jresult ;
10135   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10136   Dali::Property::Value *arg2 = 0 ;
10137   Dali::Property::Array *result = 0 ;
10138
10139   arg1 = (Dali::Property::Array *)jarg1;
10140   arg2 = (Dali::Property::Value *)jarg2;
10141   if (!arg2) {
10142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10143     return 0;
10144   }
10145   {
10146     try {
10147       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
10148     } CALL_CATCH_EXCEPTION(0);
10149   }
10150
10151   jresult = (void *)result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
10157   void * jresult ;
10158   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10159   Dali::Property::Array::SizeType arg2 ;
10160   Dali::Property::Value *result = 0 ;
10161
10162   arg1 = (Dali::Property::Array *)jarg1;
10163   arg2 = (Dali::Property::Array::SizeType)jarg2;
10164   {
10165     try {
10166       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
10167     } CALL_CATCH_EXCEPTION(0);
10168   }
10169
10170   jresult = (void *)result;
10171   return jresult;
10172 }
10173
10174
10175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
10176   void * jresult ;
10177   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10178   Dali::Property::Array::SizeType arg2 ;
10179   Dali::Property::Value *result = 0 ;
10180
10181   arg1 = (Dali::Property::Array *)jarg1;
10182   arg2 = (Dali::Property::Array::SizeType)jarg2;
10183   {
10184     try {
10185       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
10186     } CALL_CATCH_EXCEPTION(0);
10187   }
10188
10189   jresult = (void *)result;
10190   return jresult;
10191 }
10192
10193
10194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
10195   void * jresult ;
10196   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10197   Dali::Property::Array *arg2 = 0 ;
10198   Dali::Property::Array *result = 0 ;
10199
10200   arg1 = (Dali::Property::Array *)jarg1;
10201   arg2 = (Dali::Property::Array *)jarg2;
10202   if (!arg2) {
10203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
10204     return 0;
10205   }
10206   {
10207     try {
10208       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
10209     } CALL_CATCH_EXCEPTION(0);
10210   }
10211
10212   jresult = (void *)result;
10213   return jresult;
10214 }
10215
10216
10217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
10218   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10219   enum Dali::Property::Key::Type arg2 ;
10220
10221   arg1 = (Dali::Property::Key *)jarg1;
10222   arg2 = (enum Dali::Property::Key::Type)jarg2;
10223   if (arg1) (arg1)->type = arg2;
10224 }
10225
10226
10227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
10228   int jresult ;
10229   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10230   enum Dali::Property::Key::Type result;
10231
10232   arg1 = (Dali::Property::Key *)jarg1;
10233   result = (enum Dali::Property::Key::Type) ((arg1)->type);
10234   jresult = (int)result;
10235   return jresult;
10236 }
10237
10238
10239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
10240   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10241   Dali::Property::Index arg2 ;
10242
10243   arg1 = (Dali::Property::Key *)jarg1;
10244   arg2 = (Dali::Property::Index)jarg2;
10245   if (arg1) (arg1)->indexKey = arg2;
10246 }
10247
10248
10249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
10250   int jresult ;
10251   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10252   Dali::Property::Index result;
10253
10254   arg1 = (Dali::Property::Key *)jarg1;
10255   result = (Dali::Property::Index) ((arg1)->indexKey);
10256   jresult = result;
10257   return jresult;
10258 }
10259
10260
10261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
10262   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10263   std::string *arg2 = 0 ;
10264
10265   arg1 = (Dali::Property::Key *)jarg1;
10266   if (!jarg2) {
10267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10268     return ;
10269   }
10270   std::string arg2_str(jarg2);
10271   arg2 = &arg2_str;
10272   if (arg1) (arg1)->stringKey = *arg2;
10273
10274   //argout typemap for const std::string&
10275
10276 }
10277
10278
10279 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
10280   char * jresult ;
10281   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10282   std::string *result = 0 ;
10283
10284   arg1 = (Dali::Property::Key *)jarg1;
10285   result = (std::string *) & ((arg1)->stringKey);
10286   jresult = SWIG_csharp_string_callback(result->c_str());
10287   return jresult;
10288 }
10289
10290
10291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
10292   void * jresult ;
10293   std::string *arg1 = 0 ;
10294   Dali::Property::Key *result = 0 ;
10295
10296   if (!jarg1) {
10297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10298     return 0;
10299   }
10300   std::string arg1_str(jarg1);
10301   arg1 = &arg1_str;
10302   {
10303     try {
10304       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
10305     } CALL_CATCH_EXCEPTION(0);
10306   }
10307
10308   jresult = (void *)result;
10309
10310   //argout typemap for const std::string&
10311
10312   return jresult;
10313 }
10314
10315
10316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
10317   void * jresult ;
10318   Dali::Property::Index arg1 ;
10319   Dali::Property::Key *result = 0 ;
10320
10321   arg1 = (Dali::Property::Index)jarg1;
10322   {
10323     try {
10324       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
10325     } CALL_CATCH_EXCEPTION(0);
10326   }
10327
10328   jresult = (void *)result;
10329   return jresult;
10330 }
10331
10332
10333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
10334   unsigned int jresult ;
10335   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10336   std::string *arg2 = 0 ;
10337   bool result;
10338
10339   arg1 = (Dali::Property::Key *)jarg1;
10340   if (!jarg2) {
10341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10342     return 0;
10343   }
10344   std::string arg2_str(jarg2);
10345   arg2 = &arg2_str;
10346   {
10347     try {
10348       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
10349     } CALL_CATCH_EXCEPTION(0);
10350   }
10351
10352   jresult = result;
10353
10354   //argout typemap for const std::string&
10355
10356   return jresult;
10357 }
10358
10359
10360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
10361   unsigned int jresult ;
10362   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10363   Dali::Property::Index arg2 ;
10364   bool result;
10365
10366   arg1 = (Dali::Property::Key *)jarg1;
10367   arg2 = (Dali::Property::Index)jarg2;
10368   {
10369     try {
10370       result = (bool)(arg1)->operator ==(arg2);
10371     } CALL_CATCH_EXCEPTION(0);
10372   }
10373
10374   jresult = result;
10375   return jresult;
10376 }
10377
10378
10379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
10380   unsigned int jresult ;
10381   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10382   Dali::Property::Key *arg2 = 0 ;
10383   bool result;
10384
10385   arg1 = (Dali::Property::Key *)jarg1;
10386   arg2 = (Dali::Property::Key *)jarg2;
10387   if (!arg2) {
10388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10389     return 0;
10390   }
10391   {
10392     try {
10393       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
10394     } CALL_CATCH_EXCEPTION(0);
10395   }
10396
10397   jresult = result;
10398   return jresult;
10399 }
10400
10401
10402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
10403   unsigned int jresult ;
10404   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10405   std::string *arg2 = 0 ;
10406   bool result;
10407
10408   arg1 = (Dali::Property::Key *)jarg1;
10409   if (!jarg2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10411     return 0;
10412   }
10413   std::string arg2_str(jarg2);
10414   arg2 = &arg2_str;
10415   {
10416     try {
10417       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
10418     } CALL_CATCH_EXCEPTION(0);
10419   }
10420
10421   jresult = result;
10422
10423   //argout typemap for const std::string&
10424
10425   return jresult;
10426 }
10427
10428
10429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
10430   unsigned int jresult ;
10431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10432   Dali::Property::Index arg2 ;
10433   bool result;
10434
10435   arg1 = (Dali::Property::Key *)jarg1;
10436   arg2 = (Dali::Property::Index)jarg2;
10437   {
10438     try {
10439       result = (bool)(arg1)->operator !=(arg2);
10440     } CALL_CATCH_EXCEPTION(0);
10441   }
10442
10443   jresult = result;
10444   return jresult;
10445 }
10446
10447
10448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
10449   unsigned int jresult ;
10450   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10451   Dali::Property::Key *arg2 = 0 ;
10452   bool result;
10453
10454   arg1 = (Dali::Property::Key *)jarg1;
10455   arg2 = (Dali::Property::Key *)jarg2;
10456   if (!arg2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10458     return 0;
10459   }
10460   {
10461     try {
10462       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
10463     } CALL_CATCH_EXCEPTION(0);
10464   }
10465
10466   jresult = result;
10467   return jresult;
10468 }
10469
10470
10471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
10472   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10473
10474   arg1 = (Dali::Property::Key *)jarg1;
10475   {
10476     try {
10477       delete arg1;
10478     } CALL_CATCH_EXCEPTION();
10479   }
10480
10481 }
10482
10483
10484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
10485   void * jresult ;
10486   Dali::Property::Map *result = 0 ;
10487
10488   {
10489     try {
10490       result = (Dali::Property::Map *)new Dali::Property::Map();
10491     } CALL_CATCH_EXCEPTION(0);
10492   }
10493
10494   jresult = (void *)result;
10495   return jresult;
10496 }
10497
10498
10499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
10500   void * jresult ;
10501   Dali::Property::Map *arg1 = 0 ;
10502   Dali::Property::Map *result = 0 ;
10503
10504   arg1 = (Dali::Property::Map *)jarg1;
10505   if (!arg1) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10507     return 0;
10508   }
10509   {
10510     try {
10511       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
10512     } CALL_CATCH_EXCEPTION(0);
10513   }
10514
10515   jresult = (void *)result;
10516   return jresult;
10517 }
10518
10519
10520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
10521   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10522
10523   arg1 = (Dali::Property::Map *)jarg1;
10524   {
10525     try {
10526       delete arg1;
10527     } CALL_CATCH_EXCEPTION();
10528   }
10529
10530 }
10531
10532
10533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10534   unsigned long jresult ;
10535   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10536   Dali::Property::Map::SizeType result;
10537
10538   arg1 = (Dali::Property::Map *)jarg1;
10539   {
10540     try {
10541       result = ((Dali::Property::Map const *)arg1)->Count();
10542     } CALL_CATCH_EXCEPTION(0);
10543   }
10544
10545   jresult = (unsigned long)result;
10546   return jresult;
10547 }
10548
10549
10550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10551   unsigned int jresult ;
10552   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10553   bool result;
10554
10555   arg1 = (Dali::Property::Map *)jarg1;
10556   {
10557     try {
10558       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10559     } CALL_CATCH_EXCEPTION(0);
10560   }
10561
10562   jresult = result;
10563   return jresult;
10564 }
10565
10566
10567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10568   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10569   char *arg2 = (char *) 0 ;
10570   Dali::Property::Value *arg3 = 0 ;
10571
10572   arg1 = (Dali::Property::Map *)jarg1;
10573   arg2 = (char *)jarg2;
10574   arg3 = (Dali::Property::Value *)jarg3;
10575   if (!arg3) {
10576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10577     return ;
10578   }
10579   {
10580     try {
10581       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10582     } CALL_CATCH_EXCEPTION();
10583   }
10584
10585 }
10586
10587
10588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10589   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10590   Dali::Property::Index arg2 ;
10591   Dali::Property::Value *arg3 = 0 ;
10592
10593   arg1 = (Dali::Property::Map *)jarg1;
10594   arg2 = (Dali::Property::Index)jarg2;
10595   arg3 = (Dali::Property::Value *)jarg3;
10596   if (!arg3) {
10597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10598     return ;
10599   }
10600   {
10601     try {
10602       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10603     } CALL_CATCH_EXCEPTION();
10604   }
10605
10606 }
10607
10608
10609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10610   void * jresult ;
10611   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10612   char *arg2 = (char *) 0 ;
10613   Dali::Property::Value *arg3 = 0 ;
10614   Dali::Property::Map *result = 0 ;
10615
10616   arg1 = (Dali::Property::Map *)jarg1;
10617   arg2 = (char *)jarg2;
10618   arg3 = (Dali::Property::Value *)jarg3;
10619   if (!arg3) {
10620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10621     return 0;
10622   }
10623   {
10624     try {
10625       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10626     } CALL_CATCH_EXCEPTION(0);
10627   }
10628
10629   jresult = (void *)result;
10630   return jresult;
10631 }
10632
10633
10634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10635   void * jresult ;
10636   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10637   Dali::Property::Index arg2 ;
10638   Dali::Property::Value *arg3 = 0 ;
10639   Dali::Property::Map *result = 0 ;
10640
10641   arg1 = (Dali::Property::Map *)jarg1;
10642   arg2 = (Dali::Property::Index)jarg2;
10643   arg3 = (Dali::Property::Value *)jarg3;
10644   if (!arg3) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10646     return 0;
10647   }
10648   {
10649     try {
10650       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10651     } CALL_CATCH_EXCEPTION(0);
10652   }
10653
10654   jresult = (void *)result;
10655   return jresult;
10656 }
10657
10658
10659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10660   void * jresult ;
10661   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10662   Dali::Property::Map::SizeType arg2 ;
10663   Dali::Property::Value *result = 0 ;
10664
10665   arg1 = (Dali::Property::Map *)jarg1;
10666   arg2 = (Dali::Property::Map::SizeType)jarg2;
10667   {
10668     try {
10669       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10670     } CALL_CATCH_EXCEPTION(0);
10671   }
10672
10673   jresult = (void *)result;
10674   return jresult;
10675 }
10676
10677
10678 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10679   char * jresult ;
10680   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10681   Dali::Property::Map::SizeType arg2 ;
10682   std::string *result = 0 ;
10683
10684   arg1 = (Dali::Property::Map *)jarg1;
10685   arg2 = (Dali::Property::Map::SizeType)jarg2;
10686   {
10687     try {
10688       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10689     } CALL_CATCH_EXCEPTION(0);
10690   }
10691
10692   jresult = SWIG_csharp_string_callback(result->c_str());
10693   return jresult;
10694 }
10695
10696
10697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10698   void * jresult ;
10699   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10700   Dali::Property::Map::SizeType arg2 ;
10701   SwigValueWrapper< Dali::Property::Key > result;
10702
10703   arg1 = (Dali::Property::Map *)jarg1;
10704   arg2 = (Dali::Property::Map::SizeType)jarg2;
10705   {
10706     try {
10707       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10708     } CALL_CATCH_EXCEPTION(0);
10709   }
10710
10711   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10712   return jresult;
10713 }
10714
10715
10716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10717   void * jresult ;
10718   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10719   Dali::Property::Map::SizeType arg2 ;
10720   StringValuePair *result = 0 ;
10721
10722   arg1 = (Dali::Property::Map *)jarg1;
10723   arg2 = (Dali::Property::Map::SizeType)jarg2;
10724   {
10725     try {
10726       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10727     } CALL_CATCH_EXCEPTION(0);
10728   }
10729
10730   jresult = (void *)result;
10731   return jresult;
10732 }
10733
10734
10735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10736   void * jresult ;
10737   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10738   char *arg2 = (char *) 0 ;
10739   Dali::Property::Value *result = 0 ;
10740
10741   arg1 = (Dali::Property::Map *)jarg1;
10742   arg2 = (char *)jarg2;
10743   {
10744     try {
10745       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10746     } CALL_CATCH_EXCEPTION(0);
10747   }
10748
10749   jresult = (void *)result;
10750   return jresult;
10751 }
10752
10753
10754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10755   void * jresult ;
10756   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10757   Dali::Property::Index arg2 ;
10758   Dali::Property::Value *result = 0 ;
10759
10760   arg1 = (Dali::Property::Map *)jarg1;
10761   arg2 = (Dali::Property::Index)jarg2;
10762   {
10763     try {
10764       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10765     } CALL_CATCH_EXCEPTION(0);
10766   }
10767
10768   jresult = (void *)result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10774   void * jresult ;
10775   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10776   Dali::Property::Index arg2 ;
10777   std::string *arg3 = 0 ;
10778   Dali::Property::Value *result = 0 ;
10779
10780   arg1 = (Dali::Property::Map *)jarg1;
10781   arg2 = (Dali::Property::Index)jarg2;
10782   if (!jarg3) {
10783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10784     return 0;
10785   }
10786   std::string arg3_str(jarg3);
10787   arg3 = &arg3_str;
10788   {
10789     try {
10790       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10791     } CALL_CATCH_EXCEPTION(0);
10792   }
10793
10794   jresult = (void *)result;
10795
10796   //argout typemap for const std::string&
10797
10798   return jresult;
10799 }
10800
10801
10802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10803   void * jresult ;
10804   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10805   std::string *arg2 = 0 ;
10806   Dali::Property::Type arg3 ;
10807   Dali::Property::Value *result = 0 ;
10808
10809   arg1 = (Dali::Property::Map *)jarg1;
10810   if (!jarg2) {
10811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10812     return 0;
10813   }
10814   std::string arg2_str(jarg2);
10815   arg2 = &arg2_str;
10816   arg3 = (Dali::Property::Type)jarg3;
10817   {
10818     try {
10819       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10820     } CALL_CATCH_EXCEPTION(0);
10821   }
10822
10823   jresult = (void *)result;
10824
10825   //argout typemap for const std::string&
10826
10827   return jresult;
10828 }
10829
10830
10831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10832   void * jresult ;
10833   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10834   Dali::Property::Index arg2 ;
10835   Dali::Property::Type arg3 ;
10836   Dali::Property::Value *result = 0 ;
10837
10838   arg1 = (Dali::Property::Map *)jarg1;
10839   arg2 = (Dali::Property::Index)jarg2;
10840   arg3 = (Dali::Property::Type)jarg3;
10841   {
10842     try {
10843       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10844     } CALL_CATCH_EXCEPTION(0);
10845   }
10846
10847   jresult = (void *)result;
10848   return jresult;
10849 }
10850
10851
10852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10853   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10854
10855   arg1 = (Dali::Property::Map *)jarg1;
10856   {
10857     try {
10858       (arg1)->Clear();
10859     } CALL_CATCH_EXCEPTION();
10860   }
10861
10862 }
10863
10864
10865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10866   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10867   Dali::Property::Map *arg2 = 0 ;
10868
10869   arg1 = (Dali::Property::Map *)jarg1;
10870   arg2 = (Dali::Property::Map *)jarg2;
10871   if (!arg2) {
10872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10873     return ;
10874   }
10875   {
10876     try {
10877       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10878     } CALL_CATCH_EXCEPTION();
10879   }
10880
10881 }
10882
10883
10884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10885   void * jresult ;
10886   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10887   std::string *arg2 = 0 ;
10888   Dali::Property::Value *result = 0 ;
10889
10890   arg1 = (Dali::Property::Map *)jarg1;
10891   if (!jarg2) {
10892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10893     return 0;
10894   }
10895   std::string arg2_str(jarg2);
10896   arg2 = &arg2_str;
10897   {
10898     try {
10899       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10900     } CALL_CATCH_EXCEPTION(0);
10901   }
10902
10903   jresult = (void *)result;
10904
10905   //argout typemap for const std::string&
10906
10907   return jresult;
10908 }
10909
10910
10911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10912   void * jresult ;
10913   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10914   Dali::Property::Index arg2 ;
10915   Dali::Property::Value *result = 0 ;
10916
10917   arg1 = (Dali::Property::Map *)jarg1;
10918   arg2 = (Dali::Property::Index)jarg2;
10919   {
10920     try {
10921       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10922     } CALL_CATCH_EXCEPTION(0);
10923   }
10924
10925   jresult = (void *)result;
10926   return jresult;
10927 }
10928
10929
10930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10931   void * jresult ;
10932   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10933   Dali::Property::Map *arg2 = 0 ;
10934   Dali::Property::Map *result = 0 ;
10935
10936   arg1 = (Dali::Property::Map *)jarg1;
10937   arg2 = (Dali::Property::Map *)jarg2;
10938   if (!arg2) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10940     return 0;
10941   }
10942   {
10943     try {
10944       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10945     } CALL_CATCH_EXCEPTION(0);
10946   }
10947
10948   jresult = (void *)result;
10949   return jresult;
10950 }
10951
10952
10953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10954
10955   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10956
10957   if (!jarg2) {
10958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10959     return;
10960   }
10961   std::string arg2_str(jarg2);
10962   std::string* arg2 = &arg2_str;
10963
10964   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10965
10966   {
10967     try {
10968       arg1->operator[]((std::string const &)*arg2) = *arg3;
10969     } CALL_CATCH_EXCEPTION();
10970   }
10971 }
10972
10973
10974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10975
10976   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10977   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10978   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10979
10980   {
10981     try {
10982       arg1->operator[](arg2) = *arg3;
10983     } CALL_CATCH_EXCEPTION();
10984   }
10985 }
10986
10987
10988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10989   void * jresult ;
10990   Dali::Property::Value *result = 0 ;
10991
10992   {
10993     try {
10994       result = (Dali::Property::Value *)new Dali::Property::Value();
10995     } CALL_CATCH_EXCEPTION(0);
10996   }
10997
10998   jresult = (void *)result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
11004   void * jresult ;
11005   bool arg1 ;
11006   Dali::Property::Value *result = 0 ;
11007
11008   arg1 = jarg1 ? true : false;
11009   {
11010     try {
11011       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11012     } CALL_CATCH_EXCEPTION(0);
11013   }
11014
11015   jresult = (void *)result;
11016   return jresult;
11017 }
11018
11019
11020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
11021   void * jresult ;
11022   int arg1 ;
11023   Dali::Property::Value *result = 0 ;
11024
11025   arg1 = (int)jarg1;
11026   {
11027     try {
11028       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11029     } CALL_CATCH_EXCEPTION(0);
11030   }
11031
11032   jresult = (void *)result;
11033   return jresult;
11034 }
11035
11036
11037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
11038   void * jresult ;
11039   float arg1 ;
11040   Dali::Property::Value *result = 0 ;
11041
11042   arg1 = (float)jarg1;
11043   {
11044     try {
11045       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11046     } CALL_CATCH_EXCEPTION(0);
11047   }
11048
11049   jresult = (void *)result;
11050   return jresult;
11051 }
11052
11053
11054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
11055   void * jresult ;
11056   Dali::Vector2 *arg1 = 0 ;
11057   Dali::Property::Value *result = 0 ;
11058
11059   arg1 = (Dali::Vector2 *)jarg1;
11060   if (!arg1) {
11061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
11062     return 0;
11063   }
11064   {
11065     try {
11066       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
11067     } CALL_CATCH_EXCEPTION(0);
11068   }
11069
11070   jresult = (void *)result;
11071   return jresult;
11072 }
11073
11074
11075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
11076   void * jresult ;
11077   Dali::Vector3 *arg1 = 0 ;
11078   Dali::Property::Value *result = 0 ;
11079
11080   arg1 = (Dali::Vector3 *)jarg1;
11081   if (!arg1) {
11082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11083     return 0;
11084   }
11085   {
11086     try {
11087       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
11088     } CALL_CATCH_EXCEPTION(0);
11089   }
11090
11091   jresult = (void *)result;
11092   return jresult;
11093 }
11094
11095
11096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
11097   void * jresult ;
11098   Dali::Vector4 *arg1 = 0 ;
11099   Dali::Property::Value *result = 0 ;
11100
11101   arg1 = (Dali::Vector4 *)jarg1;
11102   if (!arg1) {
11103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11104     return 0;
11105   }
11106   {
11107     try {
11108       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11109     } CALL_CATCH_EXCEPTION(0);
11110   }
11111
11112   jresult = (void *)result;
11113   return jresult;
11114 }
11115
11116
11117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11118   void * jresult ;
11119   Dali::Matrix3 *arg1 = 0 ;
11120   Dali::Property::Value *result = 0 ;
11121
11122   arg1 = (Dali::Matrix3 *)jarg1;
11123   if (!arg1) {
11124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11125     return 0;
11126   }
11127   {
11128     try {
11129       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11130     } CALL_CATCH_EXCEPTION(0);
11131   }
11132
11133   jresult = (void *)result;
11134   return jresult;
11135 }
11136
11137
11138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11139   void * jresult ;
11140   Dali::Matrix *arg1 = 0 ;
11141   Dali::Property::Value *result = 0 ;
11142
11143   arg1 = (Dali::Matrix *)jarg1;
11144   if (!arg1) {
11145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11146     return 0;
11147   }
11148   {
11149     try {
11150       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11151     } CALL_CATCH_EXCEPTION(0);
11152   }
11153
11154   jresult = (void *)result;
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11160   void * jresult ;
11161   Dali::Rect< int > *arg1 = 0 ;
11162   Dali::Property::Value *result = 0 ;
11163
11164   arg1 = (Dali::Rect< int > *)jarg1;
11165   if (!arg1) {
11166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11167     return 0;
11168   }
11169   {
11170     try {
11171       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11172     } CALL_CATCH_EXCEPTION(0);
11173   }
11174
11175   jresult = (void *)result;
11176   return jresult;
11177 }
11178
11179
11180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11181   void * jresult ;
11182   Dali::AngleAxis *arg1 = 0 ;
11183   Dali::Property::Value *result = 0 ;
11184
11185   arg1 = (Dali::AngleAxis *)jarg1;
11186   if (!arg1) {
11187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11188     return 0;
11189   }
11190   {
11191     try {
11192       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11193     } CALL_CATCH_EXCEPTION(0);
11194   }
11195
11196   jresult = (void *)result;
11197   return jresult;
11198 }
11199
11200
11201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11202   void * jresult ;
11203   Dali::Quaternion *arg1 = 0 ;
11204   Dali::Property::Value *result = 0 ;
11205
11206   arg1 = (Dali::Quaternion *)jarg1;
11207   if (!arg1) {
11208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11209     return 0;
11210   }
11211   {
11212     try {
11213       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11214     } CALL_CATCH_EXCEPTION(0);
11215   }
11216
11217   jresult = (void *)result;
11218   return jresult;
11219 }
11220
11221
11222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11223   void * jresult ;
11224   std::string *arg1 = 0 ;
11225   Dali::Property::Value *result = 0 ;
11226
11227   if (!jarg1) {
11228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11229     return 0;
11230   }
11231   std::string arg1_str(jarg1);
11232   arg1 = &arg1_str;
11233   {
11234     try {
11235       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11236     } CALL_CATCH_EXCEPTION(0);
11237   }
11238
11239   jresult = (void *)result;
11240
11241   //argout typemap for const std::string&
11242
11243   return jresult;
11244 }
11245
11246
11247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11248   void * jresult ;
11249   Dali::Property::Array *arg1 = 0 ;
11250   Dali::Property::Value *result = 0 ;
11251
11252   arg1 = (Dali::Property::Array *)jarg1;
11253   if (!arg1) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11260     } CALL_CATCH_EXCEPTION(0);
11261   }
11262
11263   jresult = (void *)result;
11264   return jresult;
11265 }
11266
11267
11268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11269   void * jresult ;
11270   Dali::Property::Map *arg1 = 0 ;
11271   Dali::Property::Value *result = 0 ;
11272
11273   arg1 = (Dali::Property::Map *)jarg1;
11274   if (!arg1) {
11275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11276     return 0;
11277   }
11278   {
11279     try {
11280       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11281     } CALL_CATCH_EXCEPTION(0);
11282   }
11283
11284   jresult = (void *)result;
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11290   void * jresult ;
11291   Extents *arg1 = 0 ;
11292   Dali::Property::Value *result = 0 ;
11293
11294   arg1 = (Extents *)jarg1;
11295   if (!arg1) {
11296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11297     return 0;
11298   }
11299   {
11300     try {
11301       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11302     } CALL_CATCH_EXCEPTION(0);
11303   }
11304
11305   jresult = (void*) result;
11306   return jresult;
11307 }
11308
11309
11310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11311   void * jresult ;
11312   Dali::Property::Type arg1 ;
11313   Dali::Property::Value *result = 0 ;
11314
11315   arg1 = (Dali::Property::Type)jarg1;
11316   {
11317     try {
11318       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11319     } CALL_CATCH_EXCEPTION(0);
11320   }
11321
11322   jresult = (void *)result;
11323   return jresult;
11324 }
11325
11326
11327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11328   void * jresult ;
11329   Dali::Property::Value *arg1 = 0 ;
11330   Dali::Property::Value *result = 0 ;
11331
11332   arg1 = (Dali::Property::Value *)jarg1;
11333   if (!arg1) {
11334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11335     return 0;
11336   }
11337   {
11338     try {
11339       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11340     } CALL_CATCH_EXCEPTION(0);
11341   }
11342
11343   jresult = (void *)result;
11344   return jresult;
11345 }
11346
11347
11348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11349   void * jresult ;
11350   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11351   Dali::Property::Value *arg2 = 0 ;
11352   Dali::Property::Value *result = 0 ;
11353
11354   arg1 = (Dali::Property::Value *)jarg1;
11355   arg2 = (Dali::Property::Value *)jarg2;
11356   if (!arg2) {
11357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11358     return 0;
11359   }
11360   {
11361     try {
11362       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11363     } CALL_CATCH_EXCEPTION(0);
11364   }
11365
11366   jresult = (void *)result;
11367   return jresult;
11368 }
11369
11370
11371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11372   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11373
11374   arg1 = (Dali::Property::Value *)jarg1;
11375   {
11376     try {
11377       delete arg1;
11378     } CALL_CATCH_EXCEPTION();
11379   }
11380
11381 }
11382
11383
11384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11385   int jresult ;
11386   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11387   Dali::Property::Type result;
11388
11389   arg1 = (Dali::Property::Value *)jarg1;
11390   {
11391     try {
11392       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11393     } CALL_CATCH_EXCEPTION(0);
11394   }
11395
11396   jresult = (int)result;
11397   return jresult;
11398 }
11399
11400
11401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
11402   unsigned int jresult ;
11403   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11404   bool *arg2 = 0 ;
11405   bool result;
11406
11407   arg1 = (Dali::Property::Value *)jarg1;
11408   arg2 = (bool *)jarg2;
11409   {
11410     try {
11411       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11412     } CALL_CATCH_EXCEPTION(0);
11413   }
11414
11415   jresult = result;
11416   return jresult;
11417 }
11418
11419
11420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11421   unsigned int jresult ;
11422   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11423   float *arg2 = 0 ;
11424   bool result;
11425
11426   arg1 = (Dali::Property::Value *)jarg1;
11427   arg2 = (float *)jarg2;
11428   {
11429     try {
11430       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11431     } CALL_CATCH_EXCEPTION(0);
11432   }
11433
11434   jresult = result;
11435   return jresult;
11436 }
11437
11438
11439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11440   unsigned int jresult ;
11441   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11442   int *arg2 = 0 ;
11443   bool result;
11444
11445   arg1 = (Dali::Property::Value *)jarg1;
11446   arg2 = (int *)jarg2;
11447   {
11448     try {
11449       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11450     } CALL_CATCH_EXCEPTION(0);
11451   }
11452
11453   jresult = result;
11454   return jresult;
11455 }
11456
11457
11458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11459   unsigned int jresult ;
11460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11461   Dali::Rect< int > *arg2 = 0 ;
11462   bool result;
11463
11464   arg1 = (Dali::Property::Value *)jarg1;
11465   arg2 = (Dali::Rect< int > *)jarg2;
11466   if (!arg2) {
11467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11468     return 0;
11469   }
11470   {
11471     try {
11472       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11473     } CALL_CATCH_EXCEPTION(0);
11474   }
11475
11476   jresult = result;
11477   return jresult;
11478 }
11479
11480
11481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11482   unsigned int jresult ;
11483   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11484   Dali::Vector2 *arg2 = 0 ;
11485   bool result;
11486
11487   arg1 = (Dali::Property::Value *)jarg1;
11488   arg2 = (Dali::Vector2 *)jarg2;
11489   if (!arg2) {
11490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11491     return 0;
11492   }
11493   {
11494     try {
11495       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11496     } CALL_CATCH_EXCEPTION(0);
11497   }
11498
11499   jresult = result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11505   unsigned int jresult ;
11506   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11507   Dali::Vector3 *arg2 = 0 ;
11508   bool result;
11509
11510   arg1 = (Dali::Property::Value *)jarg1;
11511   arg2 = (Dali::Vector3 *)jarg2;
11512   if (!arg2) {
11513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11514     return 0;
11515   }
11516   {
11517     try {
11518       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11519     } CALL_CATCH_EXCEPTION(0);
11520   }
11521
11522   jresult = result;
11523   return jresult;
11524 }
11525
11526
11527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11528   unsigned int jresult ;
11529   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11530   Dali::Vector4 *arg2 = 0 ;
11531   bool result;
11532
11533   arg1 = (Dali::Property::Value *)jarg1;
11534   arg2 = (Dali::Vector4 *)jarg2;
11535   if (!arg2) {
11536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11537     return 0;
11538   }
11539   {
11540     try {
11541       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11542     } CALL_CATCH_EXCEPTION(0);
11543   }
11544
11545   jresult = result;
11546   return jresult;
11547 }
11548
11549
11550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11551   unsigned int jresult ;
11552   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11553   Dali::Matrix3 *arg2 = 0 ;
11554   bool result;
11555
11556   arg1 = (Dali::Property::Value *)jarg1;
11557   arg2 = (Dali::Matrix3 *)jarg2;
11558   if (!arg2) {
11559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11560     return 0;
11561   }
11562   {
11563     try {
11564       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11565     } CALL_CATCH_EXCEPTION(0);
11566   }
11567
11568   jresult = result;
11569   return jresult;
11570 }
11571
11572
11573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11574   unsigned int jresult ;
11575   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11576   Dali::Matrix *arg2 = 0 ;
11577   bool result;
11578
11579   arg1 = (Dali::Property::Value *)jarg1;
11580   arg2 = (Dali::Matrix *)jarg2;
11581   if (!arg2) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11583     return 0;
11584   }
11585   {
11586     try {
11587       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11588     } CALL_CATCH_EXCEPTION(0);
11589   }
11590
11591   jresult = result;
11592   return jresult;
11593 }
11594
11595
11596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11597   unsigned int jresult ;
11598   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11599   Dali::AngleAxis *arg2 = 0 ;
11600   bool result;
11601
11602   arg1 = (Dali::Property::Value *)jarg1;
11603   arg2 = (Dali::AngleAxis *)jarg2;
11604   if (!arg2) {
11605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11606     return 0;
11607   }
11608   {
11609     try {
11610       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11611     } CALL_CATCH_EXCEPTION(0);
11612   }
11613
11614   jresult = result;
11615   return jresult;
11616 }
11617
11618
11619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11620   unsigned int jresult ;
11621   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11622   Dali::Quaternion *arg2 = 0 ;
11623   bool result;
11624
11625   arg1 = (Dali::Property::Value *)jarg1;
11626   arg2 = (Dali::Quaternion *)jarg2;
11627   if (!arg2) {
11628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11629     return 0;
11630   }
11631   {
11632     try {
11633       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11634     } CALL_CATCH_EXCEPTION(0);
11635   }
11636
11637   jresult = result;
11638   return jresult;
11639 }
11640
11641
11642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11643   unsigned int jresult ;
11644   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11645   std::string *arg2 = 0 ;
11646   bool result;
11647
11648   arg1 = (Dali::Property::Value *)jarg1;
11649
11650   //typemap in
11651   std::string temp;
11652   arg2 = &temp;
11653
11654   {
11655     try {
11656       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11657     } CALL_CATCH_EXCEPTION(0);
11658   }
11659
11660   jresult = result;
11661
11662   //Typemap argout in c++ file.
11663   //This will convert c++ string to c# string
11664   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11665
11666   return jresult;
11667 }
11668
11669
11670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11671   unsigned int jresult ;
11672   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11673   Dali::Property::Array *arg2 = 0 ;
11674   bool result;
11675
11676   arg1 = (Dali::Property::Value *)jarg1;
11677   arg2 = (Dali::Property::Array *)jarg2;
11678   if (!arg2) {
11679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11680     return 0;
11681   }
11682   {
11683     try {
11684       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11685     } CALL_CATCH_EXCEPTION(0);
11686   }
11687
11688   jresult = result;
11689   return jresult;
11690 }
11691
11692
11693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11694   unsigned int jresult ;
11695   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11696   Dali::Property::Map *arg2 = 0 ;
11697   bool result;
11698
11699   arg1 = (Dali::Property::Value *)jarg1;
11700   arg2 = (Dali::Property::Map *)jarg2;
11701   if (!arg2) {
11702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11703     return 0;
11704   }
11705   {
11706     try {
11707       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11708     } CALL_CATCH_EXCEPTION(0);
11709   }
11710
11711   jresult = result;
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11717   unsigned int jresult ;
11718   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11719   Extents *arg2 = 0 ;
11720   bool result;
11721
11722   arg1 = (Dali::Property::Value *)jarg1;
11723   arg2 = (Extents *)jarg2;
11724   if (!arg2) {
11725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11726     return 0;
11727   }
11728   {
11729     try {
11730       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11731     } CALL_CATCH_EXCEPTION(0);
11732   }
11733   jresult = result;
11734   return jresult;
11735 }
11736
11737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11738   void * jresult ;
11739   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11740   Dali::Property::Array *result = 0 ;
11741
11742   arg1 = (Dali::Property::Value *)jarg1;
11743   {
11744     try {
11745       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11746     } CALL_CATCH_EXCEPTION(0);
11747   }
11748
11749   jresult = (void *)result;
11750   return jresult;
11751 }
11752
11753
11754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11755   void * jresult ;
11756   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11757   Dali::Property::Map *result = 0 ;
11758
11759   arg1 = (Dali::Property::Value *)jarg1;
11760   {
11761     try {
11762       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11763     } CALL_CATCH_EXCEPTION(0);
11764   }
11765
11766   jresult = (void *)result;
11767   return jresult;
11768 }
11769
11770
11771 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11772   char * jresult ;
11773   Dali::Property::Type arg1 ;
11774   char *result = 0 ;
11775
11776   arg1 = (Dali::Property::Type)jarg1;
11777   {
11778     try {
11779       result = (char *)Dali::PropertyTypes::GetName(arg1);
11780     } CALL_CATCH_EXCEPTION(0);
11781   }
11782
11783   jresult = SWIG_csharp_string_callback((const char *)result);
11784   return jresult;
11785 }
11786
11787
11788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11789   unsigned int jresult ;
11790   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11791   std::string *arg2 = 0 ;
11792   Dali::Property::Map *arg3 = 0 ;
11793   bool result;
11794
11795   arg1 = (Dali::BaseObject *)jarg1;
11796   if (!jarg2) {
11797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11798     return 0;
11799   }
11800   std::string arg2_str(jarg2);
11801   arg2 = &arg2_str;
11802   arg3 = (Dali::Property::Map *)jarg3;
11803   if (!arg3) {
11804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11805     return 0;
11806   }
11807   {
11808     try {
11809       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11810     } CALL_CATCH_EXCEPTION(0);
11811   }
11812
11813   jresult = result;
11814
11815   //argout typemap for const std::string&
11816
11817   return jresult;
11818 }
11819
11820
11821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11822   char * jresult ;
11823   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11824   std::string *result = 0 ;
11825
11826   arg1 = (Dali::BaseObject *)jarg1;
11827   {
11828     try {
11829       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11830     } CALL_CATCH_EXCEPTION(0);
11831   }
11832
11833   jresult = SWIG_csharp_string_callback(result->c_str());
11834   return jresult;
11835 }
11836
11837
11838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11839   unsigned int jresult ;
11840   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11841   Dali::TypeInfo *arg2 = 0 ;
11842   bool result;
11843
11844   arg1 = (Dali::BaseObject *)jarg1;
11845   arg2 = (Dali::TypeInfo *)jarg2;
11846   if (!arg2) {
11847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11848     return 0;
11849   }
11850   {
11851     try {
11852       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11853     } CALL_CATCH_EXCEPTION(0);
11854   }
11855
11856   jresult = result;
11857   return jresult;
11858 }
11859
11860
11861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11862   unsigned int jresult ;
11863   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11864   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11865   std::string *arg3 = 0 ;
11866   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11867   bool result;
11868
11869   arg1 = (Dali::BaseObject *)jarg1;
11870   arg2 = (ConnectionTrackerInterface *)jarg2;
11871   if (!jarg3) {
11872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11873     return 0;
11874   }
11875   std::string arg3_str(jarg3);
11876   arg3 = &arg3_str;
11877   arg4 = (FunctorDelegate *)jarg4;
11878   {
11879     try {
11880       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11881     } CALL_CATCH_EXCEPTION(0);
11882   }
11883
11884   jresult = result;
11885
11886   //argout typemap for const std::string&
11887
11888   return jresult;
11889 }
11890
11891
11892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11893   void * jresult ;
11894   Dali::BaseHandle *arg1 = 0 ;
11895   Dali::BaseObject *result = 0 ;
11896
11897   arg1 = (Dali::BaseHandle *)jarg1;
11898   if (!arg1) {
11899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11900     return 0;
11901   }
11902   {
11903     try {
11904       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11905     } CALL_CATCH_EXCEPTION(0);
11906   }
11907
11908   jresult = (void *)result;
11909   return jresult;
11910 }
11911
11912
11913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11914   void * jresult ;
11915   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11916   Dali::BaseHandle *result = 0 ;
11917
11918   arg1 = (Dali::BaseObject *)jarg1;
11919   {
11920     try {
11921       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11922     } CALL_CATCH_EXCEPTION(0);
11923   }
11924
11925   jresult = (void *)result;
11926   return jresult;
11927 }
11928
11929
11930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11931   void * jresult ;
11932   Dali::BaseHandle *result = 0 ;
11933
11934   {
11935     try {
11936       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11937     } CALL_CATCH_EXCEPTION(0);
11938   }
11939
11940   jresult = (void *)result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11946   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11947
11948   arg1 = (Dali::BaseHandle *)jarg1;
11949   {
11950     try {
11951       delete arg1;
11952     } CALL_CATCH_EXCEPTION();
11953   }
11954
11955 }
11956
11957
11958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11959   void * jresult ;
11960   Dali::BaseHandle *arg1 = 0 ;
11961   Dali::BaseHandle *result = 0 ;
11962
11963   arg1 = (Dali::BaseHandle *)jarg1;
11964   if (!arg1) {
11965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11966     return 0;
11967   }
11968   {
11969     try {
11970       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11971     } CALL_CATCH_EXCEPTION(0);
11972   }
11973
11974   jresult = (void *)result;
11975   return jresult;
11976 }
11977
11978
11979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11980   void * jresult ;
11981   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11982   Dali::BaseHandle *arg2 = 0 ;
11983   Dali::BaseHandle *result = 0 ;
11984
11985   arg1 = (Dali::BaseHandle *)jarg1;
11986   arg2 = (Dali::BaseHandle *)jarg2;
11987   if (!arg2) {
11988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11989     return 0;
11990   }
11991   {
11992     try {
11993       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11994     } CALL_CATCH_EXCEPTION(0);
11995   }
11996
11997   jresult = (void *)result;
11998   return jresult;
11999 }
12000
12001
12002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
12003   unsigned int jresult ;
12004   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12005   std::string *arg2 = 0 ;
12006   Dali::Property::Map *arg3 = 0 ;
12007   bool result;
12008
12009   arg1 = (Dali::BaseHandle *)jarg1;
12010   if (!jarg2) {
12011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12012     return 0;
12013   }
12014   std::string arg2_str(jarg2);
12015   arg2 = &arg2_str;
12016   arg3 = (Dali::Property::Map *)jarg3;
12017   if (!arg3) {
12018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
12019     return 0;
12020   }
12021   {
12022     try {
12023       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
12024     } CALL_CATCH_EXCEPTION(0);
12025   }
12026
12027   jresult = result;
12028
12029   //argout typemap for const std::string&
12030
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
12036   char * jresult ;
12037   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12038   std::string *result = 0 ;
12039
12040   arg1 = (Dali::BaseHandle *)jarg1;
12041   {
12042     try {
12043       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
12044     } CALL_CATCH_EXCEPTION(0);
12045   }
12046
12047   jresult = SWIG_csharp_string_callback(result->c_str());
12048   return jresult;
12049 }
12050
12051
12052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
12053   unsigned int jresult ;
12054   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12055   Dali::TypeInfo *arg2 = 0 ;
12056   bool result;
12057
12058   arg1 = (Dali::BaseHandle *)jarg1;
12059   arg2 = (Dali::TypeInfo *)jarg2;
12060   if (!arg2) {
12061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12062     return 0;
12063   }
12064   {
12065     try {
12066       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12067     } CALL_CATCH_EXCEPTION(0);
12068   }
12069
12070   jresult = result;
12071   return jresult;
12072 }
12073
12074
12075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12076   void * jresult ;
12077   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12078   Dali::BaseObject *result = 0 ;
12079
12080   arg1 = (Dali::BaseHandle *)jarg1;
12081   {
12082     try {
12083       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12084     } CALL_CATCH_EXCEPTION(0);
12085   }
12086
12087   jresult = (void *)result;
12088   return jresult;
12089 }
12090
12091
12092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12093   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12094
12095   arg1 = (Dali::BaseHandle *)jarg1;
12096   {
12097     try {
12098       (arg1)->Reset();
12099     } CALL_CATCH_EXCEPTION();
12100   }
12101
12102 }
12103
12104
12105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12106   unsigned int jresult ;
12107   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12108   Dali::BaseHandle *arg2 = 0 ;
12109   bool result;
12110
12111   arg1 = (Dali::BaseHandle *)jarg1;
12112   arg2 = (Dali::BaseHandle *)jarg2;
12113   if (!arg2) {
12114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12115     return 0;
12116   }
12117   {
12118     try {
12119       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12120     } CALL_CATCH_EXCEPTION(0);
12121   }
12122
12123   jresult = result;
12124   return jresult;
12125 }
12126
12127
12128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12129   unsigned int jresult ;
12130   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12131   Dali::BaseHandle *arg2 = 0 ;
12132   bool result;
12133
12134   arg1 = (Dali::BaseHandle *)jarg1;
12135   arg2 = (Dali::BaseHandle *)jarg2;
12136   if (!arg2) {
12137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12138     return 0;
12139   }
12140   {
12141     try {
12142       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12143     } CALL_CATCH_EXCEPTION(0);
12144   }
12145
12146   jresult = result;
12147   return jresult;
12148 }
12149
12150
12151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12152   void * jresult ;
12153   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12154   Dali::RefObject *result = 0 ;
12155
12156   arg1 = (Dali::BaseHandle *)jarg1;
12157   {
12158     try {
12159       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12160     } CALL_CATCH_EXCEPTION(0);
12161   }
12162
12163   jresult = (void *)result;
12164   return jresult;
12165 }
12166
12167
12168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12169   unsigned int jresult ;
12170   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12171   bool result;
12172
12173   arg1 = (Dali::BaseHandle *)jarg1;
12174   {
12175     try {
12176       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12177     } CALL_CATCH_EXCEPTION(0);
12178   }
12179
12180   jresult = result;
12181   return jresult;
12182 }
12183
12184
12185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12186   unsigned int jresult ;
12187   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12188   Dali::BaseHandle *arg2 = 0 ;
12189   bool result;
12190
12191   arg1 = (Dali::BaseHandle *)jarg1;
12192   arg2 = (Dali::BaseHandle *)jarg2;
12193   if (!arg2) {
12194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12195     return 0;
12196   }
12197   {
12198     try {
12199       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12200     } CALL_CATCH_EXCEPTION(0);
12201   }
12202
12203   jresult = result;
12204   return jresult;
12205 }
12206
12207
12208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12209   unsigned int jresult ;
12210   Dali::BaseHandle *arg1 = 0 ;
12211   Dali::BaseHandle *arg2 = 0 ;
12212   bool result;
12213
12214   arg1 = (Dali::BaseHandle *)jarg1;
12215   if (!arg1) {
12216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12217     return 0;
12218   }
12219   arg2 = (Dali::BaseHandle *)jarg2;
12220   if (!arg2) {
12221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12222     return 0;
12223   }
12224   {
12225     try {
12226       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12227     } CALL_CATCH_EXCEPTION(0);
12228   }
12229
12230   jresult = result;
12231   return jresult;
12232 }
12233
12234
12235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12236   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12237
12238   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12239   {
12240     try {
12241       delete arg1;
12242     } CALL_CATCH_EXCEPTION();
12243   }
12244
12245 }
12246
12247
12248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12249   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12250   SlotObserver *arg2 = (SlotObserver *) 0 ;
12251   CallbackBase *arg3 = (CallbackBase *) 0 ;
12252
12253   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12254   arg2 = (SlotObserver *)jarg2;
12255   arg3 = (CallbackBase *)jarg3;
12256   {
12257     try {
12258       (arg1)->SignalConnected(arg2,arg3);
12259     } CALL_CATCH_EXCEPTION();
12260   }
12261
12262 }
12263
12264
12265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12266   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12267
12268   arg1 = (Dali::SignalObserver *)jarg1;
12269   {
12270     try {
12271       delete arg1;
12272     } CALL_CATCH_EXCEPTION();
12273   }
12274
12275 }
12276
12277
12278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12279   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12280   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12281   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12282
12283   arg1 = (Dali::SignalObserver *)jarg1;
12284   arg2 = (Dali::SlotObserver *)jarg2;
12285   arg3 = (Dali::CallbackBase *)jarg3;
12286   {
12287     try {
12288       (arg1)->SignalDisconnected(arg2,arg3);
12289     } CALL_CATCH_EXCEPTION();
12290   }
12291
12292 }
12293
12294
12295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12296   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12297
12298   arg1 = (Dali::SlotObserver *)jarg1;
12299   {
12300     try {
12301       delete arg1;
12302     } CALL_CATCH_EXCEPTION();
12303   }
12304
12305 }
12306
12307
12308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12309   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12310   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12311
12312   arg1 = (Dali::SlotObserver *)jarg1;
12313   arg2 = (Dali::CallbackBase *)jarg2;
12314   {
12315     try {
12316       (arg1)->SlotDisconnected(arg2);
12317     } CALL_CATCH_EXCEPTION();
12318   }
12319
12320 }
12321
12322
12323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12324   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12325
12326   arg1 = (Dali::ConnectionTracker *)jarg1;
12327   {
12328     try {
12329       delete arg1;
12330     } CALL_CATCH_EXCEPTION();
12331   }
12332
12333 }
12334
12335
12336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12337   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12338
12339   arg1 = (Dali::ConnectionTracker *)jarg1;
12340   {
12341     try {
12342       (arg1)->DisconnectAll();
12343     } CALL_CATCH_EXCEPTION();
12344   }
12345
12346 }
12347
12348
12349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12350   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12351   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12352   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12353
12354   arg1 = (Dali::ConnectionTracker *)jarg1;
12355   arg2 = (Dali::SlotObserver *)jarg2;
12356   arg3 = (Dali::CallbackBase *)jarg3;
12357   {
12358     try {
12359       (arg1)->SignalConnected(arg2,arg3);
12360     } CALL_CATCH_EXCEPTION();
12361   }
12362
12363 }
12364
12365
12366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12367   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12368   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12369   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12370
12371   arg1 = (Dali::ConnectionTracker *)jarg1;
12372   arg2 = (Dali::SlotObserver *)jarg2;
12373   arg3 = (Dali::CallbackBase *)jarg3;
12374   {
12375     try {
12376       (arg1)->SignalDisconnected(arg2,arg3);
12377     } CALL_CATCH_EXCEPTION();
12378   }
12379
12380 }
12381
12382
12383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12384   unsigned long jresult ;
12385   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12386   std::size_t result;
12387
12388   arg1 = (Dali::ConnectionTracker *)jarg1;
12389   {
12390     try {
12391       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12392     } CALL_CATCH_EXCEPTION(0);
12393   }
12394
12395   jresult = (unsigned long)result;
12396   return jresult;
12397 }
12398
12399
12400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12401   void * jresult ;
12402   Dali::ObjectRegistry *result = 0 ;
12403
12404   {
12405     try {
12406       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12407     } CALL_CATCH_EXCEPTION(0);
12408   }
12409
12410   jresult = (void *)result;
12411   return jresult;
12412 }
12413
12414
12415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12416   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12417
12418   arg1 = (Dali::ObjectRegistry *)jarg1;
12419   {
12420     try {
12421       delete arg1;
12422     } CALL_CATCH_EXCEPTION();
12423   }
12424
12425 }
12426
12427
12428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12429   void * jresult ;
12430   Dali::ObjectRegistry *arg1 = 0 ;
12431   Dali::ObjectRegistry *result = 0 ;
12432
12433   arg1 = (Dali::ObjectRegistry *)jarg1;
12434   if (!arg1) {
12435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12436     return 0;
12437   }
12438   {
12439     try {
12440       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12441     } CALL_CATCH_EXCEPTION(0);
12442   }
12443
12444   jresult = (void *)result;
12445   return jresult;
12446 }
12447
12448
12449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12450   void * jresult ;
12451   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12452   Dali::ObjectRegistry *arg2 = 0 ;
12453   Dali::ObjectRegistry *result = 0 ;
12454
12455   arg1 = (Dali::ObjectRegistry *)jarg1;
12456   arg2 = (Dali::ObjectRegistry *)jarg2;
12457   if (!arg2) {
12458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12459     return 0;
12460   }
12461   {
12462     try {
12463       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12464     } CALL_CATCH_EXCEPTION(0);
12465   }
12466
12467   jresult = (void *)result;
12468   return jresult;
12469 }
12470
12471
12472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12473   void * jresult ;
12474   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12475   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12476
12477   arg1 = (Dali::ObjectRegistry *)jarg1;
12478   {
12479     try {
12480       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12481     } CALL_CATCH_EXCEPTION(0);
12482   }
12483
12484   jresult = (void *)result;
12485   return jresult;
12486 }
12487
12488
12489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12490   void * jresult ;
12491   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12492   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12493
12494   arg1 = (Dali::ObjectRegistry *)jarg1;
12495   {
12496     try {
12497       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12498     } CALL_CATCH_EXCEPTION(0);
12499   }
12500
12501   jresult = (void *)result;
12502   return jresult;
12503 }
12504
12505
12506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12507   void * jresult ;
12508   Dali::PropertyCondition *result = 0 ;
12509
12510   {
12511     try {
12512       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12513     } CALL_CATCH_EXCEPTION(0);
12514   }
12515
12516   jresult = (void *)result;
12517   return jresult;
12518 }
12519
12520
12521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12522   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12523
12524   arg1 = (Dali::PropertyCondition *)jarg1;
12525   {
12526     try {
12527       delete arg1;
12528     } CALL_CATCH_EXCEPTION();
12529   }
12530
12531 }
12532
12533
12534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12535   void * jresult ;
12536   Dali::PropertyCondition *arg1 = 0 ;
12537   Dali::PropertyCondition *result = 0 ;
12538
12539   arg1 = (Dali::PropertyCondition *)jarg1;
12540   if (!arg1) {
12541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12542     return 0;
12543   }
12544   {
12545     try {
12546       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12547     } CALL_CATCH_EXCEPTION(0);
12548   }
12549
12550   jresult = (void *)result;
12551   return jresult;
12552 }
12553
12554
12555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12556   void * jresult ;
12557   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12558   Dali::PropertyCondition *arg2 = 0 ;
12559   Dali::PropertyCondition *result = 0 ;
12560
12561   arg1 = (Dali::PropertyCondition *)jarg1;
12562   arg2 = (Dali::PropertyCondition *)jarg2;
12563   if (!arg2) {
12564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12565     return 0;
12566   }
12567   {
12568     try {
12569       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12570     } CALL_CATCH_EXCEPTION(0);
12571   }
12572
12573   jresult = (void *)result;
12574   return jresult;
12575 }
12576
12577
12578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12579   unsigned long jresult ;
12580   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12581   std::size_t result;
12582
12583   arg1 = (Dali::PropertyCondition *)jarg1;
12584   {
12585     try {
12586       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12587     } CALL_CATCH_EXCEPTION(0);
12588   }
12589   jresult = (unsigned long)result;
12590   return jresult;
12591 }
12592
12593
12594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12595   float jresult ;
12596   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12597   std::size_t arg2 ;
12598   float result;
12599
12600   arg1 = (Dali::PropertyCondition *)jarg1;
12601   arg2 = (std::size_t)jarg2;
12602   {
12603     try {
12604       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12605     } CALL_CATCH_EXCEPTION(0);
12606   }
12607   jresult = result;
12608   return jresult;
12609 }
12610
12611
12612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12613   void * jresult ;
12614   float arg1 ;
12615   Dali::PropertyCondition result;
12616
12617   arg1 = (float)jarg1;
12618   {
12619     try {
12620       result = Dali::LessThanCondition(arg1);
12621     } CALL_CATCH_EXCEPTION(0);
12622   }
12623
12624   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12630   void * jresult ;
12631   float arg1 ;
12632   Dali::PropertyCondition result;
12633
12634   arg1 = (float)jarg1;
12635   {
12636     try {
12637       result = Dali::GreaterThanCondition(arg1);
12638     } CALL_CATCH_EXCEPTION(0);
12639   }
12640
12641   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12642   return jresult;
12643 }
12644
12645
12646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12647   void * jresult ;
12648   float arg1 ;
12649   float arg2 ;
12650   Dali::PropertyCondition result;
12651
12652   arg1 = (float)jarg1;
12653   arg2 = (float)jarg2;
12654   {
12655     try {
12656       result = Dali::InsideCondition(arg1,arg2);
12657     } CALL_CATCH_EXCEPTION(0);
12658   }
12659
12660   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12661   return jresult;
12662 }
12663
12664
12665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12666   void * jresult ;
12667   float arg1 ;
12668   float arg2 ;
12669   Dali::PropertyCondition result;
12670
12671   arg1 = (float)jarg1;
12672   arg2 = (float)jarg2;
12673   {
12674     try {
12675       result = Dali::OutsideCondition(arg1,arg2);
12676     } CALL_CATCH_EXCEPTION(0);
12677   }
12678
12679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12680   return jresult;
12681 }
12682
12683
12684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12685   void * jresult ;
12686   float arg1 ;
12687   float arg2 ;
12688   Dali::PropertyCondition result;
12689
12690   arg1 = (float)jarg1;
12691   arg2 = (float)jarg2;
12692   {
12693     try {
12694       result = Dali::StepCondition(arg1,arg2);
12695     } CALL_CATCH_EXCEPTION(0);
12696   }
12697
12698   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12699   return jresult;
12700 }
12701
12702
12703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12704   void * jresult ;
12705   float arg1 ;
12706   Dali::PropertyCondition result;
12707
12708   arg1 = (float)jarg1;
12709   {
12710     try {
12711       result = Dali::StepCondition(arg1);
12712     } CALL_CATCH_EXCEPTION(0);
12713   }
12714
12715   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12716   return jresult;
12717 }
12718
12719
12720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12721   void * jresult ;
12722   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12723   Dali::PropertyCondition result;
12724
12725   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12726   if (!arg1) {
12727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12728     return 0;
12729   }
12730   {
12731     try {
12732       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12733     } CALL_CATCH_EXCEPTION(0);
12734   }
12735
12736   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12737   return jresult;
12738 }
12739
12740
12741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12742   void * jresult ;
12743   Dali::PropertyNotification *result = 0 ;
12744
12745   {
12746     try {
12747       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12748     } CALL_CATCH_EXCEPTION(0);
12749   }
12750
12751   jresult = (void *)result;
12752   return jresult;
12753 }
12754
12755
12756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12757   void * jresult ;
12758   Dali::BaseHandle arg1 ;
12759   Dali::BaseHandle *argp1 ;
12760   Dali::PropertyNotification result;
12761
12762   argp1 = (Dali::BaseHandle *)jarg1;
12763   if (!argp1) {
12764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12765     return 0;
12766   }
12767   arg1 = *argp1;
12768   {
12769     try {
12770       result = Dali::PropertyNotification::DownCast(arg1);
12771     } CALL_CATCH_EXCEPTION(0);
12772   }
12773
12774   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12775   return jresult;
12776 }
12777
12778
12779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12780   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12781
12782   arg1 = (Dali::PropertyNotification *)jarg1;
12783   {
12784     try {
12785       delete arg1;
12786     } CALL_CATCH_EXCEPTION();
12787   }
12788
12789 }
12790
12791
12792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12793   void * jresult ;
12794   Dali::PropertyNotification *arg1 = 0 ;
12795   Dali::PropertyNotification *result = 0 ;
12796
12797   arg1 = (Dali::PropertyNotification *)jarg1;
12798   if (!arg1) {
12799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12800     return 0;
12801   }
12802   {
12803     try {
12804       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12805     } CALL_CATCH_EXCEPTION(0);
12806   }
12807
12808   jresult = (void *)result;
12809   return jresult;
12810 }
12811
12812
12813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12814   void * jresult ;
12815   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12816   Dali::PropertyNotification *arg2 = 0 ;
12817   Dali::PropertyNotification *result = 0 ;
12818
12819   arg1 = (Dali::PropertyNotification *)jarg1;
12820   arg2 = (Dali::PropertyNotification *)jarg2;
12821   if (!arg2) {
12822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12823     return 0;
12824   }
12825   {
12826     try {
12827       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12828     } CALL_CATCH_EXCEPTION(0);
12829   }
12830
12831   jresult = (void *)result;
12832   return jresult;
12833 }
12834
12835
12836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12837   void * jresult ;
12838   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12839   Dali::PropertyCondition result;
12840
12841   arg1 = (Dali::PropertyNotification *)jarg1;
12842   {
12843     try {
12844       result = (arg1)->GetCondition();
12845     } CALL_CATCH_EXCEPTION(0);
12846   }
12847
12848   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12849   return jresult;
12850 }
12851
12852
12853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12854   void * jresult ;
12855   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12856   Dali::Handle result;
12857
12858   arg1 = (Dali::PropertyNotification *)jarg1;
12859   {
12860     try {
12861       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12862     } CALL_CATCH_EXCEPTION(0);
12863   }
12864
12865   jresult = new Dali::Handle((const Dali::Handle &)result);
12866   return jresult;
12867 }
12868
12869
12870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12871   int jresult ;
12872   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12873   Dali::Property::Index result;
12874
12875   arg1 = (Dali::PropertyNotification *)jarg1;
12876   {
12877     try {
12878       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12879     } CALL_CATCH_EXCEPTION(0);
12880   }
12881
12882   jresult = result;
12883   return jresult;
12884 }
12885
12886
12887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12888   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12889   Dali::PropertyNotification::NotifyMode arg2 ;
12890
12891   arg1 = (Dali::PropertyNotification *)jarg1;
12892   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12893   {
12894     try {
12895       (arg1)->SetNotifyMode(arg2);
12896     } CALL_CATCH_EXCEPTION();
12897   }
12898
12899 }
12900
12901
12902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12903   int jresult ;
12904   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12905   Dali::PropertyNotification::NotifyMode result;
12906
12907   arg1 = (Dali::PropertyNotification *)jarg1;
12908   {
12909     try {
12910       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12911     } CALL_CATCH_EXCEPTION(0);
12912   }
12913
12914   jresult = (int)result;
12915   return jresult;
12916 }
12917
12918
12919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12920   unsigned int jresult ;
12921   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12922   bool result;
12923
12924   arg1 = (Dali::PropertyNotification *)jarg1;
12925   {
12926     try {
12927       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12928     } CALL_CATCH_EXCEPTION(0);
12929   }
12930
12931   jresult = result;
12932   return jresult;
12933 }
12934
12935
12936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12937   void * jresult ;
12938   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12939   Dali::PropertyNotifySignalType *result = 0 ;
12940
12941   arg1 = (Dali::PropertyNotification *)jarg1;
12942   {
12943     try {
12944       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12945     } CALL_CATCH_EXCEPTION(0);
12946   }
12947
12948   jresult = (void *)result;
12949   return jresult;
12950 }
12951
12952
12953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12954   void * jresult ;
12955   Dali::Handle *result = 0 ;
12956
12957   {
12958     try {
12959       result = (Dali::Handle *)new Dali::Handle();
12960     } CALL_CATCH_EXCEPTION(0);
12961   }
12962
12963   jresult = (void *)result;
12964   return jresult;
12965 }
12966
12967
12968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12969   void * jresult ;
12970   Dali::Handle result;
12971
12972   {
12973     try {
12974       result = Dali::Handle::New();
12975     } CALL_CATCH_EXCEPTION(0);
12976   }
12977
12978   jresult = new Dali::Handle((const Dali::Handle &)result);
12979   return jresult;
12980 }
12981
12982
12983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12984   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12985
12986   arg1 = (Dali::Handle *)jarg1;
12987   {
12988     try {
12989       delete arg1;
12990     } CALL_CATCH_EXCEPTION();
12991   }
12992
12993 }
12994
12995
12996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12997   void * jresult ;
12998   Dali::Handle *arg1 = 0 ;
12999   Dali::Handle *result = 0 ;
13000
13001   arg1 = (Dali::Handle *)jarg1;
13002   if (!arg1) {
13003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13004     return 0;
13005   }
13006   {
13007     try {
13008       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
13009     } CALL_CATCH_EXCEPTION(0);
13010   }
13011
13012   jresult = (void *)result;
13013   return jresult;
13014 }
13015
13016
13017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
13018   void * jresult ;
13019   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13020   Dali::Handle *arg2 = 0 ;
13021   Dali::Handle *result = 0 ;
13022
13023   arg1 = (Dali::Handle *)jarg1;
13024   arg2 = (Dali::Handle *)jarg2;
13025   if (!arg2) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13027     return 0;
13028   }
13029   {
13030     try {
13031       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
13032     } CALL_CATCH_EXCEPTION(0);
13033   }
13034
13035   jresult = (void *)result;
13036   return jresult;
13037 }
13038
13039
13040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
13041   void * jresult ;
13042   Dali::BaseHandle arg1 ;
13043   Dali::BaseHandle *argp1 ;
13044   Dali::Handle result;
13045
13046   argp1 = (Dali::BaseHandle *)jarg1;
13047   if (!argp1) {
13048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13049     return 0;
13050   }
13051   arg1 = *argp1;
13052   {
13053     try {
13054       result = Dali::Handle::DownCast(arg1);
13055     } CALL_CATCH_EXCEPTION(0);
13056   }
13057
13058   jresult = new Dali::Handle((const Dali::Handle &)result);
13059   return jresult;
13060 }
13061
13062
13063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13064   unsigned int jresult ;
13065   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13066   Dali::Handle::Capability arg2 ;
13067   bool result;
13068
13069   arg1 = (Dali::Handle *)jarg1;
13070   arg2 = (Dali::Handle::Capability)jarg2;
13071   {
13072     try {
13073       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13074     } CALL_CATCH_EXCEPTION(0);
13075   }
13076
13077   jresult = result;
13078   return jresult;
13079 }
13080
13081
13082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13083   unsigned int jresult ;
13084   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13085   unsigned int result;
13086
13087   arg1 = (Dali::Handle *)jarg1;
13088   {
13089     try {
13090       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13091     } CALL_CATCH_EXCEPTION(0);
13092   }
13093
13094   jresult = result;
13095   return jresult;
13096 }
13097
13098
13099 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13100   char * jresult ;
13101   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13102   Dali::Property::Index arg2 ;
13103   std::string result;
13104
13105   arg1 = (Dali::Handle *)jarg1;
13106   arg2 = (Dali::Property::Index)jarg2;
13107   {
13108     try {
13109       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13110     } CALL_CATCH_EXCEPTION(0);
13111   }
13112
13113   jresult = SWIG_csharp_string_callback((&result)->c_str());
13114   return jresult;
13115 }
13116
13117
13118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13119   int jresult ;
13120   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13121   std::string *arg2 = 0 ;
13122   Dali::Property::Index result;
13123
13124   arg1 = (Dali::Handle *)jarg1;
13125   if (!jarg2) {
13126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13127     return 0;
13128   }
13129   std::string arg2_str(jarg2);
13130   arg2 = &arg2_str;
13131   {
13132     try {
13133       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13134     } CALL_CATCH_EXCEPTION(0);
13135   }
13136
13137   jresult = result;
13138
13139   //argout typemap for const std::string&
13140
13141   return jresult;
13142 }
13143
13144
13145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13146   unsigned int jresult ;
13147   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13148   Dali::Property::Index arg2 ;
13149   bool result;
13150
13151   arg1 = (Dali::Handle *)jarg1;
13152   arg2 = (Dali::Property::Index)jarg2;
13153   {
13154     try {
13155       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13156     } CALL_CATCH_EXCEPTION(0);
13157   }
13158
13159   jresult = result;
13160   return jresult;
13161 }
13162
13163
13164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13165   unsigned int jresult ;
13166   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13167   Dali::Property::Index arg2 ;
13168   bool result;
13169
13170   arg1 = (Dali::Handle *)jarg1;
13171   arg2 = (Dali::Property::Index)jarg2;
13172   {
13173     try {
13174       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13175     } CALL_CATCH_EXCEPTION(0);
13176   }
13177
13178   jresult = result;
13179   return jresult;
13180 }
13181
13182
13183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13184   unsigned int jresult ;
13185   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13186   Dali::Property::Index arg2 ;
13187   bool result;
13188
13189   arg1 = (Dali::Handle *)jarg1;
13190   arg2 = (Dali::Property::Index)jarg2;
13191   {
13192     try {
13193       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13194     } CALL_CATCH_EXCEPTION(0);
13195   }
13196
13197   jresult = result;
13198   return jresult;
13199 }
13200
13201
13202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13203   int jresult ;
13204   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13205   Dali::Property::Index arg2 ;
13206   Dali::Property::Type result;
13207
13208   arg1 = (Dali::Handle *)jarg1;
13209   arg2 = (Dali::Property::Index)jarg2;
13210   {
13211     try {
13212       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13213     } CALL_CATCH_EXCEPTION(0);
13214   }
13215
13216   jresult = (int)result;
13217   return jresult;
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13222   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13223   Dali::Property::Index arg2 ;
13224   Dali::Property::Value *arg3 = 0 ;
13225
13226   arg1 = (Dali::Handle *)jarg1;
13227   arg2 = (Dali::Property::Index)jarg2;
13228   arg3 = (Dali::Property::Value *)jarg3;
13229   if (!arg3) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13231     return ;
13232   }
13233   {
13234     try {
13235       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13236     } CALL_CATCH_EXCEPTION();
13237   }
13238
13239 }
13240
13241
13242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13243   int jresult ;
13244   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13245   std::string *arg2 = 0 ;
13246   Dali::Property::Value *arg3 = 0 ;
13247   Dali::Property::Index result;
13248
13249   arg1 = (Dali::Handle *)jarg1;
13250   if (!jarg2) {
13251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13252     return 0;
13253   }
13254   std::string arg2_str(jarg2);
13255   arg2 = &arg2_str;
13256   arg3 = (Dali::Property::Value *)jarg3;
13257   if (!arg3) {
13258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13259     return 0;
13260   }
13261   {
13262     try {
13263       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13264     } CALL_CATCH_EXCEPTION(0);
13265   }
13266
13267   jresult = result;
13268
13269   //argout typemap for const std::string&
13270
13271   return jresult;
13272 }
13273
13274
13275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13276   int jresult ;
13277   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13278   std::string *arg2 = 0 ;
13279   Dali::Property::Value *arg3 = 0 ;
13280   Dali::Property::AccessMode arg4 ;
13281   Dali::Property::Index result;
13282
13283   arg1 = (Dali::Handle *)jarg1;
13284   if (!jarg2) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13286     return 0;
13287   }
13288   std::string arg2_str(jarg2);
13289   arg2 = &arg2_str;
13290   arg3 = (Dali::Property::Value *)jarg3;
13291   if (!arg3) {
13292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13293     return 0;
13294   }
13295   arg4 = (Dali::Property::AccessMode)jarg4;
13296   {
13297     try {
13298       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13299     } CALL_CATCH_EXCEPTION(0);
13300   }
13301
13302   jresult = result;
13303
13304   //argout typemap for const std::string&
13305
13306   return jresult;
13307 }
13308
13309
13310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13311   void * jresult ;
13312   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13313   Dali::Property::Index arg2 ;
13314   Dali::Property::Value result;
13315
13316   arg1 = (Dali::Handle *)jarg1;
13317   arg2 = (Dali::Property::Index)jarg2;
13318   {
13319     try {
13320       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13321     } CALL_CATCH_EXCEPTION(0);
13322   }
13323
13324   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13325   return jresult;
13326 }
13327
13328
13329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13330   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13331   Dali::Property::IndexContainer *arg2 = 0 ;
13332
13333   arg1 = (Dali::Handle *)jarg1;
13334   arg2 = (Dali::Property::IndexContainer *)jarg2;
13335   if (!arg2) {
13336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13337     return ;
13338   }
13339   {
13340     try {
13341       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13342     } CALL_CATCH_EXCEPTION();
13343   }
13344
13345 }
13346
13347
13348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13349   void * jresult ;
13350   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13351   Dali::Property::Index arg2 ;
13352   Dali::PropertyCondition *arg3 = 0 ;
13353   Dali::PropertyNotification result;
13354
13355   arg1 = (Dali::Handle *)jarg1;
13356   arg2 = (Dali::Property::Index)jarg2;
13357   arg3 = (Dali::PropertyCondition *)jarg3;
13358   if (!arg3) {
13359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13360     return 0;
13361   }
13362   {
13363     try {
13364       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13365     } CALL_CATCH_EXCEPTION(0);
13366   }
13367
13368   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13369   return jresult;
13370 }
13371
13372
13373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13374   void * jresult ;
13375   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13376   Dali::Property::Index arg2 ;
13377   int arg3 ;
13378   Dali::PropertyCondition *arg4 = 0 ;
13379   Dali::PropertyNotification result;
13380
13381   arg1 = (Dali::Handle *)jarg1;
13382   arg2 = (Dali::Property::Index)jarg2;
13383   arg3 = (int)jarg3;
13384   arg4 = (Dali::PropertyCondition *)jarg4;
13385   if (!arg4) {
13386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13387     return 0;
13388   }
13389   {
13390     try {
13391       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13392     } CALL_CATCH_EXCEPTION(0);
13393   }
13394
13395   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13396   return jresult;
13397 }
13398
13399
13400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13401   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13402   Dali::PropertyNotification arg2 ;
13403   Dali::PropertyNotification *argp2 ;
13404
13405   arg1 = (Dali::Handle *)jarg1;
13406   argp2 = (Dali::PropertyNotification *)jarg2;
13407   if (!argp2) {
13408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13409     return ;
13410   }
13411   arg2 = *argp2;
13412   {
13413     try {
13414       (arg1)->RemovePropertyNotification(arg2);
13415     } CALL_CATCH_EXCEPTION();
13416   }
13417
13418 }
13419
13420
13421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13422   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13423
13424   arg1 = (Dali::Handle *)jarg1;
13425   {
13426     try {
13427       (arg1)->RemovePropertyNotifications();
13428     } CALL_CATCH_EXCEPTION();
13429   }
13430
13431 }
13432
13433
13434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13435   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13436
13437   arg1 = (Dali::Handle *)jarg1;
13438   {
13439     try {
13440       (arg1)->RemoveConstraints();
13441     } CALL_CATCH_EXCEPTION();
13442   }
13443
13444 }
13445
13446
13447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13448   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13449   unsigned int arg2 ;
13450
13451   arg1 = (Dali::Handle *)jarg1;
13452   arg2 = (unsigned int)jarg2;
13453   {
13454     try {
13455       (arg1)->RemoveConstraints(arg2);
13456     } CALL_CATCH_EXCEPTION();
13457   }
13458
13459 }
13460
13461
13462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13463   int jresult ;
13464   Dali::Property::Index result;
13465
13466   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13467   jresult = result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13473   void * jresult ;
13474   Dali::Handle result;
13475
13476   {
13477     try {
13478       result = Dali::WeightObject::New();
13479     } CALL_CATCH_EXCEPTION(0);
13480   }
13481
13482   jresult = new Dali::Handle((const Dali::Handle &)result);
13483   return jresult;
13484 }
13485
13486
13487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13488   void * jresult ;
13489   Dali::TypeInfo *result = 0 ;
13490
13491   {
13492     try {
13493       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13494     } CALL_CATCH_EXCEPTION(0);
13495   }
13496
13497   jresult = (void *)result;
13498   return jresult;
13499 }
13500
13501
13502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13503   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13504
13505   arg1 = (Dali::TypeInfo *)jarg1;
13506   {
13507     try {
13508       delete arg1;
13509     } CALL_CATCH_EXCEPTION();
13510   }
13511
13512 }
13513
13514
13515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13516   void * jresult ;
13517   Dali::TypeInfo *arg1 = 0 ;
13518   Dali::TypeInfo *result = 0 ;
13519
13520   arg1 = (Dali::TypeInfo *)jarg1;
13521   if (!arg1) {
13522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13523     return 0;
13524   }
13525   {
13526     try {
13527       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13528     } CALL_CATCH_EXCEPTION(0);
13529   }
13530
13531   jresult = (void *)result;
13532   return jresult;
13533 }
13534
13535
13536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13537   void * jresult ;
13538   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13539   Dali::TypeInfo *arg2 = 0 ;
13540   Dali::TypeInfo *result = 0 ;
13541
13542   arg1 = (Dali::TypeInfo *)jarg1;
13543   arg2 = (Dali::TypeInfo *)jarg2;
13544   if (!arg2) {
13545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13546     return 0;
13547   }
13548   {
13549     try {
13550       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13551     } CALL_CATCH_EXCEPTION(0);
13552   }
13553
13554   jresult = (void *)result;
13555   return jresult;
13556 }
13557
13558
13559 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13560   char * jresult ;
13561   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13562   std::string *result = 0 ;
13563
13564   arg1 = (Dali::TypeInfo *)jarg1;
13565   {
13566     try {
13567       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13568     } CALL_CATCH_EXCEPTION(0);
13569   }
13570
13571   jresult = SWIG_csharp_string_callback(result->c_str());
13572   return jresult;
13573 }
13574
13575
13576 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13577   char * jresult ;
13578   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13579   std::string *result = 0 ;
13580
13581   arg1 = (Dali::TypeInfo *)jarg1;
13582   {
13583     try {
13584       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13585     } CALL_CATCH_EXCEPTION(0);
13586   }
13587
13588   jresult = SWIG_csharp_string_callback(result->c_str());
13589   return jresult;
13590 }
13591
13592
13593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13594   void * jresult ;
13595   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13596   Dali::BaseHandle result;
13597
13598   arg1 = (Dali::TypeInfo *)jarg1;
13599   {
13600     try {
13601       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13602     } CALL_CATCH_EXCEPTION(0);
13603   }
13604
13605   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13606   return jresult;
13607 }
13608
13609
13610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13611   unsigned long jresult ;
13612   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13613   size_t result;
13614
13615   arg1 = (Dali::TypeInfo *)jarg1;
13616   {
13617     try {
13618       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13619     } CALL_CATCH_EXCEPTION(0);
13620   }
13621
13622   jresult = (unsigned long)result;
13623   return jresult;
13624 }
13625
13626
13627 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13628   char * jresult ;
13629   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13630   size_t arg2 ;
13631   std::string result;
13632
13633   arg1 = (Dali::TypeInfo *)jarg1;
13634   arg2 = (size_t)jarg2;
13635   {
13636     try {
13637       result = (arg1)->GetActionName(arg2);
13638     } CALL_CATCH_EXCEPTION(0);
13639   }
13640
13641   jresult = SWIG_csharp_string_callback((&result)->c_str());
13642   return jresult;
13643 }
13644
13645
13646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13647   unsigned long jresult ;
13648   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13649   size_t result;
13650
13651   arg1 = (Dali::TypeInfo *)jarg1;
13652   {
13653     try {
13654       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13655     } CALL_CATCH_EXCEPTION(0);
13656   }
13657
13658   jresult = (unsigned long)result;
13659   return jresult;
13660 }
13661
13662
13663 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13664   char * jresult ;
13665   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13666   size_t arg2 ;
13667   std::string result;
13668
13669   arg1 = (Dali::TypeInfo *)jarg1;
13670   arg2 = (size_t)jarg2;
13671   {
13672     try {
13673       result = (arg1)->GetSignalName(arg2);
13674     } CALL_CATCH_EXCEPTION(0);
13675   }
13676
13677   jresult = SWIG_csharp_string_callback((&result)->c_str());
13678   return jresult;
13679 }
13680
13681
13682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13683   unsigned long jresult ;
13684   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13685   size_t result;
13686
13687   arg1 = (Dali::TypeInfo *)jarg1;
13688   {
13689     try {
13690       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13691     } CALL_CATCH_EXCEPTION(0);
13692   }
13693
13694   jresult = (unsigned long)result;
13695   return jresult;
13696 }
13697
13698
13699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13700   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13701   Dali::Property::IndexContainer *arg2 = 0 ;
13702
13703   arg1 = (Dali::TypeInfo *)jarg1;
13704   arg2 = (Dali::Property::IndexContainer *)jarg2;
13705   if (!arg2) {
13706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13707     return ;
13708   }
13709   {
13710     try {
13711       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13712     } CALL_CATCH_EXCEPTION();
13713   }
13714
13715 }
13716
13717
13718 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13719   char * jresult ;
13720   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13721   Dali::Property::Index arg2 ;
13722   std::string *result = 0 ;
13723
13724   arg1 = (Dali::TypeInfo *)jarg1;
13725   arg2 = (Dali::Property::Index)jarg2;
13726   {
13727     try {
13728       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13729     } CALL_CATCH_EXCEPTION(0);
13730   }
13731
13732   jresult = SWIG_csharp_string_callback(result->c_str());
13733   return jresult;
13734 }
13735
13736
13737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13738   void * jresult ;
13739   Dali::TypeRegistry result;
13740
13741   {
13742     try {
13743       result = Dali::TypeRegistry::Get();
13744     } CALL_CATCH_EXCEPTION(0);
13745   }
13746
13747   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13748   return jresult;
13749 }
13750
13751
13752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13753   void * jresult ;
13754   Dali::TypeRegistry *result = 0 ;
13755
13756   {
13757     try {
13758       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13759     } CALL_CATCH_EXCEPTION(0);
13760   }
13761
13762   jresult = (void *)result;
13763   return jresult;
13764 }
13765
13766
13767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13768   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13769
13770   arg1 = (Dali::TypeRegistry *)jarg1;
13771   {
13772     try {
13773       delete arg1;
13774     } CALL_CATCH_EXCEPTION();
13775   }
13776
13777 }
13778
13779
13780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13781   void * jresult ;
13782   Dali::TypeRegistry *arg1 = 0 ;
13783   Dali::TypeRegistry *result = 0 ;
13784
13785   arg1 = (Dali::TypeRegistry *)jarg1;
13786   if (!arg1) {
13787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13788     return 0;
13789   }
13790   {
13791     try {
13792       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13793     } CALL_CATCH_EXCEPTION(0);
13794   }
13795
13796   jresult = (void *)result;
13797   return jresult;
13798 }
13799
13800
13801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13802   void * jresult ;
13803   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13804   Dali::TypeRegistry *arg2 = 0 ;
13805   Dali::TypeRegistry *result = 0 ;
13806
13807   arg1 = (Dali::TypeRegistry *)jarg1;
13808   arg2 = (Dali::TypeRegistry *)jarg2;
13809   if (!arg2) {
13810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13811     return 0;
13812   }
13813   {
13814     try {
13815       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13816     } CALL_CATCH_EXCEPTION(0);
13817   }
13818
13819   jresult = (void *)result;
13820   return jresult;
13821 }
13822
13823
13824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13825   void * jresult ;
13826   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13827   std::string *arg2 = 0 ;
13828   Dali::TypeInfo result;
13829
13830   arg1 = (Dali::TypeRegistry *)jarg1;
13831   if (!jarg2) {
13832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13833     return 0;
13834   }
13835   std::string arg2_str(jarg2);
13836   arg2 = &arg2_str;
13837   {
13838     try {
13839       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13840     } CALL_CATCH_EXCEPTION(0);
13841   }
13842
13843   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13844
13845   //argout typemap for const std::string&
13846
13847   return jresult;
13848 }
13849
13850
13851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13852   void * jresult ;
13853   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13854   std::type_info *arg2 = 0 ;
13855   Dali::TypeInfo result;
13856
13857   arg1 = (Dali::TypeRegistry *)jarg1;
13858   arg2 = (std::type_info *)jarg2;
13859   if (!arg2) {
13860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13861     return 0;
13862   }
13863   {
13864     try {
13865       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13866     } CALL_CATCH_EXCEPTION(0);
13867   }
13868
13869   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13875   unsigned long jresult ;
13876   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13877   size_t result;
13878
13879   arg1 = (Dali::TypeRegistry *)jarg1;
13880   {
13881     try {
13882       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13883     } CALL_CATCH_EXCEPTION(0);
13884   }
13885
13886   jresult = (unsigned long)result;
13887   return jresult;
13888 }
13889
13890
13891 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13892   char * jresult ;
13893   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13894   size_t arg2 ;
13895   std::string result;
13896
13897   arg1 = (Dali::TypeRegistry *)jarg1;
13898   arg2 = (size_t)jarg2;
13899   {
13900     try {
13901       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13902     } CALL_CATCH_EXCEPTION(0);
13903   }
13904
13905   jresult = SWIG_csharp_string_callback((&result)->c_str());
13906   return jresult;
13907 }
13908
13909
13910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13911   void * jresult ;
13912   std::type_info *arg1 = 0 ;
13913   std::type_info *arg2 = 0 ;
13914   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13915   Dali::TypeRegistration *result = 0 ;
13916
13917   arg1 = (std::type_info *)jarg1;
13918   if (!arg1) {
13919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13920     return 0;
13921   }
13922   arg2 = (std::type_info *)jarg2;
13923   if (!arg2) {
13924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13925     return 0;
13926   }
13927   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13928   {
13929     try {
13930       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13931     } CALL_CATCH_EXCEPTION(0);
13932   }
13933
13934   jresult = (void *)result;
13935   return jresult;
13936 }
13937
13938
13939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
13940   void * jresult ;
13941   std::type_info *arg1 = 0 ;
13942   std::type_info *arg2 = 0 ;
13943   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13944   bool arg4 ;
13945   Dali::TypeRegistration *result = 0 ;
13946
13947   arg1 = (std::type_info *)jarg1;
13948   if (!arg1) {
13949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13950     return 0;
13951   }
13952   arg2 = (std::type_info *)jarg2;
13953   if (!arg2) {
13954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13955     return 0;
13956   }
13957   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13958   arg4 = jarg4 ? true : false;
13959   {
13960     try {
13961       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13962     } CALL_CATCH_EXCEPTION(0);
13963   }
13964
13965   jresult = (void *)result;
13966   return jresult;
13967 }
13968
13969
13970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13971   void * jresult ;
13972   std::string *arg1 = 0 ;
13973   std::type_info *arg2 = 0 ;
13974   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13975   Dali::TypeRegistration *result = 0 ;
13976
13977   if (!jarg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13979     return 0;
13980   }
13981   std::string arg1_str(jarg1);
13982   arg1 = &arg1_str;
13983   arg2 = (std::type_info *)jarg2;
13984   if (!arg2) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13986     return 0;
13987   }
13988   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13989   {
13990     try {
13991       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13992     } CALL_CATCH_EXCEPTION(0);
13993   }
13994
13995   jresult = (void *)result;
13996
13997   //argout typemap for const std::string&
13998
13999   return jresult;
14000 }
14001
14002
14003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
14004   char * jresult ;
14005   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14006   std::string result;
14007
14008   arg1 = (Dali::TypeRegistration *)jarg1;
14009   {
14010     try {
14011       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
14012     } CALL_CATCH_EXCEPTION(0);
14013   }
14014
14015   jresult = SWIG_csharp_string_callback((&result)->c_str());
14016   return jresult;
14017 }
14018
14019
14020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
14021   std::string *arg1 = 0 ;
14022   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14023
14024   if (!jarg1) {
14025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14026     return ;
14027   }
14028   std::string arg1_str(jarg1);
14029   arg1 = &arg1_str;
14030   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
14031   {
14032     try {
14033       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14034     } CALL_CATCH_EXCEPTION();
14035   }
14036
14037
14038   //argout typemap for const std::string&
14039
14040 }
14041
14042
14043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14044   std::string *arg1 = 0 ;
14045   std::string *arg2 = 0 ;
14046   int arg3 ;
14047   Dali::Property::Type arg4 ;
14048   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14049   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14050
14051   if (!jarg1) {
14052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14053     return ;
14054   }
14055   std::string arg1_str(jarg1);
14056   arg1 = &arg1_str;
14057   if (!jarg2) {
14058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14059     return ;
14060   }
14061   std::string arg2_str(jarg2);
14062   arg2 = &arg2_str;
14063   arg3 = (int)jarg3;
14064   arg4 = (Dali::Property::Type)jarg4;
14065   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14066   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14067   {
14068     try {
14069       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14070     } CALL_CATCH_EXCEPTION();
14071   }
14072
14073
14074   //argout typemap for const std::string&
14075
14076
14077   //argout typemap for const std::string&
14078
14079 }
14080
14081
14082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14083   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14084
14085   arg1 = (Dali::TypeRegistration *)jarg1;
14086   {
14087     try {
14088       delete arg1;
14089     } CALL_CATCH_EXCEPTION();
14090   }
14091
14092 }
14093
14094
14095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14096   void * jresult ;
14097   Dali::TypeRegistration *arg1 = 0 ;
14098   std::string *arg2 = 0 ;
14099   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14100   Dali::SignalConnectorType *result = 0 ;
14101
14102   arg1 = (Dali::TypeRegistration *)jarg1;
14103   if (!arg1) {
14104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14105     return 0;
14106   }
14107   if (!jarg2) {
14108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14109     return 0;
14110   }
14111   std::string arg2_str(jarg2);
14112   arg2 = &arg2_str;
14113   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14114   {
14115     try {
14116       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14117     } CALL_CATCH_EXCEPTION(0);
14118   }
14119
14120   jresult = (void *)result;
14121
14122   //argout typemap for const std::string&
14123
14124   return jresult;
14125 }
14126
14127
14128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14129   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14130
14131   arg1 = (Dali::SignalConnectorType *)jarg1;
14132   {
14133     try {
14134       delete arg1;
14135     } CALL_CATCH_EXCEPTION();
14136   }
14137
14138 }
14139
14140
14141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14142   void * jresult ;
14143   Dali::TypeRegistration *arg1 = 0 ;
14144   std::string *arg2 = 0 ;
14145   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14146   Dali::TypeAction *result = 0 ;
14147
14148   arg1 = (Dali::TypeRegistration *)jarg1;
14149   if (!arg1) {
14150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14151     return 0;
14152   }
14153   if (!jarg2) {
14154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14155     return 0;
14156   }
14157   std::string arg2_str(jarg2);
14158   arg2 = &arg2_str;
14159   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14160   {
14161     try {
14162       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14163     } CALL_CATCH_EXCEPTION(0);
14164   }
14165
14166   jresult = (void *)result;
14167
14168   //argout typemap for const std::string&
14169
14170   return jresult;
14171 }
14172
14173
14174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14175   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14176
14177   arg1 = (Dali::TypeAction *)jarg1;
14178   {
14179     try {
14180       delete arg1;
14181     } CALL_CATCH_EXCEPTION();
14182   }
14183
14184 }
14185
14186
14187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14188   void * jresult ;
14189   Dali::TypeRegistration *arg1 = 0 ;
14190   std::string *arg2 = 0 ;
14191   Dali::Property::Index arg3 ;
14192   Dali::Property::Type arg4 ;
14193   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14194   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14195   Dali::PropertyRegistration *result = 0 ;
14196
14197   arg1 = (Dali::TypeRegistration *)jarg1;
14198   if (!arg1) {
14199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14200     return 0;
14201   }
14202   if (!jarg2) {
14203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14204     return 0;
14205   }
14206   std::string arg2_str(jarg2);
14207   arg2 = &arg2_str;
14208   arg3 = (Dali::Property::Index)jarg3;
14209   arg4 = (Dali::Property::Type)jarg4;
14210   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14211   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14212   {
14213     try {
14214       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14215     } CALL_CATCH_EXCEPTION(0);
14216   }
14217
14218   jresult = (void *)result;
14219
14220   //argout typemap for const std::string&
14221
14222   return jresult;
14223 }
14224
14225
14226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14227   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14228
14229   arg1 = (Dali::PropertyRegistration *)jarg1;
14230   {
14231     try {
14232       delete arg1;
14233     } CALL_CATCH_EXCEPTION();
14234   }
14235
14236 }
14237
14238
14239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14240   void * jresult ;
14241   Dali::TypeRegistration *arg1 = 0 ;
14242   std::string *arg2 = 0 ;
14243   Dali::Property::Index arg3 ;
14244   Dali::Property::Type arg4 ;
14245   Dali::AnimatablePropertyRegistration *result = 0 ;
14246
14247   arg1 = (Dali::TypeRegistration *)jarg1;
14248   if (!arg1) {
14249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14250     return 0;
14251   }
14252   if (!jarg2) {
14253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14254     return 0;
14255   }
14256   std::string arg2_str(jarg2);
14257   arg2 = &arg2_str;
14258   arg3 = (Dali::Property::Index)jarg3;
14259   arg4 = (Dali::Property::Type)jarg4;
14260   {
14261     try {
14262       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14263     } CALL_CATCH_EXCEPTION(0);
14264   }
14265
14266   jresult = (void *)result;
14267
14268   //argout typemap for const std::string&
14269
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14275   void * jresult ;
14276   Dali::TypeRegistration *arg1 = 0 ;
14277   std::string *arg2 = 0 ;
14278   Dali::Property::Index arg3 ;
14279   Dali::Property::Value *arg4 = 0 ;
14280   Dali::AnimatablePropertyRegistration *result = 0 ;
14281
14282   arg1 = (Dali::TypeRegistration *)jarg1;
14283   if (!arg1) {
14284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14285     return 0;
14286   }
14287   if (!jarg2) {
14288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14289     return 0;
14290   }
14291   std::string arg2_str(jarg2);
14292   arg2 = &arg2_str;
14293   arg3 = (Dali::Property::Index)jarg3;
14294   arg4 = (Dali::Property::Value *)jarg4;
14295   if (!arg4) {
14296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14297     return 0;
14298   }
14299   {
14300     try {
14301       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14302     } CALL_CATCH_EXCEPTION(0);
14303   }
14304
14305   jresult = (void *)result;
14306
14307   //argout typemap for const std::string&
14308
14309   return jresult;
14310 }
14311
14312
14313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14314   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14315
14316   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14317   {
14318     try {
14319       delete arg1;
14320     } CALL_CATCH_EXCEPTION();
14321   }
14322
14323 }
14324
14325
14326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14327   void * jresult ;
14328   Dali::TypeRegistration *arg1 = 0 ;
14329   std::string *arg2 = 0 ;
14330   Dali::Property::Index arg3 ;
14331   Dali::Property::Index arg4 ;
14332   unsigned int arg5 ;
14333   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14334
14335   arg1 = (Dali::TypeRegistration *)jarg1;
14336   if (!arg1) {
14337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14338     return 0;
14339   }
14340   if (!jarg2) {
14341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14342     return 0;
14343   }
14344   std::string arg2_str(jarg2);
14345   arg2 = &arg2_str;
14346   arg3 = (Dali::Property::Index)jarg3;
14347   arg4 = (Dali::Property::Index)jarg4;
14348   arg5 = (unsigned int)jarg5;
14349   {
14350     try {
14351       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14352     } CALL_CATCH_EXCEPTION(0);
14353   }
14354
14355   jresult = (void *)result;
14356
14357   //argout typemap for const std::string&
14358
14359   return jresult;
14360 }
14361
14362
14363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14364   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14365
14366   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14367   {
14368     try {
14369       delete arg1;
14370     } CALL_CATCH_EXCEPTION();
14371   }
14372
14373 }
14374
14375
14376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14377   void * jresult ;
14378   Dali::TypeRegistration *arg1 = 0 ;
14379   std::string *arg2 = 0 ;
14380   Dali::Property::Index arg3 ;
14381   Dali::Property::Type arg4 ;
14382   Dali::ChildPropertyRegistration *result = 0 ;
14383
14384   arg1 = (Dali::TypeRegistration *)jarg1;
14385   if (!arg1) {
14386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14387     return 0;
14388   }
14389   if (!jarg2) {
14390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14391     return 0;
14392   }
14393   std::string arg2_str(jarg2);
14394   arg2 = &arg2_str;
14395   arg3 = (Dali::Property::Index)jarg3;
14396   arg4 = (Dali::Property::Type)jarg4;
14397   {
14398     try {
14399       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14400     } CALL_CATCH_EXCEPTION(0);
14401   }
14402
14403   jresult = (void *)result;
14404
14405   //argout typemap for const std::string&
14406
14407   return jresult;
14408 }
14409
14410
14411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14412   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14413
14414   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14415   {
14416     try {
14417       delete arg1;
14418     } CALL_CATCH_EXCEPTION();
14419   }
14420
14421 }
14422
14423
14424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14425   unsigned int jresult ;
14426   std::string *arg1 = 0 ;
14427   std::type_info *arg2 = 0 ;
14428   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14429   bool result;
14430
14431   if (!jarg1) {
14432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14433     return 0;
14434   }
14435   std::string arg1_str(jarg1);
14436   arg1 = &arg1_str;
14437   arg2 = (std::type_info *)jarg2;
14438   if (!arg2) {
14439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14440     return 0;
14441   }
14442   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14443   {
14444     try {
14445       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14446     } CALL_CATCH_EXCEPTION(0);
14447   }
14448
14449   jresult = result;
14450
14451   //argout typemap for const std::string&
14452
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14458   unsigned int jresult ;
14459   std::string *arg1 = 0 ;
14460   std::string *arg2 = 0 ;
14461   Dali::Property::Index arg3 ;
14462   Dali::Property::Type arg4 ;
14463   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14464   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14465   bool result;
14466
14467   if (!jarg1) {
14468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14469     return 0;
14470   }
14471   std::string arg1_str(jarg1);
14472   arg1 = &arg1_str;
14473   if (!jarg2) {
14474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14475     return 0;
14476   }
14477   std::string arg2_str(jarg2);
14478   arg2 = &arg2_str;
14479   arg3 = (Dali::Property::Index)jarg3;
14480   arg4 = (Dali::Property::Type)jarg4;
14481   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14482   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14483   {
14484     try {
14485       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14486     } CALL_CATCH_EXCEPTION(0);
14487   }
14488
14489   jresult = result;
14490
14491   //argout typemap for const std::string&
14492
14493
14494   //argout typemap for const std::string&
14495
14496   return jresult;
14497 }
14498
14499
14500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14501   float jresult ;
14502   float result;
14503
14504   result = (float)(float)Dali::ParentOrigin::TOP;
14505   jresult = result;
14506   return jresult;
14507 }
14508
14509
14510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14511   float jresult ;
14512   float result;
14513
14514   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14515   jresult = result;
14516   return jresult;
14517 }
14518
14519
14520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14521   float jresult ;
14522   float result;
14523
14524   result = (float)(float)Dali::ParentOrigin::LEFT;
14525   jresult = result;
14526   return jresult;
14527 }
14528
14529
14530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14531   float jresult ;
14532   float result;
14533
14534   result = (float)(float)Dali::ParentOrigin::RIGHT;
14535   jresult = result;
14536   return jresult;
14537 }
14538
14539
14540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14541   float jresult ;
14542   float result;
14543
14544   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14551   void * jresult ;
14552   Dali::Vector3 *result = 0 ;
14553
14554   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14555   jresult = (void *)result;
14556   return jresult;
14557 }
14558
14559
14560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14561   void * jresult ;
14562   Dali::Vector3 *result = 0 ;
14563
14564   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14565   jresult = (void *)result;
14566   return jresult;
14567 }
14568
14569
14570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14571   void * jresult ;
14572   Dali::Vector3 *result = 0 ;
14573
14574   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14575   jresult = (void *)result;
14576   return jresult;
14577 }
14578
14579
14580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14581   void * jresult ;
14582   Dali::Vector3 *result = 0 ;
14583
14584   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14585   jresult = (void *)result;
14586   return jresult;
14587 }
14588
14589
14590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14591   void * jresult ;
14592   Dali::Vector3 *result = 0 ;
14593
14594   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14595   jresult = (void *)result;
14596   return jresult;
14597 }
14598
14599
14600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14601   void * jresult ;
14602   Dali::Vector3 *result = 0 ;
14603
14604   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14605   jresult = (void *)result;
14606   return jresult;
14607 }
14608
14609
14610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14611   void * jresult ;
14612   Dali::Vector3 *result = 0 ;
14613
14614   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14615   jresult = (void *)result;
14616   return jresult;
14617 }
14618
14619
14620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14621   void * jresult ;
14622   Dali::Vector3 *result = 0 ;
14623
14624   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14625   jresult = (void *)result;
14626   return jresult;
14627 }
14628
14629
14630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14631   void * jresult ;
14632   Dali::Vector3 *result = 0 ;
14633
14634   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14635   jresult = (void *)result;
14636   return jresult;
14637 }
14638
14639
14640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14641   float jresult ;
14642   float result;
14643
14644   result = (float)(float)Dali::AnchorPoint::TOP;
14645   jresult = result;
14646   return jresult;
14647 }
14648
14649
14650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14651   float jresult ;
14652   float result;
14653
14654   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14655   jresult = result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14661   float jresult ;
14662   float result;
14663
14664   result = (float)(float)Dali::AnchorPoint::LEFT;
14665   jresult = result;
14666   return jresult;
14667 }
14668
14669
14670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14671   float jresult ;
14672   float result;
14673
14674   result = (float)(float)Dali::AnchorPoint::RIGHT;
14675   jresult = result;
14676   return jresult;
14677 }
14678
14679
14680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14681   float jresult ;
14682   float result;
14683
14684   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14685   jresult = result;
14686   return jresult;
14687 }
14688
14689
14690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14691   void * jresult ;
14692   Dali::Vector3 *result = 0 ;
14693
14694   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14695   jresult = (void *)result;
14696   return jresult;
14697 }
14698
14699
14700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14701   void * jresult ;
14702   Dali::Vector3 *result = 0 ;
14703
14704   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14705   jresult = (void *)result;
14706   return jresult;
14707 }
14708
14709
14710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14711   void * jresult ;
14712   Dali::Vector3 *result = 0 ;
14713
14714   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14715   jresult = (void *)result;
14716   return jresult;
14717 }
14718
14719
14720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14721   void * jresult ;
14722   Dali::Vector3 *result = 0 ;
14723
14724   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14725   jresult = (void *)result;
14726   return jresult;
14727 }
14728
14729
14730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14731   void * jresult ;
14732   Dali::Vector3 *result = 0 ;
14733
14734   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14735   jresult = (void *)result;
14736   return jresult;
14737 }
14738
14739
14740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14741   void * jresult ;
14742   Dali::Vector3 *result = 0 ;
14743
14744   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14745   jresult = (void *)result;
14746   return jresult;
14747 }
14748
14749
14750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14751   void * jresult ;
14752   Dali::Vector3 *result = 0 ;
14753
14754   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14755   jresult = (void *)result;
14756   return jresult;
14757 }
14758
14759
14760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14761   void * jresult ;
14762   Dali::Vector3 *result = 0 ;
14763
14764   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14765   jresult = (void *)result;
14766   return jresult;
14767 }
14768
14769
14770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14771   void * jresult ;
14772   Dali::Vector3 *result = 0 ;
14773
14774   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14775   jresult = (void *)result;
14776   return jresult;
14777 }
14778
14779
14780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14781   void * jresult ;
14782   Dali::Vector4 *result = 0 ;
14783
14784   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14785   jresult = (void *)result;
14786   return jresult;
14787 }
14788
14789
14790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
14791   void * jresult ;
14792   Dali::Vector4 *result = 0 ;
14793
14794   result = (Dali::Vector4 *)&Dali::Color::WHITE;
14795   jresult = (void *)result;
14796   return jresult;
14797 }
14798
14799
14800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
14801   void * jresult ;
14802   Dali::Vector4 *result = 0 ;
14803
14804   result = (Dali::Vector4 *)&Dali::Color::RED;
14805   jresult = (void *)result;
14806   return jresult;
14807 }
14808
14809
14810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14811   void * jresult ;
14812   Dali::Vector4 *result = 0 ;
14813
14814   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14815   jresult = (void *)result;
14816   return jresult;
14817 }
14818
14819
14820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14821   void * jresult ;
14822   Dali::Vector4 *result = 0 ;
14823
14824   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14825   jresult = (void *)result;
14826   return jresult;
14827 }
14828
14829
14830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
14831   void * jresult ;
14832   Dali::Vector4 *result = 0 ;
14833
14834   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
14835   jresult = (void *)result;
14836   return jresult;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
14841   void * jresult ;
14842   Dali::Vector4 *result = 0 ;
14843
14844   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
14845   jresult = (void *)result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14851   void * jresult ;
14852   Dali::Vector4 *result = 0 ;
14853
14854   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14855   jresult = (void *)result;
14856   return jresult;
14857 }
14858
14859
14860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
14861   void * jresult ;
14862   Dali::Vector4 *result = 0 ;
14863
14864   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
14865   jresult = (void *)result;
14866   return jresult;
14867 }
14868
14869
14870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
14871   float jresult ;
14872   float result;
14873
14874   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
14875   jresult = result;
14876   return jresult;
14877 }
14878
14879
14880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
14881   float jresult ;
14882   float result;
14883
14884   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
14885   jresult = result;
14886   return jresult;
14887 }
14888
14889
14890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
14891   float jresult ;
14892   float result;
14893
14894   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
14895   jresult = result;
14896   return jresult;
14897 }
14898
14899
14900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
14901   float jresult ;
14902   float result;
14903
14904   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
14905   jresult = result;
14906   return jresult;
14907 }
14908
14909
14910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
14911   float jresult ;
14912   float result;
14913
14914   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
14915   jresult = result;
14916   return jresult;
14917 }
14918
14919
14920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
14921   float jresult ;
14922   float result;
14923
14924   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
14925   jresult = result;
14926   return jresult;
14927 }
14928
14929
14930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
14931   float jresult ;
14932   float result;
14933
14934   result = (float)(float)Dali::Math::PI;
14935   jresult = result;
14936   return jresult;
14937 }
14938
14939
14940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
14941   float jresult ;
14942   float result;
14943
14944   result = (float)(float)Dali::Math::PI_2;
14945   jresult = result;
14946   return jresult;
14947 }
14948
14949
14950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
14951   float jresult ;
14952   float result;
14953
14954   result = (float)(float)Dali::Math::PI_4;
14955   jresult = result;
14956   return jresult;
14957 }
14958
14959
14960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
14961   float jresult ;
14962   float result;
14963
14964   result = (float)(float)Dali::Math::PI_OVER_180;
14965   jresult = result;
14966   return jresult;
14967 }
14968
14969
14970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
14971   float jresult ;
14972   float result;
14973
14974   result = (float)(float)Dali::Math::ONE80_OVER_PI;
14975   jresult = result;
14976   return jresult;
14977 }
14978
14979
14980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
14981   int jresult ;
14982   Dali::ResizePolicy::Type result;
14983
14984   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
14985   jresult = (int)result;
14986   return jresult;
14987 }
14988
14989
14990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
14991   unsigned long jresult ;
14992   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14993   Dali::VectorBase::SizeType result;
14994
14995   arg1 = (Dali::VectorBase *)jarg1;
14996   {
14997     try {
14998       result = ((Dali::VectorBase const *)arg1)->Count();
14999     } CALL_CATCH_EXCEPTION(0);
15000   }
15001
15002   jresult = (unsigned long)result;
15003   return jresult;
15004 }
15005
15006
15007 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15008   unsigned long jresult ;
15009   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15010   Dali::VectorBase::SizeType result;
15011
15012   arg1 = (Dali::VectorBase *)jarg1;
15013   {
15014     try {
15015       result = ((Dali::VectorBase const *)arg1)->Size();
15016     } CALL_CATCH_EXCEPTION(0);
15017   }
15018
15019   jresult = (unsigned long)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15025   unsigned int jresult ;
15026   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15027   bool result;
15028
15029   arg1 = (Dali::VectorBase *)jarg1;
15030   {
15031     try {
15032       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15033     } CALL_CATCH_EXCEPTION(0);
15034   }
15035
15036   jresult = result;
15037   return jresult;
15038 }
15039
15040
15041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15042   unsigned long jresult ;
15043   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15044   Dali::VectorBase::SizeType result;
15045
15046   arg1 = (Dali::VectorBase *)jarg1;
15047   {
15048     try {
15049       result = ((Dali::VectorBase const *)arg1)->Capacity();
15050     } CALL_CATCH_EXCEPTION(0);
15051   }
15052
15053   jresult = (unsigned long)result;
15054   return jresult;
15055 }
15056
15057
15058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15059   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15060
15061   arg1 = (Dali::VectorBase *)jarg1;
15062   {
15063     try {
15064       (arg1)->Release();
15065     } CALL_CATCH_EXCEPTION();
15066   }
15067
15068 }
15069
15070
15071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15072   int jresult ;
15073   Dali::Pixel::Format result;
15074
15075   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15076   jresult = (int)result;
15077   return jresult;
15078 }
15079
15080
15081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15082   int jresult ;
15083   Dali::Pixel::Format result;
15084
15085   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15086   jresult = (int)result;
15087   return jresult;
15088 }
15089
15090
15091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15092   unsigned int jresult ;
15093   Dali::Pixel::Format arg1 ;
15094   bool result;
15095
15096   arg1 = (Dali::Pixel::Format)jarg1;
15097   {
15098     try {
15099       result = (bool)Dali::Pixel::HasAlpha(arg1);
15100     } CALL_CATCH_EXCEPTION(0);
15101   }
15102
15103   jresult = result;
15104   return jresult;
15105 }
15106
15107
15108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15109   unsigned int jresult ;
15110   Dali::Pixel::Format arg1 ;
15111   unsigned int result;
15112
15113   arg1 = (Dali::Pixel::Format)jarg1;
15114   {
15115     try {
15116       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15117     } CALL_CATCH_EXCEPTION(0);
15118   }
15119
15120   jresult = result;
15121   return jresult;
15122 }
15123
15124
15125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15126   Dali::Pixel::Format arg1 ;
15127   int *arg2 = 0 ;
15128   int *arg3 = 0 ;
15129
15130   arg1 = (Dali::Pixel::Format)jarg1;
15131   arg2 = (int *)jarg2;
15132   if (!arg2) {
15133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15134     return ;
15135   }
15136   arg3 = (int *)jarg3;
15137   if (!arg3) {
15138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15139     return ;
15140   }
15141   {
15142     try {
15143       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15144     } CALL_CATCH_EXCEPTION();
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
15151   void * jresult ;
15152   unsigned char *arg1 = (unsigned char *) 0 ;
15153   unsigned int arg2 ;
15154   unsigned int arg3 ;
15155   unsigned int arg4 ;
15156   Dali::Pixel::Format arg5 ;
15157   Dali::PixelData::ReleaseFunction arg6 ;
15158   Dali::PixelData result;
15159
15160   arg1 = jarg1;
15161   arg2 = (unsigned int)jarg2;
15162   arg3 = (unsigned int)jarg3;
15163   arg4 = (unsigned int)jarg4;
15164   arg5 = (Dali::Pixel::Format)jarg5;
15165   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
15166   {
15167     try {
15168       auto pixelBuffer = new unsigned char[jarg2];
15169       memcpy( pixelBuffer, arg1, arg2);
15170       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
15171     } CALL_CATCH_EXCEPTION(0);
15172   }
15173
15174   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15175
15176
15177   return jresult;
15178 }
15179
15180
15181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15182   void * jresult ;
15183   Dali::PixelData *result = 0 ;
15184
15185   {
15186     try {
15187       result = (Dali::PixelData *)new Dali::PixelData();
15188     } CALL_CATCH_EXCEPTION(0);
15189   }
15190
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
15197   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15198
15199   arg1 = (Dali::PixelData *)jarg1;
15200   {
15201     try {
15202       delete arg1;
15203     } CALL_CATCH_EXCEPTION();
15204   }
15205
15206 }
15207
15208
15209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
15210   void * jresult ;
15211   Dali::PixelData *arg1 = 0 ;
15212   Dali::PixelData *result = 0 ;
15213
15214   arg1 = (Dali::PixelData *)jarg1;
15215   if (!arg1) {
15216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15217     return 0;
15218   }
15219   {
15220     try {
15221       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
15222     } CALL_CATCH_EXCEPTION(0);
15223   }
15224
15225   jresult = (void *)result;
15226   return jresult;
15227 }
15228
15229
15230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
15231   void * jresult ;
15232   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15233   Dali::PixelData *arg2 = 0 ;
15234   Dali::PixelData *result = 0 ;
15235
15236   arg1 = (Dali::PixelData *)jarg1;
15237   arg2 = (Dali::PixelData *)jarg2;
15238   if (!arg2) {
15239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15240     return 0;
15241   }
15242   {
15243     try {
15244       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
15245     } CALL_CATCH_EXCEPTION(0);
15246   }
15247
15248   jresult = (void *)result;
15249   return jresult;
15250 }
15251
15252
15253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
15254   unsigned int jresult ;
15255   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15256   unsigned int result;
15257
15258   arg1 = (Dali::PixelData *)jarg1;
15259   {
15260     try {
15261       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
15262     } CALL_CATCH_EXCEPTION(0);
15263   }
15264
15265   jresult = result;
15266   return jresult;
15267 }
15268
15269
15270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
15271   unsigned int jresult ;
15272   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15273   unsigned int result;
15274
15275   arg1 = (Dali::PixelData *)jarg1;
15276   {
15277     try {
15278       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
15279     } CALL_CATCH_EXCEPTION(0);
15280   }
15281
15282   jresult = result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
15288   int jresult ;
15289   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15290   Dali::Pixel::Format result;
15291
15292   arg1 = (Dali::PixelData *)jarg1;
15293   {
15294     try {
15295       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
15296     } CALL_CATCH_EXCEPTION(0);
15297   }
15298
15299   jresult = (int)result;
15300   return jresult;
15301 }
15302
15303
15304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
15305   unsigned int jresult ;
15306   unsigned int result;
15307
15308   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
15309   jresult = result;
15310   return jresult;
15311 }
15312
15313
15314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
15315   unsigned int jresult ;
15316   unsigned int result;
15317
15318   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
15319   jresult = result;
15320   return jresult;
15321 }
15322
15323
15324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
15325   unsigned int jresult ;
15326   unsigned int result;
15327
15328   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
15329   jresult = result;
15330   return jresult;
15331 }
15332
15333
15334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
15335   unsigned int jresult ;
15336   unsigned int result;
15337
15338   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
15339   jresult = result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
15345   unsigned int jresult ;
15346   unsigned int result;
15347
15348   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
15349   jresult = result;
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
15355   unsigned int jresult ;
15356   unsigned int result;
15357
15358   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
15359   jresult = result;
15360   return jresult;
15361 }
15362
15363
15364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
15365   void * jresult ;
15366   Dali::TextureType::Type arg1 ;
15367   Dali::Pixel::Format arg2 ;
15368   unsigned int arg3 ;
15369   unsigned int arg4 ;
15370   Dali::Texture result;
15371
15372   arg1 = (Dali::TextureType::Type)jarg1;
15373   arg2 = (Dali::Pixel::Format)jarg2;
15374   arg3 = (unsigned int)jarg3;
15375   arg4 = (unsigned int)jarg4;
15376   {
15377     try {
15378       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
15379     } CALL_CATCH_EXCEPTION(0);
15380   }
15381
15382   jresult = new Dali::Texture((const Dali::Texture &)result);
15383   return jresult;
15384 }
15385
15386
15387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
15388   void * jresult ;
15389   NativeImageInterface *arg1 = 0 ;
15390   Dali::Texture result;
15391
15392   arg1 = (NativeImageInterface *)jarg1;
15393   if (!arg1) {
15394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
15395     return 0;
15396   }
15397   {
15398     try {
15399       result = Dali::Texture::New(*arg1);
15400     } CALL_CATCH_EXCEPTION(0);
15401   }
15402
15403   jresult = new Dali::Texture((const Dali::Texture &)result);
15404   return jresult;
15405 }
15406
15407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
15408   void * jresult ;
15409   Dali::Texture *result = 0 ;
15410
15411   {
15412     try {
15413       result = (Dali::Texture *)new Dali::Texture();
15414     } CALL_CATCH_EXCEPTION(0);
15415   }
15416
15417   jresult = (void *)result;
15418   return jresult;
15419 }
15420
15421
15422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
15423   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15424
15425   arg1 = (Dali::Texture *)jarg1;
15426   {
15427     try {
15428       delete arg1;
15429     } CALL_CATCH_EXCEPTION();
15430   }
15431
15432 }
15433
15434
15435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
15436   void * jresult ;
15437   Dali::Texture *arg1 = 0 ;
15438   Dali::Texture *result = 0 ;
15439
15440   arg1 = (Dali::Texture *)jarg1;
15441   if (!arg1) {
15442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15443     return 0;
15444   }
15445   {
15446     try {
15447       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
15448     } CALL_CATCH_EXCEPTION(0);
15449   }
15450
15451   jresult = (void *)result;
15452   return jresult;
15453 }
15454
15455
15456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
15457   void * jresult ;
15458   Dali::BaseHandle arg1 ;
15459   Dali::BaseHandle *argp1 ;
15460   Dali::Texture result;
15461
15462   argp1 = (Dali::BaseHandle *)jarg1;
15463   if (!argp1) {
15464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15465     return 0;
15466   }
15467   arg1 = *argp1;
15468   {
15469     try {
15470       result = Dali::Texture::DownCast(arg1);
15471     } CALL_CATCH_EXCEPTION(0);
15472   }
15473
15474   jresult = new Dali::Texture((const Dali::Texture &)result);
15475   return jresult;
15476 }
15477
15478
15479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
15480   void * jresult ;
15481   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15482   Dali::Texture *arg2 = 0 ;
15483   Dali::Texture *result = 0 ;
15484
15485   arg1 = (Dali::Texture *)jarg1;
15486   arg2 = (Dali::Texture *)jarg2;
15487   if (!arg2) {
15488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15489     return 0;
15490   }
15491   {
15492     try {
15493       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
15494     } CALL_CATCH_EXCEPTION(0);
15495   }
15496
15497   jresult = (void *)result;
15498   return jresult;
15499 }
15500
15501
15502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
15503   unsigned int jresult ;
15504   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15505   Dali::PixelData arg2 ;
15506   Dali::PixelData *argp2 ;
15507   bool result;
15508
15509   arg1 = (Dali::Texture *)jarg1;
15510   argp2 = (Dali::PixelData *)jarg2;
15511   if (!argp2) {
15512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15513     return 0;
15514   }
15515   arg2 = *argp2;
15516   {
15517     try {
15518       result = (bool)(arg1)->Upload(arg2);
15519     } CALL_CATCH_EXCEPTION(0);
15520   }
15521
15522   jresult = result;
15523   return jresult;
15524 }
15525
15526
15527 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) {
15528   unsigned int jresult ;
15529   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15530   Dali::PixelData arg2 ;
15531   unsigned int arg3 ;
15532   unsigned int arg4 ;
15533   unsigned int arg5 ;
15534   unsigned int arg6 ;
15535   unsigned int arg7 ;
15536   unsigned int arg8 ;
15537   Dali::PixelData *argp2 ;
15538   bool result;
15539
15540   arg1 = (Dali::Texture *)jarg1;
15541   argp2 = (Dali::PixelData *)jarg2;
15542   if (!argp2) {
15543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15544     return 0;
15545   }
15546   arg2 = *argp2;
15547   arg3 = (unsigned int)jarg3;
15548   arg4 = (unsigned int)jarg4;
15549   arg5 = (unsigned int)jarg5;
15550   arg6 = (unsigned int)jarg6;
15551   arg7 = (unsigned int)jarg7;
15552   arg8 = (unsigned int)jarg8;
15553   {
15554     try {
15555       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15556     } CALL_CATCH_EXCEPTION(0);
15557   }
15558
15559   jresult = result;
15560   return jresult;
15561 }
15562
15563
15564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
15565   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15566
15567   arg1 = (Dali::Texture *)jarg1;
15568   {
15569     try {
15570       (arg1)->GenerateMipmaps();
15571     } CALL_CATCH_EXCEPTION();
15572   }
15573
15574 }
15575
15576
15577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
15578   unsigned int jresult ;
15579   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15580   unsigned int result;
15581
15582   arg1 = (Dali::Texture *)jarg1;
15583   {
15584     try {
15585       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
15586     } CALL_CATCH_EXCEPTION(0);
15587   }
15588
15589   jresult = result;
15590   return jresult;
15591 }
15592
15593
15594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
15595   unsigned int jresult ;
15596   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15597   unsigned int result;
15598
15599   arg1 = (Dali::Texture *)jarg1;
15600   {
15601     try {
15602       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
15603     } CALL_CATCH_EXCEPTION(0);
15604   }
15605
15606   jresult = result;
15607   return jresult;
15608 }
15609
15610
15611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
15612   void * jresult ;
15613   Dali::Sampler result;
15614
15615   {
15616     try {
15617       result = Dali::Sampler::New();
15618     } CALL_CATCH_EXCEPTION(0);
15619   }
15620
15621   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15622   return jresult;
15623 }
15624
15625
15626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
15627   void * jresult ;
15628   Dali::Sampler *result = 0 ;
15629
15630   {
15631     try {
15632       result = (Dali::Sampler *)new Dali::Sampler();
15633     } CALL_CATCH_EXCEPTION(0);
15634   }
15635
15636   jresult = (void *)result;
15637   return jresult;
15638 }
15639
15640
15641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
15642   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15643
15644   arg1 = (Dali::Sampler *)jarg1;
15645   {
15646     try {
15647       delete arg1;
15648     } CALL_CATCH_EXCEPTION();
15649   }
15650
15651 }
15652
15653
15654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
15655   void * jresult ;
15656   Dali::Sampler *arg1 = 0 ;
15657   Dali::Sampler *result = 0 ;
15658
15659   arg1 = (Dali::Sampler *)jarg1;
15660   if (!arg1) {
15661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15662     return 0;
15663   }
15664   {
15665     try {
15666       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
15667     } CALL_CATCH_EXCEPTION(0);
15668   }
15669
15670   jresult = (void *)result;
15671   return jresult;
15672 }
15673
15674
15675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
15676   void * jresult ;
15677   Dali::BaseHandle arg1 ;
15678   Dali::BaseHandle *argp1 ;
15679   Dali::Sampler result;
15680
15681   argp1 = (Dali::BaseHandle *)jarg1;
15682   if (!argp1) {
15683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15684     return 0;
15685   }
15686   arg1 = *argp1;
15687   {
15688     try {
15689       result = Dali::Sampler::DownCast(arg1);
15690     } CALL_CATCH_EXCEPTION(0);
15691   }
15692
15693   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15694   return jresult;
15695 }
15696
15697
15698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
15699   void * jresult ;
15700   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15701   Dali::Sampler *arg2 = 0 ;
15702   Dali::Sampler *result = 0 ;
15703
15704   arg1 = (Dali::Sampler *)jarg1;
15705   arg2 = (Dali::Sampler *)jarg2;
15706   if (!arg2) {
15707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15708     return 0;
15709   }
15710   {
15711     try {
15712       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
15713     } CALL_CATCH_EXCEPTION(0);
15714   }
15715
15716   jresult = (void *)result;
15717   return jresult;
15718 }
15719
15720
15721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
15722   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15723   Dali::FilterMode::Type arg2 ;
15724   Dali::FilterMode::Type arg3 ;
15725
15726   arg1 = (Dali::Sampler *)jarg1;
15727   arg2 = (Dali::FilterMode::Type)jarg2;
15728   arg3 = (Dali::FilterMode::Type)jarg3;
15729   {
15730     try {
15731       (arg1)->SetFilterMode(arg2,arg3);
15732     } CALL_CATCH_EXCEPTION();
15733   }
15734
15735 }
15736
15737
15738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
15739   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15740   Dali::WrapMode::Type arg2 ;
15741   Dali::WrapMode::Type arg3 ;
15742
15743   arg1 = (Dali::Sampler *)jarg1;
15744   arg2 = (Dali::WrapMode::Type)jarg2;
15745   arg3 = (Dali::WrapMode::Type)jarg3;
15746   {
15747     try {
15748       (arg1)->SetWrapMode(arg2,arg3);
15749     } CALL_CATCH_EXCEPTION();
15750   }
15751
15752 }
15753
15754
15755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
15756   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15757   Dali::WrapMode::Type arg2 ;
15758   Dali::WrapMode::Type arg3 ;
15759   Dali::WrapMode::Type arg4 ;
15760
15761   arg1 = (Dali::Sampler *)jarg1;
15762   arg2 = (Dali::WrapMode::Type)jarg2;
15763   arg3 = (Dali::WrapMode::Type)jarg3;
15764   arg4 = (Dali::WrapMode::Type)jarg4;
15765   {
15766     try {
15767       (arg1)->SetWrapMode(arg2,arg3,arg4);
15768     } CALL_CATCH_EXCEPTION();
15769   }
15770
15771 }
15772
15773
15774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
15775   void * jresult ;
15776   Dali::TextureSet result;
15777
15778   {
15779     try {
15780       result = Dali::TextureSet::New();
15781     } CALL_CATCH_EXCEPTION(0);
15782   }
15783
15784   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15785   return jresult;
15786 }
15787
15788
15789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
15790   void * jresult ;
15791   Dali::TextureSet *result = 0 ;
15792
15793   {
15794     try {
15795       result = (Dali::TextureSet *)new Dali::TextureSet();
15796     } CALL_CATCH_EXCEPTION(0);
15797   }
15798
15799   jresult = (void *)result;
15800   return jresult;
15801 }
15802
15803
15804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
15805   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15806
15807   arg1 = (Dali::TextureSet *)jarg1;
15808   {
15809     try {
15810       delete arg1;
15811     } CALL_CATCH_EXCEPTION();
15812   }
15813
15814 }
15815
15816
15817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
15818   void * jresult ;
15819   Dali::TextureSet *arg1 = 0 ;
15820   Dali::TextureSet *result = 0 ;
15821
15822   arg1 = (Dali::TextureSet *)jarg1;
15823   if (!arg1) {
15824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15825     return 0;
15826   }
15827   {
15828     try {
15829       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
15830     } CALL_CATCH_EXCEPTION(0);
15831   }
15832
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
15839   void * jresult ;
15840   Dali::BaseHandle arg1 ;
15841   Dali::BaseHandle *argp1 ;
15842   Dali::TextureSet result;
15843
15844   argp1 = (Dali::BaseHandle *)jarg1;
15845   if (!argp1) {
15846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15847     return 0;
15848   }
15849   arg1 = *argp1;
15850   {
15851     try {
15852       result = Dali::TextureSet::DownCast(arg1);
15853     } CALL_CATCH_EXCEPTION(0);
15854   }
15855
15856   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15857   return jresult;
15858 }
15859
15860
15861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
15862   void * jresult ;
15863   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15864   Dali::TextureSet *arg2 = 0 ;
15865   Dali::TextureSet *result = 0 ;
15866
15867   arg1 = (Dali::TextureSet *)jarg1;
15868   arg2 = (Dali::TextureSet *)jarg2;
15869   if (!arg2) {
15870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15871     return 0;
15872   }
15873   {
15874     try {
15875       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
15876     } CALL_CATCH_EXCEPTION(0);
15877   }
15878
15879   jresult = (void *)result;
15880   return jresult;
15881 }
15882
15883
15884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
15885   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15886   size_t arg2 ;
15887   Dali::Texture arg3 ;
15888   Dali::Texture *argp3 ;
15889
15890   arg1 = (Dali::TextureSet *)jarg1;
15891   arg2 = (size_t)jarg2;
15892   argp3 = (Dali::Texture *)jarg3;
15893   if (!argp3) {
15894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
15895     return ;
15896   }
15897   arg3 = *argp3;
15898   {
15899     try {
15900       (arg1)->SetTexture(arg2,arg3);
15901     } CALL_CATCH_EXCEPTION();
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
15908   void * jresult ;
15909   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15910   size_t arg2 ;
15911   Dali::Texture result;
15912
15913   arg1 = (Dali::TextureSet *)jarg1;
15914   arg2 = (size_t)jarg2;
15915   {
15916     try {
15917       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
15918     } CALL_CATCH_EXCEPTION(0);
15919   }
15920
15921   jresult = new Dali::Texture((const Dali::Texture &)result);
15922   return jresult;
15923 }
15924
15925
15926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
15927   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15928   size_t arg2 ;
15929   Dali::Sampler arg3 ;
15930   Dali::Sampler *argp3 ;
15931
15932   arg1 = (Dali::TextureSet *)jarg1;
15933   arg2 = (size_t)jarg2;
15934   argp3 = (Dali::Sampler *)jarg3;
15935   if (!argp3) {
15936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
15937     return ;
15938   }
15939   arg3 = *argp3;
15940   {
15941     try {
15942       (arg1)->SetSampler(arg2,arg3);
15943     } CALL_CATCH_EXCEPTION();
15944   }
15945
15946 }
15947
15948
15949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
15950   void * jresult ;
15951   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15952   size_t arg2 ;
15953   Dali::Sampler result;
15954
15955   arg1 = (Dali::TextureSet *)jarg1;
15956   arg2 = (size_t)jarg2;
15957   {
15958     try {
15959       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
15960     } CALL_CATCH_EXCEPTION(0);
15961   }
15962
15963   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15964   return jresult;
15965 }
15966
15967
15968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
15969   unsigned long jresult ;
15970   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15971   size_t result;
15972
15973   arg1 = (Dali::TextureSet *)jarg1;
15974   {
15975     try {
15976       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
15977     } CALL_CATCH_EXCEPTION(0);
15978   }
15979
15980   jresult = (unsigned long)result;
15981   return jresult;
15982 }
15983
15984
15985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
15986   void * jresult ;
15987   Dali::Property::Map *arg1 = 0 ;
15988   Dali::VertexBuffer result;
15989
15990   arg1 = (Dali::Property::Map *)jarg1;
15991   if (!arg1) {
15992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15993     return 0;
15994   }
15995   {
15996     try {
15997       result = Dali::VertexBuffer::New(*arg1);
15998     } CALL_CATCH_EXCEPTION(0);
15999   }
16000
16001   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16002   return jresult;
16003 }
16004
16005
16006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16007   void * jresult ;
16008   Dali::VertexBuffer *result = 0 ;
16009
16010   {
16011     try {
16012       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16013     } CALL_CATCH_EXCEPTION(0);
16014   }
16015
16016   jresult = (void *)result;
16017   return jresult;
16018 }
16019
16020
16021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16022   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16023
16024   arg1 = (Dali::VertexBuffer *)jarg1;
16025   {
16026     try {
16027       delete arg1;
16028     } CALL_CATCH_EXCEPTION();
16029   }
16030
16031 }
16032
16033
16034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16035   void * jresult ;
16036   Dali::VertexBuffer *arg1 = 0 ;
16037   Dali::VertexBuffer *result = 0 ;
16038
16039   arg1 = (Dali::VertexBuffer *)jarg1;
16040   if (!arg1) {
16041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16042     return 0;
16043   }
16044   {
16045     try {
16046       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16047     } CALL_CATCH_EXCEPTION(0);
16048   }
16049
16050   jresult = (void *)result;
16051   return jresult;
16052 }
16053
16054
16055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16056   void * jresult ;
16057   Dali::BaseHandle arg1 ;
16058   Dali::BaseHandle *argp1 ;
16059   Dali::VertexBuffer result;
16060
16061   argp1 = (Dali::BaseHandle *)jarg1;
16062   if (!argp1) {
16063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16064     return 0;
16065   }
16066   arg1 = *argp1;
16067   {
16068     try {
16069       result = Dali::VertexBuffer::DownCast(arg1);
16070     } CALL_CATCH_EXCEPTION(0);
16071   }
16072
16073   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16074   return jresult;
16075 }
16076
16077
16078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16079   void * jresult ;
16080   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16081   Dali::VertexBuffer *arg2 = 0 ;
16082   Dali::VertexBuffer *result = 0 ;
16083
16084   arg1 = (Dali::VertexBuffer *)jarg1;
16085   arg2 = (Dali::VertexBuffer *)jarg2;
16086   if (!arg2) {
16087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16088     return 0;
16089   }
16090   {
16091     try {
16092       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16093     } CALL_CATCH_EXCEPTION(0);
16094   }
16095
16096   jresult = (void *)result;
16097   return jresult;
16098 }
16099
16100
16101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16102   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16103   void *arg2 = (void *) 0 ;
16104   std::size_t arg3 ;
16105
16106   arg1 = (Dali::VertexBuffer *)jarg1;
16107   arg2 = jarg2;
16108   arg3 = (std::size_t)jarg3;
16109   {
16110     try {
16111       (arg1)->SetData((void const *)arg2,arg3);
16112     } CALL_CATCH_EXCEPTION();
16113   }
16114
16115 }
16116
16117
16118 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16119   unsigned long jresult ;
16120   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16121   std::size_t result;
16122
16123   arg1 = (Dali::VertexBuffer *)jarg1;
16124   {
16125     try {
16126       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16127     } CALL_CATCH_EXCEPTION(0);
16128   }
16129
16130   jresult = (unsigned long)result;
16131   return jresult;
16132 }
16133
16134
16135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16136   void * jresult ;
16137   Dali::Geometry result;
16138
16139   {
16140     try {
16141       result = Dali::Geometry::New();
16142     } CALL_CATCH_EXCEPTION(0);
16143   }
16144
16145   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16146   return jresult;
16147 }
16148
16149
16150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16151   void * jresult ;
16152   Dali::Geometry *result = 0 ;
16153
16154   {
16155     try {
16156       result = (Dali::Geometry *)new Dali::Geometry();
16157     } CALL_CATCH_EXCEPTION(0);
16158   }
16159
16160   jresult = (void *)result;
16161   return jresult;
16162 }
16163
16164
16165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16166   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16167
16168   arg1 = (Dali::Geometry *)jarg1;
16169   {
16170     try {
16171       delete arg1;
16172     } CALL_CATCH_EXCEPTION();
16173   }
16174
16175 }
16176
16177
16178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
16179   void * jresult ;
16180   Dali::Geometry *arg1 = 0 ;
16181   Dali::Geometry *result = 0 ;
16182
16183   arg1 = (Dali::Geometry *)jarg1;
16184   if (!arg1) {
16185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16186     return 0;
16187   }
16188   {
16189     try {
16190       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
16191     } CALL_CATCH_EXCEPTION(0);
16192   }
16193
16194   jresult = (void *)result;
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
16200   void * jresult ;
16201   Dali::BaseHandle arg1 ;
16202   Dali::BaseHandle *argp1 ;
16203   Dali::Geometry result;
16204
16205   argp1 = (Dali::BaseHandle *)jarg1;
16206   if (!argp1) {
16207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16208     return 0;
16209   }
16210   arg1 = *argp1;
16211   {
16212     try {
16213       result = Dali::Geometry::DownCast(arg1);
16214     } CALL_CATCH_EXCEPTION(0);
16215   }
16216
16217   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16218   return jresult;
16219 }
16220
16221
16222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
16223   void * jresult ;
16224   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16225   Dali::Geometry *arg2 = 0 ;
16226   Dali::Geometry *result = 0 ;
16227
16228   arg1 = (Dali::Geometry *)jarg1;
16229   arg2 = (Dali::Geometry *)jarg2;
16230   if (!arg2) {
16231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16232     return 0;
16233   }
16234   {
16235     try {
16236       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
16237     } CALL_CATCH_EXCEPTION(0);
16238   }
16239
16240   jresult = (void *)result;
16241   return jresult;
16242 }
16243
16244
16245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
16246   unsigned long jresult ;
16247   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16248   Dali::VertexBuffer *arg2 = 0 ;
16249   std::size_t result;
16250
16251   arg1 = (Dali::Geometry *)jarg1;
16252   arg2 = (Dali::VertexBuffer *)jarg2;
16253   if (!arg2) {
16254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
16255     return 0;
16256   }
16257   {
16258     try {
16259       result = (arg1)->AddVertexBuffer(*arg2);
16260     } CALL_CATCH_EXCEPTION(0);
16261   }
16262
16263   jresult = (unsigned long)result;
16264   return jresult;
16265 }
16266
16267
16268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
16269   unsigned long jresult ;
16270   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16271   std::size_t result;
16272
16273   arg1 = (Dali::Geometry *)jarg1;
16274   {
16275     try {
16276       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
16277     } CALL_CATCH_EXCEPTION(0);
16278   }
16279
16280   jresult = (unsigned long)result;
16281   return jresult;
16282 }
16283
16284
16285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
16286   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16287   std::size_t arg2 ;
16288
16289   arg1 = (Dali::Geometry *)jarg1;
16290   arg2 = (std::size_t)jarg2;
16291   {
16292     try {
16293       (arg1)->RemoveVertexBuffer(arg2);
16294     } CALL_CATCH_EXCEPTION();
16295   }
16296
16297 }
16298
16299
16300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
16301   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16302   unsigned short *arg2 = (unsigned short *) 0 ;
16303   size_t arg3 ;
16304
16305   arg1 = (Dali::Geometry *)jarg1;
16306   arg2 = jarg2;
16307   arg3 = (size_t)jarg3;
16308   {
16309     try {
16310       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
16311     } CALL_CATCH_EXCEPTION();
16312   }
16313
16314
16315
16316 }
16317
16318
16319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
16320   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16321   Dali::Geometry::Type arg2 ;
16322
16323   arg1 = (Dali::Geometry *)jarg1;
16324   arg2 = (Dali::Geometry::Type)jarg2;
16325   {
16326     try {
16327       (arg1)->SetType(arg2);
16328     } CALL_CATCH_EXCEPTION();
16329   }
16330
16331 }
16332
16333
16334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
16335   int jresult ;
16336   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16337   Dali::Geometry::Type result;
16338
16339   arg1 = (Dali::Geometry *)jarg1;
16340   {
16341     try {
16342       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
16343     } CALL_CATCH_EXCEPTION(0);
16344   }
16345
16346   jresult = (int)result;
16347   return jresult;
16348 }
16349
16350
16351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
16352   void * jresult ;
16353   Dali::Shader::Hint *result = 0 ;
16354
16355   {
16356     try {
16357       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
16358     } CALL_CATCH_EXCEPTION(0);
16359   }
16360
16361   jresult = (void *)result;
16362   return jresult;
16363 }
16364
16365
16366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
16367   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
16368
16369   arg1 = (Dali::Shader::Hint *)jarg1;
16370   {
16371     try {
16372       delete arg1;
16373     } CALL_CATCH_EXCEPTION();
16374   }
16375
16376 }
16377
16378
16379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
16380   int jresult ;
16381   int result;
16382
16383   result = (int)Dali::Shader::Property::PROGRAM;
16384   jresult = (int)result;
16385   return jresult;
16386 }
16387
16388
16389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
16390   void * jresult ;
16391   Dali::Shader::Property *result = 0 ;
16392
16393   {
16394     try {
16395       result = (Dali::Shader::Property *)new Dali::Shader::Property();
16396     } CALL_CATCH_EXCEPTION(0);
16397   }
16398
16399   jresult = (void *)result;
16400   return jresult;
16401 }
16402
16403
16404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
16405   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
16406
16407   arg1 = (Dali::Shader::Property *)jarg1;
16408   {
16409     try {
16410       delete arg1;
16411     } CALL_CATCH_EXCEPTION();
16412   }
16413
16414 }
16415
16416
16417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
16418   void * jresult ;
16419   std::string *arg1 = 0 ;
16420   std::string *arg2 = 0 ;
16421   Dali::Shader::Hint::Value arg3 ;
16422   Dali::Shader result;
16423
16424   if (!jarg1) {
16425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16426     return 0;
16427   }
16428   std::string arg1_str(jarg1);
16429   arg1 = &arg1_str;
16430   if (!jarg2) {
16431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16432     return 0;
16433   }
16434   std::string arg2_str(jarg2);
16435   arg2 = &arg2_str;
16436   arg3 = (Dali::Shader::Hint::Value)jarg3;
16437   {
16438     try {
16439       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
16440     } CALL_CATCH_EXCEPTION(0);
16441   }
16442
16443   jresult = new Dali::Shader((const Dali::Shader &)result);
16444
16445   //argout typemap for const std::string&
16446
16447
16448   //argout typemap for const std::string&
16449
16450   return jresult;
16451 }
16452
16453
16454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
16455   void * jresult ;
16456   std::string *arg1 = 0 ;
16457   std::string *arg2 = 0 ;
16458   Dali::Shader result;
16459
16460   if (!jarg1) {
16461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16462     return 0;
16463   }
16464   std::string arg1_str(jarg1);
16465   arg1 = &arg1_str;
16466   if (!jarg2) {
16467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16468     return 0;
16469   }
16470   std::string arg2_str(jarg2);
16471   arg2 = &arg2_str;
16472   {
16473     try {
16474       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
16475     } CALL_CATCH_EXCEPTION(0);
16476   }
16477
16478   jresult = new Dali::Shader((const Dali::Shader &)result);
16479
16480   //argout typemap for const std::string&
16481
16482
16483   //argout typemap for const std::string&
16484
16485   return jresult;
16486 }
16487
16488
16489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
16490   void * jresult ;
16491   Dali::Shader *result = 0 ;
16492
16493   {
16494     try {
16495       result = (Dali::Shader *)new Dali::Shader();
16496     } CALL_CATCH_EXCEPTION(0);
16497   }
16498
16499   jresult = (void *)result;
16500   return jresult;
16501 }
16502
16503
16504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
16505   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16506
16507   arg1 = (Dali::Shader *)jarg1;
16508   {
16509     try {
16510       delete arg1;
16511     } CALL_CATCH_EXCEPTION();
16512   }
16513
16514 }
16515
16516
16517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
16518   void * jresult ;
16519   Dali::Shader *arg1 = 0 ;
16520   Dali::Shader *result = 0 ;
16521
16522   arg1 = (Dali::Shader *)jarg1;
16523   if (!arg1) {
16524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16525     return 0;
16526   }
16527   {
16528     try {
16529       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
16530     } CALL_CATCH_EXCEPTION(0);
16531   }
16532
16533   jresult = (void *)result;
16534   return jresult;
16535 }
16536
16537
16538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
16539   void * jresult ;
16540   Dali::BaseHandle arg1 ;
16541   Dali::BaseHandle *argp1 ;
16542   Dali::Shader result;
16543
16544   argp1 = (Dali::BaseHandle *)jarg1;
16545   if (!argp1) {
16546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16547     return 0;
16548   }
16549   arg1 = *argp1;
16550   {
16551     try {
16552       result = Dali::Shader::DownCast(arg1);
16553     } CALL_CATCH_EXCEPTION(0);
16554   }
16555
16556   jresult = new Dali::Shader((const Dali::Shader &)result);
16557   return jresult;
16558 }
16559
16560
16561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
16562   void * jresult ;
16563   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16564   Dali::Shader *arg2 = 0 ;
16565   Dali::Shader *result = 0 ;
16566
16567   arg1 = (Dali::Shader *)jarg1;
16568   arg2 = (Dali::Shader *)jarg2;
16569   if (!arg2) {
16570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16571     return 0;
16572   }
16573   {
16574     try {
16575       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
16576     } CALL_CATCH_EXCEPTION(0);
16577   }
16578
16579   jresult = (void *)result;
16580   return jresult;
16581 }
16582
16583
16584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
16585   int jresult ;
16586   int result;
16587
16588   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
16589   jresult = (int)result;
16590   return jresult;
16591 }
16592
16593
16594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
16595   int jresult ;
16596   int result;
16597
16598   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
16599   jresult = (int)result;
16600   return jresult;
16601 }
16602
16603
16604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
16605   int jresult ;
16606   int result;
16607
16608   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
16609   jresult = (int)result;
16610   return jresult;
16611 }
16612
16613
16614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
16615   int jresult ;
16616   int result;
16617
16618   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
16619   jresult = (int)result;
16620   return jresult;
16621 }
16622
16623
16624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
16625   int jresult ;
16626   int result;
16627
16628   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
16629   jresult = (int)result;
16630   return jresult;
16631 }
16632
16633
16634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
16635   int jresult ;
16636   int result;
16637
16638   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
16639   jresult = (int)result;
16640   return jresult;
16641 }
16642
16643
16644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
16645   int jresult ;
16646   int result;
16647
16648   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
16649   jresult = (int)result;
16650   return jresult;
16651 }
16652
16653
16654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
16655   int jresult ;
16656   int result;
16657
16658   result = (int)Dali::Renderer::Property::BLEND_MODE;
16659   jresult = (int)result;
16660   return jresult;
16661 }
16662
16663
16664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
16665   int jresult ;
16666   int result;
16667
16668   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
16669   jresult = (int)result;
16670   return jresult;
16671 }
16672
16673
16674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
16675   int jresult ;
16676   int result;
16677
16678   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
16679   jresult = (int)result;
16680   return jresult;
16681 }
16682
16683
16684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
16685   int jresult ;
16686   int result;
16687
16688   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
16689   jresult = (int)result;
16690   return jresult;
16691 }
16692
16693
16694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
16695   int jresult ;
16696   int result;
16697
16698   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
16699   jresult = (int)result;
16700   return jresult;
16701 }
16702
16703
16704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
16705   int jresult ;
16706   int result;
16707
16708   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
16709   jresult = (int)result;
16710   return jresult;
16711 }
16712
16713
16714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
16715   int jresult ;
16716   int result;
16717
16718   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
16719   jresult = (int)result;
16720   return jresult;
16721 }
16722
16723
16724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
16725   int jresult ;
16726   int result;
16727
16728   result = (int)Dali::Renderer::Property::BLEND_COLOR;
16729   jresult = (int)result;
16730   return jresult;
16731 }
16732
16733
16734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
16735   int jresult ;
16736   int result;
16737
16738   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
16739   jresult = (int)result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
16745   int jresult ;
16746   int result;
16747
16748   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
16749   jresult = (int)result;
16750   return jresult;
16751 }
16752
16753
16754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
16755   int jresult ;
16756   int result;
16757
16758   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
16759   jresult = (int)result;
16760   return jresult;
16761 }
16762
16763
16764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
16765   int jresult ;
16766   int result;
16767
16768   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
16769   jresult = (int)result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
16775   int jresult ;
16776   int result;
16777
16778   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
16779   jresult = (int)result;
16780   return jresult;
16781 }
16782
16783
16784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
16785   int jresult ;
16786   int result;
16787
16788   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
16789   jresult = (int)result;
16790   return jresult;
16791 }
16792
16793
16794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
16795   int jresult ;
16796   int result;
16797
16798   result = (int)Dali::Renderer::Property::RENDER_MODE;
16799   jresult = (int)result;
16800   return jresult;
16801 }
16802
16803
16804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
16805   int jresult ;
16806   int result;
16807
16808   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
16809   jresult = (int)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
16815   int jresult ;
16816   int result;
16817
16818   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
16819   jresult = (int)result;
16820   return jresult;
16821 }
16822
16823
16824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
16825   int jresult ;
16826   int result;
16827
16828   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
16829   jresult = (int)result;
16830   return jresult;
16831 }
16832
16833
16834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
16835   int jresult ;
16836   int result;
16837
16838   result = (int)Dali::Renderer::Property::STENCIL_MASK;
16839   jresult = (int)result;
16840   return jresult;
16841 }
16842
16843
16844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
16845   int jresult ;
16846   int result;
16847
16848   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
16849   jresult = (int)result;
16850   return jresult;
16851 }
16852
16853
16854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
16855   int jresult ;
16856   int result;
16857
16858   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
16859   jresult = (int)result;
16860   return jresult;
16861 }
16862
16863
16864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
16865   int jresult ;
16866   int result;
16867
16868   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
16869   jresult = (int)result;
16870   return jresult;
16871 }
16872
16873
16874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
16875   void * jresult ;
16876   Dali::Renderer::Property *result = 0 ;
16877
16878   {
16879     try {
16880       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
16881     } CALL_CATCH_EXCEPTION(0);
16882   }
16883
16884   jresult = (void *)result;
16885   return jresult;
16886 }
16887
16888
16889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
16890   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
16891
16892   arg1 = (Dali::Renderer::Property *)jarg1;
16893   {
16894     try {
16895       delete arg1;
16896     } CALL_CATCH_EXCEPTION();
16897   }
16898
16899 }
16900
16901
16902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
16903   void * jresult ;
16904   Dali::Geometry *arg1 = 0 ;
16905   Dali::Shader *arg2 = 0 ;
16906   Dali::Renderer result;
16907
16908   arg1 = (Dali::Geometry *)jarg1;
16909   if (!arg1) {
16910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
16911     return 0;
16912   }
16913   arg2 = (Dali::Shader *)jarg2;
16914   if (!arg2) {
16915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
16916     return 0;
16917   }
16918   {
16919     try {
16920       result = Dali::Renderer::New(*arg1,*arg2);
16921     } CALL_CATCH_EXCEPTION(0);
16922   }
16923
16924   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16925   return jresult;
16926 }
16927
16928
16929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
16930   void * jresult ;
16931   Dali::Renderer *result = 0 ;
16932
16933   {
16934     try {
16935       result = (Dali::Renderer *)new Dali::Renderer();
16936     } CALL_CATCH_EXCEPTION(0);
16937   }
16938
16939   jresult = (void *)result;
16940   return jresult;
16941 }
16942
16943
16944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
16945   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16946
16947   arg1 = (Dali::Renderer *)jarg1;
16948   {
16949     try {
16950       delete arg1;
16951     } CALL_CATCH_EXCEPTION();
16952   }
16953
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
16958   void * jresult ;
16959   Dali::Renderer *arg1 = 0 ;
16960   Dali::Renderer *result = 0 ;
16961
16962   arg1 = (Dali::Renderer *)jarg1;
16963   if (!arg1) {
16964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
16965     return 0;
16966   }
16967   {
16968     try {
16969       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
16970     } CALL_CATCH_EXCEPTION(0);
16971   }
16972
16973   jresult = (void *)result;
16974   return jresult;
16975 }
16976
16977
16978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
16979   void * jresult ;
16980   Dali::BaseHandle arg1 ;
16981   Dali::BaseHandle *argp1 ;
16982   Dali::Renderer result;
16983
16984   argp1 = (Dali::BaseHandle *)jarg1;
16985   if (!argp1) {
16986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16987     return 0;
16988   }
16989   arg1 = *argp1;
16990   {
16991     try {
16992       result = Dali::Renderer::DownCast(arg1);
16993     } CALL_CATCH_EXCEPTION(0);
16994   }
16995
16996   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16997   return jresult;
16998 }
16999
17000
17001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17002   void * jresult ;
17003   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17004   Dali::Renderer *arg2 = 0 ;
17005   Dali::Renderer *result = 0 ;
17006
17007   arg1 = (Dali::Renderer *)jarg1;
17008   arg2 = (Dali::Renderer *)jarg2;
17009   if (!arg2) {
17010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17011     return 0;
17012   }
17013   {
17014     try {
17015       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17016     } CALL_CATCH_EXCEPTION(0);
17017   }
17018
17019   jresult = (void *)result;
17020   return jresult;
17021 }
17022
17023
17024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17025   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17026   Dali::Geometry *arg2 = 0 ;
17027
17028   arg1 = (Dali::Renderer *)jarg1;
17029   arg2 = (Dali::Geometry *)jarg2;
17030   if (!arg2) {
17031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17032     return ;
17033   }
17034   {
17035     try {
17036       (arg1)->SetGeometry(*arg2);
17037     } CALL_CATCH_EXCEPTION();
17038   }
17039
17040 }
17041
17042
17043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17044   void * jresult ;
17045   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17046   Dali::Geometry result;
17047
17048   arg1 = (Dali::Renderer *)jarg1;
17049   {
17050     try {
17051       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17052     } CALL_CATCH_EXCEPTION(0);
17053   }
17054
17055   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17056   return jresult;
17057 }
17058
17059
17060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17061   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17062   int arg2 ;
17063   int arg3 ;
17064
17065   arg1 = (Dali::Renderer *)jarg1;
17066   arg2 = (int)jarg2;
17067   arg3 = (int)jarg3;
17068   {
17069     try {
17070       (arg1)->SetIndexRange(arg2,arg3);
17071     } CALL_CATCH_EXCEPTION();
17072   }
17073
17074 }
17075
17076
17077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17078   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17079   Dali::TextureSet *arg2 = 0 ;
17080
17081   arg1 = (Dali::Renderer *)jarg1;
17082   arg2 = (Dali::TextureSet *)jarg2;
17083   if (!arg2) {
17084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17085     return ;
17086   }
17087   {
17088     try {
17089       (arg1)->SetTextures(*arg2);
17090     } CALL_CATCH_EXCEPTION();
17091   }
17092
17093 }
17094
17095
17096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17097   void * jresult ;
17098   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17099   Dali::TextureSet result;
17100
17101   arg1 = (Dali::Renderer *)jarg1;
17102   {
17103     try {
17104       result = ((Dali::Renderer const *)arg1)->GetTextures();
17105     } CALL_CATCH_EXCEPTION(0);
17106   }
17107
17108   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17109   return jresult;
17110 }
17111
17112
17113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17114   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17115   Dali::Shader *arg2 = 0 ;
17116
17117   arg1 = (Dali::Renderer *)jarg1;
17118   arg2 = (Dali::Shader *)jarg2;
17119   if (!arg2) {
17120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17121     return ;
17122   }
17123   {
17124     try {
17125       (arg1)->SetShader(*arg2);
17126     } CALL_CATCH_EXCEPTION();
17127   }
17128
17129 }
17130
17131
17132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17133   void * jresult ;
17134   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17135   Dali::Shader result;
17136
17137   arg1 = (Dali::Renderer *)jarg1;
17138   {
17139     try {
17140       result = ((Dali::Renderer const *)arg1)->GetShader();
17141     } CALL_CATCH_EXCEPTION(0);
17142   }
17143
17144   jresult = new Dali::Shader((const Dali::Shader &)result);
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17150   void * jresult ;
17151   Dali::FrameBuffer::Attachment *result = 0 ;
17152
17153   {
17154     try {
17155       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17156     } CALL_CATCH_EXCEPTION(0);
17157   }
17158
17159   jresult = (void *)result;
17160   return jresult;
17161 }
17162
17163
17164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17165   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17166
17167   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17168   {
17169     try {
17170       delete arg1;
17171     } CALL_CATCH_EXCEPTION();
17172   }
17173
17174 }
17175
17176
17177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
17178   void * jresult ;
17179   unsigned int arg1 ;
17180   unsigned int arg2 ;
17181   unsigned int arg3 ;
17182   Dali::FrameBuffer result;
17183
17184   arg1 = (unsigned int)jarg1;
17185   arg2 = (unsigned int)jarg2;
17186   arg3 = (unsigned int)jarg3;
17187   {
17188     try {
17189       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
17190     } CALL_CATCH_EXCEPTION(0);
17191   }
17192
17193   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17194   return jresult;
17195 }
17196
17197
17198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
17199   void * jresult ;
17200   Dali::FrameBuffer *result = 0 ;
17201
17202   {
17203     try {
17204       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
17205     } CALL_CATCH_EXCEPTION(0);
17206   }
17207
17208   jresult = (void *)result;
17209   return jresult;
17210 }
17211
17212
17213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
17214   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17215
17216   arg1 = (Dali::FrameBuffer *)jarg1;
17217   {
17218     try {
17219       delete arg1;
17220     } CALL_CATCH_EXCEPTION();
17221   }
17222
17223 }
17224
17225
17226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
17227   void * jresult ;
17228   Dali::FrameBuffer *arg1 = 0 ;
17229   Dali::FrameBuffer *result = 0 ;
17230
17231   arg1 = (Dali::FrameBuffer *)jarg1;
17232   if (!arg1) {
17233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17234     return 0;
17235   }
17236   {
17237     try {
17238       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
17239     } CALL_CATCH_EXCEPTION(0);
17240   }
17241
17242   jresult = (void *)result;
17243   return jresult;
17244 }
17245
17246
17247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
17248   void * jresult ;
17249   Dali::BaseHandle arg1 ;
17250   Dali::BaseHandle *argp1 ;
17251   Dali::FrameBuffer result;
17252
17253   argp1 = (Dali::BaseHandle *)jarg1;
17254   if (!argp1) {
17255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17256     return 0;
17257   }
17258   arg1 = *argp1;
17259   {
17260     try {
17261       result = Dali::FrameBuffer::DownCast(arg1);
17262     } CALL_CATCH_EXCEPTION(0);
17263   }
17264
17265   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17266   return jresult;
17267 }
17268
17269
17270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
17271   void * jresult ;
17272   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17273   Dali::FrameBuffer *arg2 = 0 ;
17274   Dali::FrameBuffer *result = 0 ;
17275
17276   arg1 = (Dali::FrameBuffer *)jarg1;
17277   arg2 = (Dali::FrameBuffer *)jarg2;
17278   if (!arg2) {
17279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17280     return 0;
17281   }
17282   {
17283     try {
17284       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
17285     } CALL_CATCH_EXCEPTION(0);
17286   }
17287
17288   jresult = (void *)result;
17289   return jresult;
17290 }
17291
17292
17293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
17294   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17295   Dali::Texture *arg2 = 0 ;
17296
17297   arg1 = (Dali::FrameBuffer *)jarg1;
17298   arg2 = (Dali::Texture *)jarg2;
17299   if (!arg2) {
17300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17301     return ;
17302   }
17303   {
17304     try {
17305       (arg1)->AttachColorTexture(*arg2);
17306     } CALL_CATCH_EXCEPTION();
17307   }
17308
17309 }
17310
17311
17312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
17313   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17314   Dali::Texture *arg2 = 0 ;
17315   unsigned int arg3 ;
17316   unsigned int arg4 ;
17317
17318   arg1 = (Dali::FrameBuffer *)jarg1;
17319   arg2 = (Dali::Texture *)jarg2;
17320   if (!arg2) {
17321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17322     return ;
17323   }
17324   arg3 = (unsigned int)jarg3;
17325   arg4 = (unsigned int)jarg4;
17326   {
17327     try {
17328       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
17329     } CALL_CATCH_EXCEPTION();
17330   }
17331
17332 }
17333
17334
17335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
17336   void * jresult ;
17337   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17338   Dali::Texture result;
17339
17340   arg1 = (Dali::FrameBuffer *)jarg1;
17341   {
17342     try {
17343       result = (arg1)->GetColorTexture();
17344     } CALL_CATCH_EXCEPTION(0);
17345   }
17346
17347   jresult = new Dali::Texture((const Dali::Texture &)result);
17348   return jresult;
17349 }
17350
17351
17352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
17353   void * jresult ;
17354   Dali::RenderTaskList *result = 0 ;
17355
17356   {
17357     try {
17358       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
17359     } CALL_CATCH_EXCEPTION(0);
17360   }
17361
17362   jresult = (void *)result;
17363   return jresult;
17364 }
17365
17366
17367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
17368   void * jresult ;
17369   Dali::BaseHandle arg1 ;
17370   Dali::BaseHandle *argp1 ;
17371   Dali::RenderTaskList result;
17372
17373   argp1 = (Dali::BaseHandle *)jarg1;
17374   if (!argp1) {
17375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17376     return 0;
17377   }
17378   arg1 = *argp1;
17379   {
17380     try {
17381       result = Dali::RenderTaskList::DownCast(arg1);
17382     } CALL_CATCH_EXCEPTION(0);
17383   }
17384
17385   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
17386   return jresult;
17387 }
17388
17389
17390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
17391   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17392
17393   arg1 = (Dali::RenderTaskList *)jarg1;
17394   {
17395     try {
17396       delete arg1;
17397     } CALL_CATCH_EXCEPTION();
17398   }
17399
17400 }
17401
17402
17403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
17404   void * jresult ;
17405   Dali::RenderTaskList *arg1 = 0 ;
17406   Dali::RenderTaskList *result = 0 ;
17407
17408   arg1 = (Dali::RenderTaskList *)jarg1;
17409   if (!arg1) {
17410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17411     return 0;
17412   }
17413   {
17414     try {
17415       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
17416     } CALL_CATCH_EXCEPTION(0);
17417   }
17418
17419   jresult = (void *)result;
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
17425   void * jresult ;
17426   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17427   Dali::RenderTaskList *arg2 = 0 ;
17428   Dali::RenderTaskList *result = 0 ;
17429
17430   arg1 = (Dali::RenderTaskList *)jarg1;
17431   arg2 = (Dali::RenderTaskList *)jarg2;
17432   if (!arg2) {
17433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17434     return 0;
17435   }
17436   {
17437     try {
17438       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
17439     } CALL_CATCH_EXCEPTION(0);
17440   }
17441
17442   jresult = (void *)result;
17443   return jresult;
17444 }
17445
17446
17447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
17448   void * jresult ;
17449   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17450   Dali::RenderTask result;
17451
17452   arg1 = (Dali::RenderTaskList *)jarg1;
17453   {
17454     try {
17455       result = (arg1)->CreateTask();
17456     } CALL_CATCH_EXCEPTION(0);
17457   }
17458
17459   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17460   return jresult;
17461 }
17462
17463
17464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
17465   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17466   Dali::RenderTask arg2 ;
17467   Dali::RenderTask *argp2 ;
17468
17469   arg1 = (Dali::RenderTaskList *)jarg1;
17470   argp2 = (Dali::RenderTask *)jarg2;
17471   if (!argp2) {
17472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
17473     return ;
17474   }
17475   arg2 = *argp2;
17476   {
17477     try {
17478       (arg1)->RemoveTask(arg2);
17479     } CALL_CATCH_EXCEPTION();
17480   }
17481
17482 }
17483
17484
17485 //// ===============================================end part 1 =================
17486
17487 //// ========================= part 2 ===============================
17488
17489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
17490   unsigned int jresult ;
17491   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17492   unsigned int result;
17493
17494   arg1 = (Dali::RenderTaskList *)jarg1;
17495   {
17496     try {
17497       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
17498     } CALL_CATCH_EXCEPTION(0);
17499   }
17500
17501   jresult = result;
17502   return jresult;
17503 }
17504
17505
17506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
17507   void * jresult ;
17508   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17509   unsigned int arg2 ;
17510   Dali::RenderTask result;
17511
17512   arg1 = (Dali::RenderTaskList *)jarg1;
17513   arg2 = (unsigned int)jarg2;
17514   {
17515     try {
17516       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
17517     } CALL_CATCH_EXCEPTION(0);
17518   }
17519
17520   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17521   return jresult;
17522 }
17523
17524
17525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
17526   int jresult ;
17527   int result;
17528
17529   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
17530   jresult = (int)result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
17536   int jresult ;
17537   int result;
17538
17539   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
17540   jresult = (int)result;
17541   return jresult;
17542 }
17543
17544
17545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
17546   int jresult ;
17547   int result;
17548
17549   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
17550   jresult = (int)result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
17556   int jresult ;
17557   int result;
17558
17559   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
17560   jresult = (int)result;
17561   return jresult;
17562 }
17563
17564
17565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
17566   void * jresult ;
17567   Dali::RenderTask::Property *result = 0 ;
17568
17569   {
17570     try {
17571       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
17572     } CALL_CATCH_EXCEPTION(0);
17573   }
17574
17575   jresult = (void *)result;
17576   return jresult;
17577 }
17578
17579
17580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
17581   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
17582
17583   arg1 = (Dali::RenderTask::Property *)jarg1;
17584   {
17585     try {
17586       delete arg1;
17587     } CALL_CATCH_EXCEPTION();
17588   }
17589
17590 }
17591
17592
17593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
17594   void * jresult ;
17595   bool (*result)(Dali::Vector2 &) = 0 ;
17596
17597   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
17598   jresult = (void *)result;
17599   return jresult;
17600 }
17601
17602
17603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
17604   void * jresult ;
17605   bool (*result)(Dali::Vector2 &) = 0 ;
17606
17607   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
17608   jresult = (void *)result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
17614   unsigned int jresult ;
17615   bool result;
17616
17617   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
17618   jresult = result;
17619   return jresult;
17620 }
17621
17622
17623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
17624   unsigned int jresult ;
17625   bool result;
17626
17627   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
17628   jresult = result;
17629   return jresult;
17630 }
17631
17632
17633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
17634   void * jresult ;
17635   Dali::Vector4 *result = 0 ;
17636
17637   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
17638   jresult = (void *)result;
17639   return jresult;
17640 }
17641
17642
17643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
17644   unsigned int jresult ;
17645   bool result;
17646
17647   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
17648   jresult = result;
17649   return jresult;
17650 }
17651
17652
17653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
17654   unsigned int jresult ;
17655   bool result;
17656
17657   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
17658   jresult = result;
17659   return jresult;
17660 }
17661
17662
17663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
17664   unsigned int jresult ;
17665   unsigned int result;
17666
17667   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
17668   jresult = result;
17669   return jresult;
17670 }
17671
17672
17673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
17674   void * jresult ;
17675   Dali::RenderTask *result = 0 ;
17676
17677   {
17678     try {
17679       result = (Dali::RenderTask *)new Dali::RenderTask();
17680     } CALL_CATCH_EXCEPTION(0);
17681   }
17682
17683   jresult = (void *)result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
17689   void * jresult ;
17690   Dali::BaseHandle arg1 ;
17691   Dali::BaseHandle *argp1 ;
17692   Dali::RenderTask result;
17693
17694   argp1 = (Dali::BaseHandle *)jarg1;
17695   if (!argp1) {
17696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17697     return 0;
17698   }
17699   arg1 = *argp1;
17700   {
17701     try {
17702       result = Dali::RenderTask::DownCast(arg1);
17703     } CALL_CATCH_EXCEPTION(0);
17704   }
17705
17706   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17707   return jresult;
17708 }
17709
17710
17711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
17712   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17713
17714   arg1 = (Dali::RenderTask *)jarg1;
17715   {
17716     try {
17717       delete arg1;
17718     } CALL_CATCH_EXCEPTION();
17719   }
17720
17721 }
17722
17723
17724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
17725   void * jresult ;
17726   Dali::RenderTask *arg1 = 0 ;
17727   Dali::RenderTask *result = 0 ;
17728
17729   arg1 = (Dali::RenderTask *)jarg1;
17730   if (!arg1) {
17731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17732     return 0;
17733   }
17734   {
17735     try {
17736       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
17737     } CALL_CATCH_EXCEPTION(0);
17738   }
17739
17740   jresult = (void *)result;
17741   return jresult;
17742 }
17743
17744
17745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
17746   void * jresult ;
17747   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17748   Dali::RenderTask *arg2 = 0 ;
17749   Dali::RenderTask *result = 0 ;
17750
17751   arg1 = (Dali::RenderTask *)jarg1;
17752   arg2 = (Dali::RenderTask *)jarg2;
17753   if (!arg2) {
17754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17755     return 0;
17756   }
17757   {
17758     try {
17759       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
17760     } CALL_CATCH_EXCEPTION(0);
17761   }
17762
17763   jresult = (void *)result;
17764   return jresult;
17765 }
17766
17767
17768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
17769   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17770   Dali::Actor arg2 ;
17771   Dali::Actor *argp2 ;
17772
17773   arg1 = (Dali::RenderTask *)jarg1;
17774   argp2 = (Dali::Actor *)jarg2;
17775   if (!argp2) {
17776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17777     return ;
17778   }
17779   arg2 = *argp2;
17780   {
17781     try {
17782       (arg1)->SetSourceActor(arg2);
17783     } CALL_CATCH_EXCEPTION();
17784   }
17785
17786 }
17787
17788
17789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
17790   void * jresult ;
17791   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17792   Dali::Actor result;
17793
17794   arg1 = (Dali::RenderTask *)jarg1;
17795   {
17796     try {
17797       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
17798     } CALL_CATCH_EXCEPTION(0);
17799   }
17800
17801   jresult = new Dali::Actor((const Dali::Actor &)result);
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
17807   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17808   bool arg2 ;
17809
17810   arg1 = (Dali::RenderTask *)jarg1;
17811   arg2 = jarg2 ? true : false;
17812   {
17813     try {
17814       (arg1)->SetExclusive(arg2);
17815     } CALL_CATCH_EXCEPTION();
17816   }
17817
17818 }
17819
17820
17821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
17822   unsigned int jresult ;
17823   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17824   bool result;
17825
17826   arg1 = (Dali::RenderTask *)jarg1;
17827   {
17828     try {
17829       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
17830     } CALL_CATCH_EXCEPTION(0);
17831   }
17832
17833   jresult = result;
17834   return jresult;
17835 }
17836
17837
17838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
17839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17840   bool arg2 ;
17841
17842   arg1 = (Dali::RenderTask *)jarg1;
17843   arg2 = jarg2 ? true : false;
17844   {
17845     try {
17846       (arg1)->SetInputEnabled(arg2);
17847     } CALL_CATCH_EXCEPTION();
17848   }
17849
17850 }
17851
17852
17853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
17854   unsigned int jresult ;
17855   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17856   bool result;
17857
17858   arg1 = (Dali::RenderTask *)jarg1;
17859   {
17860     try {
17861       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
17862     } CALL_CATCH_EXCEPTION(0);
17863   }
17864
17865   jresult = result;
17866   return jresult;
17867 }
17868
17869
17870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
17871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17872   Dali::CameraActor arg2 ;
17873   Dali::CameraActor *argp2 ;
17874
17875   arg1 = (Dali::RenderTask *)jarg1;
17876   argp2 = (Dali::CameraActor *)jarg2;
17877   if (!argp2) {
17878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
17879     return ;
17880   }
17881   arg2 = *argp2;
17882   {
17883     try {
17884       (arg1)->SetCameraActor(arg2);
17885     } CALL_CATCH_EXCEPTION();
17886   }
17887
17888 }
17889
17890
17891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
17892   void * jresult ;
17893   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17894   Dali::CameraActor result;
17895
17896   arg1 = (Dali::RenderTask *)jarg1;
17897   {
17898     try {
17899       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
17900     } CALL_CATCH_EXCEPTION(0);
17901   }
17902
17903   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
17904   return jresult;
17905 }
17906
17907
17908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
17909   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17910   Dali::FrameBuffer arg2 ;
17911   Dali::FrameBuffer *argp2 ;
17912
17913   arg1 = (Dali::RenderTask *)jarg1;
17914   argp2 = (Dali::FrameBuffer *)jarg2;
17915   if (!argp2) {
17916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
17917     return ;
17918   }
17919   arg2 = *argp2;
17920   {
17921     try {
17922       (arg1)->SetFrameBuffer(arg2);
17923     } CALL_CATCH_EXCEPTION();
17924   }
17925
17926 }
17927
17928
17929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
17930   void * jresult ;
17931   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17932   Dali::FrameBuffer result;
17933
17934   arg1 = (Dali::RenderTask *)jarg1;
17935   {
17936     try {
17937       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
17938     } CALL_CATCH_EXCEPTION(0);
17939   }
17940
17941   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17942   return jresult;
17943 }
17944
17945
17946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
17947   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17948   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
17949
17950   arg1 = (Dali::RenderTask *)jarg1;
17951   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
17952   {
17953     try {
17954       (arg1)->SetScreenToFrameBufferFunction(arg2);
17955     } CALL_CATCH_EXCEPTION();
17956   }
17957
17958 }
17959
17960
17961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
17962   void * jresult ;
17963   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17964   Dali::RenderTask::ScreenToFrameBufferFunction result;
17965
17966   arg1 = (Dali::RenderTask *)jarg1;
17967   {
17968     try {
17969       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
17970     } CALL_CATCH_EXCEPTION(0);
17971   }
17972
17973   jresult = (void *)result;
17974   return jresult;
17975 }
17976
17977
17978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
17979   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17980   Dali::Actor arg2 ;
17981   Dali::Actor *argp2 ;
17982
17983   arg1 = (Dali::RenderTask *)jarg1;
17984   argp2 = (Dali::Actor *)jarg2;
17985   if (!argp2) {
17986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17987     return ;
17988   }
17989   arg2 = *argp2;
17990   {
17991     try {
17992       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
17993     } CALL_CATCH_EXCEPTION();
17994   }
17995
17996 }
17997
17998
17999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18000   void * jresult ;
18001   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18002   Dali::Actor result;
18003
18004   arg1 = (Dali::RenderTask *)jarg1;
18005   {
18006     try {
18007       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18008     } CALL_CATCH_EXCEPTION(0);
18009   }
18010
18011   jresult = new Dali::Actor((const Dali::Actor &)result);
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18017   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18018   Dali::Vector2 arg2 ;
18019   Dali::Vector2 *argp2 ;
18020
18021   arg1 = (Dali::RenderTask *)jarg1;
18022   argp2 = (Dali::Vector2 *)jarg2;
18023   if (!argp2) {
18024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18025     return ;
18026   }
18027   arg2 = *argp2;
18028   {
18029     try {
18030       (arg1)->SetViewportPosition(arg2);
18031     } CALL_CATCH_EXCEPTION();
18032   }
18033
18034 }
18035
18036
18037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18038   void * jresult ;
18039   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18040   Dali::Vector2 result;
18041
18042   arg1 = (Dali::RenderTask *)jarg1;
18043   {
18044     try {
18045       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18046     } CALL_CATCH_EXCEPTION(0);
18047   }
18048
18049   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18050   return jresult;
18051 }
18052
18053
18054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18055   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18056   Dali::Vector2 arg2 ;
18057   Dali::Vector2 *argp2 ;
18058
18059   arg1 = (Dali::RenderTask *)jarg1;
18060   argp2 = (Dali::Vector2 *)jarg2;
18061   if (!argp2) {
18062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18063     return ;
18064   }
18065   arg2 = *argp2;
18066   {
18067     try {
18068       (arg1)->SetViewportSize(arg2);
18069     } CALL_CATCH_EXCEPTION();
18070   }
18071
18072 }
18073
18074
18075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18076   void * jresult ;
18077   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18078   Dali::Vector2 result;
18079
18080   arg1 = (Dali::RenderTask *)jarg1;
18081   {
18082     try {
18083       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18084     } CALL_CATCH_EXCEPTION(0);
18085   }
18086
18087   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18088   return jresult;
18089 }
18090
18091
18092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18093   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18094   Dali::Viewport arg2 ;
18095   Dali::Viewport *argp2 ;
18096
18097   arg1 = (Dali::RenderTask *)jarg1;
18098   argp2 = (Dali::Viewport *)jarg2;
18099   if (!argp2) {
18100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18101     return ;
18102   }
18103   arg2 = *argp2;
18104   {
18105     try {
18106       (arg1)->SetViewport(arg2);
18107     } CALL_CATCH_EXCEPTION();
18108   }
18109
18110 }
18111
18112
18113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18114   void * jresult ;
18115   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18116   Dali::Viewport result;
18117
18118   arg1 = (Dali::RenderTask *)jarg1;
18119   {
18120     try {
18121       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18122     } CALL_CATCH_EXCEPTION(0);
18123   }
18124
18125   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18126   return jresult;
18127 }
18128
18129
18130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18131   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18132   Dali::Vector4 *arg2 = 0 ;
18133
18134   arg1 = (Dali::RenderTask *)jarg1;
18135   arg2 = (Dali::Vector4 *)jarg2;
18136   if (!arg2) {
18137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18138     return ;
18139   }
18140   {
18141     try {
18142       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18143     } CALL_CATCH_EXCEPTION();
18144   }
18145
18146 }
18147
18148
18149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
18150   void * jresult ;
18151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18152   Dali::Vector4 result;
18153
18154   arg1 = (Dali::RenderTask *)jarg1;
18155   {
18156     try {
18157       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
18158     } CALL_CATCH_EXCEPTION(0);
18159   }
18160
18161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18162   return jresult;
18163 }
18164
18165
18166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
18167   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18168   bool arg2 ;
18169
18170   arg1 = (Dali::RenderTask *)jarg1;
18171   arg2 = jarg2 ? true : false;
18172   {
18173     try {
18174       (arg1)->SetClearEnabled(arg2);
18175     } CALL_CATCH_EXCEPTION();
18176   }
18177
18178 }
18179
18180
18181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
18182   unsigned int jresult ;
18183   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18184   bool result;
18185
18186   arg1 = (Dali::RenderTask *)jarg1;
18187   {
18188     try {
18189       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
18190     } CALL_CATCH_EXCEPTION(0);
18191   }
18192
18193   jresult = result;
18194   return jresult;
18195 }
18196
18197
18198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
18199   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18200   bool arg2 ;
18201
18202   arg1 = (Dali::RenderTask *)jarg1;
18203   arg2 = jarg2 ? true : false;
18204   {
18205     try {
18206       (arg1)->SetCullMode(arg2);
18207     } CALL_CATCH_EXCEPTION();
18208   }
18209
18210 }
18211
18212
18213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
18214   unsigned int jresult ;
18215   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18216   bool result;
18217
18218   arg1 = (Dali::RenderTask *)jarg1;
18219   {
18220     try {
18221       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
18222     } CALL_CATCH_EXCEPTION(0);
18223   }
18224
18225   jresult = result;
18226   return jresult;
18227 }
18228
18229
18230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
18231   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18232   unsigned int arg2 ;
18233
18234   arg1 = (Dali::RenderTask *)jarg1;
18235   arg2 = (unsigned int)jarg2;
18236   {
18237     try {
18238       (arg1)->SetRefreshRate(arg2);
18239     } CALL_CATCH_EXCEPTION();
18240   }
18241
18242 }
18243
18244
18245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
18246   unsigned int jresult ;
18247   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18248   unsigned int result;
18249
18250   arg1 = (Dali::RenderTask *)jarg1;
18251   {
18252     try {
18253       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
18254     } CALL_CATCH_EXCEPTION(0);
18255   }
18256
18257   jresult = result;
18258   return jresult;
18259 }
18260
18261
18262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
18263   unsigned int jresult ;
18264   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18265   Dali::Vector3 *arg2 = 0 ;
18266   float *arg3 = 0 ;
18267   float *arg4 = 0 ;
18268   bool result;
18269
18270   arg1 = (Dali::RenderTask *)jarg1;
18271   arg2 = (Dali::Vector3 *)jarg2;
18272   if (!arg2) {
18273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
18274     return 0;
18275   }
18276   arg3 = (float *)jarg3;
18277   arg4 = (float *)jarg4;
18278   {
18279     try {
18280       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
18281     } CALL_CATCH_EXCEPTION(0);
18282   }
18283
18284   jresult = result;
18285   return jresult;
18286 }
18287
18288
18289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
18290   unsigned int jresult ;
18291   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18292   Dali::Actor arg2 ;
18293   float arg3 ;
18294   float arg4 ;
18295   float *arg5 = 0 ;
18296   float *arg6 = 0 ;
18297   Dali::Actor *argp2 ;
18298   bool result;
18299
18300   arg1 = (Dali::RenderTask *)jarg1;
18301   argp2 = (Dali::Actor *)jarg2;
18302   if (!argp2) {
18303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18304     return 0;
18305   }
18306   arg2 = *argp2;
18307   arg3 = (float)jarg3;
18308   arg4 = (float)jarg4;
18309   arg5 = (float *)jarg5;
18310   arg6 = (float *)jarg6;
18311   {
18312     try {
18313       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
18314     } CALL_CATCH_EXCEPTION(0);
18315   }
18316
18317   jresult = result;
18318   return jresult;
18319 }
18320
18321
18322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
18323   void * jresult ;
18324   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18325   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
18326
18327   arg1 = (Dali::RenderTask *)jarg1;
18328   {
18329     try {
18330       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
18331     } CALL_CATCH_EXCEPTION(0);
18332   }
18333
18334   jresult = (void *)result;
18335   return jresult;
18336 }
18337
18338
18339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
18340   void * jresult ;
18341   int arg1 ;
18342   Dali::TouchPoint::State arg2 ;
18343   float arg3 ;
18344   float arg4 ;
18345   Dali::TouchPoint *result = 0 ;
18346
18347   arg1 = (int)jarg1;
18348   arg2 = (Dali::TouchPoint::State)jarg2;
18349   arg3 = (float)jarg3;
18350   arg4 = (float)jarg4;
18351   {
18352     try {
18353       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
18354     } CALL_CATCH_EXCEPTION(0);
18355   }
18356
18357   jresult = (void *)result;
18358   return jresult;
18359 }
18360
18361
18362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
18363   void * jresult ;
18364   int arg1 ;
18365   Dali::TouchPoint::State arg2 ;
18366   float arg3 ;
18367   float arg4 ;
18368   float arg5 ;
18369   float arg6 ;
18370   Dali::TouchPoint *result = 0 ;
18371
18372   arg1 = (int)jarg1;
18373   arg2 = (Dali::TouchPoint::State)jarg2;
18374   arg3 = (float)jarg3;
18375   arg4 = (float)jarg4;
18376   arg5 = (float)jarg5;
18377   arg6 = (float)jarg6;
18378   {
18379     try {
18380       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
18381     } CALL_CATCH_EXCEPTION(0);
18382   }
18383
18384   jresult = (void *)result;
18385   return jresult;
18386 }
18387
18388
18389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
18390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18391
18392   arg1 = (Dali::TouchPoint *)jarg1;
18393   {
18394     try {
18395       delete arg1;
18396     } CALL_CATCH_EXCEPTION();
18397   }
18398
18399 }
18400
18401
18402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
18403   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18404   int arg2 ;
18405
18406   arg1 = (Dali::TouchPoint *)jarg1;
18407   arg2 = (int)jarg2;
18408   if (arg1) (arg1)->deviceId = arg2;
18409 }
18410
18411
18412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
18413   int jresult ;
18414   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18415   int result;
18416
18417   arg1 = (Dali::TouchPoint *)jarg1;
18418   result = (int) ((arg1)->deviceId);
18419   jresult = result;
18420   return jresult;
18421 }
18422
18423
18424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
18425   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18426   Dali::TouchPoint::State arg2 ;
18427
18428   arg1 = (Dali::TouchPoint *)jarg1;
18429   arg2 = (Dali::TouchPoint::State)jarg2;
18430   if (arg1) (arg1)->state = arg2;
18431 }
18432
18433
18434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
18435   int jresult ;
18436   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18437   Dali::TouchPoint::State result;
18438
18439   arg1 = (Dali::TouchPoint *)jarg1;
18440   result = (Dali::TouchPoint::State) ((arg1)->state);
18441   jresult = (int)result;
18442   return jresult;
18443 }
18444
18445
18446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
18447   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18448   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
18449
18450   arg1 = (Dali::TouchPoint *)jarg1;
18451   arg2 = (Dali::Actor *)jarg2;
18452   if (arg1) (arg1)->hitActor = *arg2;
18453 }
18454
18455
18456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
18457   void * jresult ;
18458   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18459   Dali::Actor *result = 0 ;
18460
18461   arg1 = (Dali::TouchPoint *)jarg1;
18462   result = (Dali::Actor *)& ((arg1)->hitActor);
18463   jresult = (void *)result;
18464   return jresult;
18465 }
18466
18467
18468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
18469   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18470   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18471
18472   arg1 = (Dali::TouchPoint *)jarg1;
18473   arg2 = (Dali::Vector2 *)jarg2;
18474   if (arg1) (arg1)->local = *arg2;
18475 }
18476
18477
18478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
18479   void * jresult ;
18480   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18481   Dali::Vector2 *result = 0 ;
18482
18483   arg1 = (Dali::TouchPoint *)jarg1;
18484   result = (Dali::Vector2 *)& ((arg1)->local);
18485   jresult = (void *)result;
18486   return jresult;
18487 }
18488
18489
18490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
18491   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18492   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18493
18494   arg1 = (Dali::TouchPoint *)jarg1;
18495   arg2 = (Dali::Vector2 *)jarg2;
18496   if (arg1) (arg1)->screen = *arg2;
18497 }
18498
18499
18500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
18501   void * jresult ;
18502   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18503   Dali::Vector2 *result = 0 ;
18504
18505   arg1 = (Dali::TouchPoint *)jarg1;
18506   result = (Dali::Vector2 *)& ((arg1)->screen);
18507   jresult = (void *)result;
18508   return jresult;
18509 }
18510
18511
18512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
18513   void * jresult ;
18514   Dali::TouchEvent *result = 0 ;
18515
18516   {
18517     try {
18518       result = (Dali::TouchEvent *)new Dali::TouchEvent();
18519     } CALL_CATCH_EXCEPTION(0);
18520   }
18521
18522   jresult = (void *)result;
18523   return jresult;
18524 }
18525
18526
18527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
18528   void * jresult ;
18529   Dali::TouchEvent *arg1 = 0 ;
18530   Dali::TouchEvent *result = 0 ;
18531
18532   arg1 = (Dali::TouchEvent *)jarg1;
18533   if (!arg1) {
18534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18535     return 0;
18536   }
18537   {
18538     try {
18539       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
18540     } CALL_CATCH_EXCEPTION(0);
18541   }
18542
18543   jresult = (void *)result;
18544   return jresult;
18545 }
18546
18547
18548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
18549   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18550
18551   arg1 = (Dali::TouchEvent *)jarg1;
18552   {
18553     try {
18554       delete arg1;
18555     } CALL_CATCH_EXCEPTION();
18556   }
18557
18558 }
18559
18560
18561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
18562   void * jresult ;
18563   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18564   Dali::TouchEvent *arg2 = 0 ;
18565   Dali::TouchEvent *result = 0 ;
18566
18567   arg1 = (Dali::TouchEvent *)jarg1;
18568   arg2 = (Dali::TouchEvent *)jarg2;
18569   if (!arg2) {
18570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18571     return 0;
18572   }
18573   {
18574     try {
18575       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
18576     } CALL_CATCH_EXCEPTION(0);
18577   }
18578
18579   jresult = (void *)result;
18580   return jresult;
18581 }
18582
18583
18584 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
18585   unsigned long jresult ;
18586   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18587   unsigned long result;
18588
18589   arg1 = (Dali::TouchEvent *)jarg1;
18590   {
18591     try {
18592       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
18593     } CALL_CATCH_EXCEPTION(0);
18594   }
18595
18596   jresult = (unsigned long)result;
18597   return jresult;
18598 }
18599
18600
18601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
18602   unsigned long jresult ;
18603   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18604   std::size_t result;
18605
18606   arg1 = (Dali::TouchEvent *)jarg1;
18607   {
18608     try {
18609       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
18610     } CALL_CATCH_EXCEPTION(0);
18611   }
18612
18613   jresult = (unsigned long)result;
18614   return jresult;
18615 }
18616
18617
18618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
18619   int jresult ;
18620   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18621   std::size_t arg2 ;
18622   int32_t result;
18623
18624   arg1 = (Dali::TouchEvent *)jarg1;
18625   arg2 = (std::size_t)jarg2;
18626   {
18627     try {
18628       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
18629     } CALL_CATCH_EXCEPTION(0);
18630   }
18631
18632   jresult = result;
18633   return jresult;
18634 }
18635
18636
18637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
18638   int jresult ;
18639   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18640   std::size_t arg2 ;
18641   Dali::PointState::Type result;
18642
18643   arg1 = (Dali::TouchEvent *)jarg1;
18644   arg2 = (std::size_t)jarg2;
18645   {
18646     try {
18647       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
18648     } CALL_CATCH_EXCEPTION(0);
18649   }
18650
18651   jresult = (int)result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
18657   void * jresult ;
18658   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18659   std::size_t arg2 ;
18660   Dali::Actor result;
18661
18662   arg1 = (Dali::TouchEvent *)jarg1;
18663   arg2 = (std::size_t)jarg2;
18664   {
18665     try {
18666       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
18667     } CALL_CATCH_EXCEPTION(0);
18668   }
18669
18670   jresult = new Dali::Actor((const Dali::Actor &)result);
18671   return jresult;
18672 }
18673
18674
18675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
18676   void * jresult ;
18677   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18678   std::size_t arg2 ;
18679   Dali::Vector2 *result = 0 ;
18680
18681   arg1 = (Dali::TouchEvent *)jarg1;
18682   arg2 = (std::size_t)jarg2;
18683   {
18684     try {
18685       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
18686     } CALL_CATCH_EXCEPTION(0);
18687   }
18688
18689   jresult = (void *)result;
18690   return jresult;
18691 }
18692
18693
18694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
18695   void * jresult ;
18696   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18697   std::size_t arg2 ;
18698   Dali::Vector2 *result = 0 ;
18699
18700   arg1 = (Dali::TouchEvent *)jarg1;
18701   arg2 = (std::size_t)jarg2;
18702   {
18703     try {
18704       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
18705     } CALL_CATCH_EXCEPTION(0);
18706   }
18707
18708   jresult = (void *)result;
18709   return jresult;
18710 }
18711
18712
18713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
18714   float jresult ;
18715   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18716   std::size_t arg2 ;
18717   float result;
18718
18719   arg1 = (Dali::TouchEvent *)jarg1;
18720   arg2 = (std::size_t)jarg2;
18721   {
18722     try {
18723       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
18724     } CALL_CATCH_EXCEPTION(0);
18725   }
18726
18727   jresult = result;
18728   return jresult;
18729 }
18730
18731
18732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
18733   void * jresult ;
18734   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18735   std::size_t arg2 ;
18736   Dali::Vector2 *result = 0 ;
18737
18738   arg1 = (Dali::TouchEvent *)jarg1;
18739   arg2 = (std::size_t)jarg2;
18740   {
18741     try {
18742       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
18743     } CALL_CATCH_EXCEPTION(0);
18744   }
18745
18746   jresult = (void *)result;
18747   return jresult;
18748 }
18749
18750
18751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
18752   float jresult ;
18753   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18754   std::size_t arg2 ;
18755   float result;
18756
18757   arg1 = (Dali::TouchEvent *)jarg1;
18758   arg2 = (std::size_t)jarg2;
18759   {
18760     try {
18761       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
18762     } CALL_CATCH_EXCEPTION(0);
18763   }
18764
18765   jresult = result;
18766   return jresult;
18767 }
18768
18769
18770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
18771   void * jresult ;
18772   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18773   std::size_t arg2 ;
18774   Dali::Degree result;
18775
18776   arg1 = (Dali::TouchEvent *)jarg1;
18777   arg2 = (std::size_t)jarg2;
18778   {
18779     try {
18780       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
18781     } CALL_CATCH_EXCEPTION(0);
18782   }
18783
18784   jresult = new Dali::Degree((const Dali::Degree &)result);
18785   return jresult;
18786 }
18787
18788
18789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
18790   int jresult ;
18791   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18792   std::size_t arg2 ;
18793   Dali::MouseButton::Type result;
18794
18795   arg1 = (Dali::TouchEvent *)jarg1;
18796   arg2 = (std::size_t)jarg2;
18797   {
18798     try {
18799       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
18800     } CALL_CATCH_EXCEPTION(0);
18801   }
18802
18803   jresult = static_cast< int >(result);
18804   return jresult;
18805 }
18806
18807
18808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
18809   void * jresult ;
18810   Dali::GestureDetector *result = 0 ;
18811
18812   {
18813     try {
18814       result = (Dali::GestureDetector *)new Dali::GestureDetector();
18815     } CALL_CATCH_EXCEPTION(0);
18816   }
18817
18818   jresult = (void *)result;
18819   return jresult;
18820 }
18821
18822
18823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
18824   void * jresult ;
18825   Dali::BaseHandle arg1 ;
18826   Dali::BaseHandle *argp1 ;
18827   Dali::GestureDetector result;
18828
18829   argp1 = (Dali::BaseHandle *)jarg1;
18830   if (!argp1) {
18831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18832     return 0;
18833   }
18834   arg1 = *argp1;
18835   {
18836     try {
18837       result = Dali::GestureDetector::DownCast(arg1);
18838     } CALL_CATCH_EXCEPTION(0);
18839   }
18840
18841   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
18847   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18848
18849   arg1 = (Dali::GestureDetector *)jarg1;
18850   {
18851     try {
18852       delete arg1;
18853     } CALL_CATCH_EXCEPTION();
18854   }
18855
18856 }
18857
18858
18859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
18860   void * jresult ;
18861   Dali::GestureDetector *arg1 = 0 ;
18862   Dali::GestureDetector *result = 0 ;
18863
18864   arg1 = (Dali::GestureDetector *)jarg1;
18865   if (!arg1) {
18866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18867     return 0;
18868   }
18869   {
18870     try {
18871       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
18872     } CALL_CATCH_EXCEPTION(0);
18873   }
18874
18875   jresult = (void *)result;
18876   return jresult;
18877 }
18878
18879
18880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
18881   void * jresult ;
18882   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18883   Dali::GestureDetector *arg2 = 0 ;
18884   Dali::GestureDetector *result = 0 ;
18885
18886   arg1 = (Dali::GestureDetector *)jarg1;
18887   arg2 = (Dali::GestureDetector *)jarg2;
18888   if (!arg2) {
18889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18890     return 0;
18891   }
18892   {
18893     try {
18894       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
18895     } CALL_CATCH_EXCEPTION(0);
18896   }
18897
18898   jresult = (void *)result;
18899   return jresult;
18900 }
18901
18902
18903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
18904   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18905   Dali::Actor arg2 ;
18906   Dali::Actor *argp2 ;
18907
18908   arg1 = (Dali::GestureDetector *)jarg1;
18909   argp2 = (Dali::Actor *)jarg2;
18910   if (!argp2) {
18911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18912     return ;
18913   }
18914   arg2 = *argp2;
18915   {
18916     try {
18917       (arg1)->Attach(arg2);
18918     } CALL_CATCH_EXCEPTION();
18919   }
18920
18921 }
18922
18923
18924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
18925   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18926   Dali::Actor arg2 ;
18927   Dali::Actor *argp2 ;
18928
18929   arg1 = (Dali::GestureDetector *)jarg1;
18930   argp2 = (Dali::Actor *)jarg2;
18931   if (!argp2) {
18932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18933     return ;
18934   }
18935   arg2 = *argp2;
18936   {
18937     try {
18938       (arg1)->Detach(arg2);
18939     } CALL_CATCH_EXCEPTION();
18940   }
18941
18942 }
18943
18944
18945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
18946   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18947
18948   arg1 = (Dali::GestureDetector *)jarg1;
18949   {
18950     try {
18951       (arg1)->DetachAll();
18952     } CALL_CATCH_EXCEPTION();
18953   }
18954
18955 }
18956
18957
18958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
18959   unsigned long jresult ;
18960   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18961   size_t result;
18962
18963   arg1 = (Dali::GestureDetector *)jarg1;
18964   {
18965     try {
18966       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
18967     } CALL_CATCH_EXCEPTION(0);
18968   }
18969
18970   jresult = (unsigned long)result;
18971   return jresult;
18972 }
18973
18974
18975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
18976   void * jresult ;
18977   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18978   size_t arg2 ;
18979   Dali::Actor result;
18980
18981   arg1 = (Dali::GestureDetector *)jarg1;
18982   arg2 = (size_t)jarg2;
18983   {
18984     try {
18985       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
18986     } CALL_CATCH_EXCEPTION(0);
18987   }
18988
18989   jresult = new Dali::Actor((const Dali::Actor &)result);
18990   return jresult;
18991 }
18992
18993
18994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
18995   void * jresult ;
18996   Dali::Gesture *arg1 = 0 ;
18997   Dali::Gesture *result = 0 ;
18998
18999   arg1 = (Dali::Gesture *)jarg1;
19000   if (!arg1) {
19001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19002     return 0;
19003   }
19004   {
19005     try {
19006       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19007     } CALL_CATCH_EXCEPTION(0);
19008   }
19009
19010   jresult = (void *)result;
19011   return jresult;
19012 }
19013
19014
19015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19016   void * jresult ;
19017   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19018   Dali::Gesture *arg2 = 0 ;
19019   Dali::Gesture *result = 0 ;
19020
19021   arg1 = (Dali::Gesture *)jarg1;
19022   arg2 = (Dali::Gesture *)jarg2;
19023   if (!arg2) {
19024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19025     return 0;
19026   }
19027   {
19028     try {
19029       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19030     } CALL_CATCH_EXCEPTION(0);
19031   }
19032
19033   jresult = (void *)result;
19034   return jresult;
19035 }
19036
19037
19038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19039   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19040
19041   arg1 = (Dali::Gesture *)jarg1;
19042   {
19043     try {
19044       delete arg1;
19045     } CALL_CATCH_EXCEPTION();
19046   }
19047
19048 }
19049
19050
19051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
19052   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19053   Dali::Gesture::Type arg2 ;
19054
19055   arg1 = (Dali::Gesture *)jarg1;
19056   arg2 = (Dali::Gesture::Type)jarg2;
19057   if (arg1) (arg1)->type = arg2;
19058 }
19059
19060
19061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19062   int jresult ;
19063   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19064   Dali::Gesture::Type result;
19065
19066   arg1 = (Dali::Gesture *)jarg1;
19067   result = (Dali::Gesture::Type) ((arg1)->type);
19068   jresult = (int)result;
19069   return jresult;
19070 }
19071
19072
19073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
19074   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19075   Dali::Gesture::State arg2 ;
19076
19077   arg1 = (Dali::Gesture *)jarg1;
19078   arg2 = (Dali::Gesture::State)jarg2;
19079   if (arg1) (arg1)->state = arg2;
19080 }
19081
19082
19083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19084   int jresult ;
19085   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19086   Dali::Gesture::State result;
19087
19088   arg1 = (Dali::Gesture *)jarg1;
19089   result = (Dali::Gesture::State) ((arg1)->state);
19090   jresult = (int)result;
19091   return jresult;
19092 }
19093
19094
19095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
19096   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19097   unsigned int arg2 ;
19098
19099   arg1 = (Dali::Gesture *)jarg1;
19100   arg2 = (unsigned int)jarg2;
19101   if (arg1) (arg1)->time = arg2;
19102 }
19103
19104
19105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19106   unsigned int jresult ;
19107   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19108   unsigned int result;
19109
19110   arg1 = (Dali::Gesture *)jarg1;
19111   result = (unsigned int) ((arg1)->time);
19112   jresult = result;
19113   return jresult;
19114 }
19115
19116
19117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19118   void * jresult ;
19119   Dali::HoverEvent *result = 0 ;
19120
19121   {
19122     try {
19123       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19124     } CALL_CATCH_EXCEPTION(0);
19125   }
19126
19127   jresult = (void *)result;
19128   return jresult;
19129 }
19130
19131
19132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19133   void * jresult ;
19134   Dali::HoverEvent *arg1 = 0 ;
19135   Dali::HoverEvent *result = 0 ;
19136
19137   arg1 = (Dali::HoverEvent *)jarg1;
19138   if (!arg1) {
19139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19140     return 0;
19141   }
19142   {
19143     try {
19144       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
19145     } CALL_CATCH_EXCEPTION(0);
19146   }
19147
19148   jresult = (void *)result;
19149   return jresult;
19150 }
19151
19152
19153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
19154   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19155
19156   arg1 = (Dali::HoverEvent *)jarg1;
19157   {
19158     try {
19159       delete arg1;
19160     } CALL_CATCH_EXCEPTION();
19161   }
19162
19163 }
19164
19165
19166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
19167   void * jresult ;
19168   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19169   Dali::HoverEvent *arg2 = 0 ;
19170   Dali::HoverEvent *result = 0 ;
19171
19172   arg1 = (Dali::HoverEvent *)jarg1;
19173   arg2 = (Dali::HoverEvent *)jarg2;
19174   if (!arg2) {
19175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19176     return 0;
19177   }
19178   {
19179     try {
19180       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
19181     } catch (std::out_of_range& e) {
19182       {
19183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19184       };
19185     } catch (std::exception& e) {
19186       {
19187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19188       };
19189     } catch (Dali::DaliException e) {
19190       {
19191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19192       };
19193     } catch (...) {
19194       {
19195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19196       };
19197     }
19198   }
19199
19200   jresult = (void *)result;
19201   return jresult;
19202 }
19203
19204
19205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19206   unsigned long jresult ;
19207   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19208   unsigned long result;
19209
19210   arg1 = (Dali::HoverEvent *)jarg1;
19211   {
19212     try {
19213       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (Dali::DaliException e) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19225       };
19226     } catch (...) {
19227       {
19228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19229       };
19230     }
19231   }
19232
19233   jresult = (unsigned long)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19239   unsigned long jresult ;
19240   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19241   std::size_t result;
19242
19243   arg1 = (Dali::HoverEvent *)jarg1;
19244   {
19245     try {
19246       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19247     } catch (std::out_of_range& e) {
19248       {
19249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19250       };
19251     } catch (std::exception& e) {
19252       {
19253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19254       };
19255     } catch (Dali::DaliException e) {
19256       {
19257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19258       };
19259     } catch (...) {
19260       {
19261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19262       };
19263     }
19264   }
19265
19266   jresult = (unsigned long)result;
19267   return jresult;
19268 }
19269
19270
19271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19272   int jresult ;
19273   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19274   std::size_t arg2 ;
19275   int32_t result;
19276
19277   arg1 = (Dali::HoverEvent *)jarg1;
19278   arg2 = (std::size_t)jarg2;
19279   {
19280     try {
19281       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19282     } catch (std::out_of_range& e) {
19283       {
19284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19285       };
19286     } catch (std::exception& e) {
19287       {
19288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19289       };
19290     } catch (Dali::DaliException e) {
19291       {
19292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19293       };
19294     } catch (...) {
19295       {
19296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19297       };
19298     }
19299   }
19300
19301   jresult = result;
19302   return jresult;
19303 }
19304
19305
19306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19307   int jresult ;
19308   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19309   std::size_t arg2 ;
19310   Dali::PointState::Type result;
19311
19312   arg1 = (Dali::HoverEvent *)jarg1;
19313   arg2 = (std::size_t)jarg2;
19314   {
19315     try {
19316       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19317     } CALL_CATCH_EXCEPTION(0);
19318   }
19319
19320   jresult = (int)result;
19321   return jresult;
19322 }
19323
19324
19325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19326   void * jresult ;
19327   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19328   std::size_t arg2 ;
19329   Dali::Actor result;
19330
19331   arg1 = (Dali::HoverEvent *)jarg1;
19332   arg2 = (std::size_t)jarg2;
19333   {
19334     try {
19335       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19336     } catch (std::out_of_range& e) {
19337       {
19338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (std::exception& e) {
19341       {
19342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19343       };
19344     } catch (Dali::DaliException e) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19347       };
19348     } catch (...) {
19349       {
19350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19351       };
19352     }
19353   }
19354
19355   jresult = new Dali::Actor((const Dali::Actor &)result);
19356   return jresult;
19357 }
19358
19359
19360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19361   void * jresult ;
19362   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19363   std::size_t arg2 ;
19364   Dali::Vector2 *result = 0 ;
19365
19366   arg1 = (Dali::HoverEvent *)jarg1;
19367   arg2 = (std::size_t)jarg2;
19368   {
19369     try {
19370       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19371     } catch (std::out_of_range& e) {
19372       {
19373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19374       };
19375     } catch (std::exception& e) {
19376       {
19377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19378       };
19379     } catch (Dali::DaliException e) {
19380       {
19381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19382       };
19383     } catch (...) {
19384       {
19385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19386       };
19387     }
19388   }
19389
19390   jresult = (void *)result;
19391   return jresult;
19392 }
19393
19394
19395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19396   void * jresult ;
19397   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19398   std::size_t arg2 ;
19399   Dali::Vector2 *result = 0 ;
19400
19401   arg1 = (Dali::HoverEvent *)jarg1;
19402   arg2 = (std::size_t)jarg2;
19403   {
19404     try {
19405       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
19406     } CALL_CATCH_EXCEPTION(0);
19407   }
19408
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
19415   void * jresult ;
19416   Dali::KeyEvent *result = 0 ;
19417
19418   {
19419     try {
19420       result = (Dali::KeyEvent *)new Dali::KeyEvent();
19421     } CALL_CATCH_EXCEPTION(0);
19422   }
19423
19424   jresult = (void *)result;
19425   return jresult;
19426 }
19427
19428
19429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
19430   void * jresult ;
19431   Dali::KeyEvent *arg1 = 0 ;
19432   Dali::KeyEvent *result = 0 ;
19433
19434   arg1 = (Dali::KeyEvent *)jarg1;
19435   if (!arg1) {
19436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19437     return 0;
19438   }
19439   {
19440     try {
19441       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
19442     } CALL_CATCH_EXCEPTION(0);
19443   }
19444
19445   jresult = (void *)result;
19446   return jresult;
19447 }
19448
19449
19450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
19451   void * jresult ;
19452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19453   Dali::KeyEvent *arg2 = 0 ;
19454   Dali::KeyEvent *result = 0 ;
19455
19456   arg1 = (Dali::KeyEvent *)jarg1;
19457   arg2 = (Dali::KeyEvent *)jarg2;
19458   if (!arg2) {
19459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19460     return 0;
19461   }
19462   {
19463     try {
19464       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
19465     } CALL_CATCH_EXCEPTION(0);
19466   }
19467
19468   jresult = (void *)result;
19469   return jresult;
19470 }
19471
19472
19473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
19474   void * jresult ;
19475   std::string *arg1 = 0 ;
19476   std::string *arg2 = 0 ;
19477   int arg3 ;
19478   int arg4 ;
19479   unsigned long arg5 ;
19480   Dali::KeyEvent::State *arg6 = 0 ;
19481   Dali::KeyEvent::State temp6 ;
19482   Dali::KeyEvent result;
19483
19484   if (!jarg1) {
19485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19486     return 0;
19487   }
19488   std::string arg1_str(jarg1);
19489   arg1 = &arg1_str;
19490   if (!jarg2) {
19491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19492     return 0;
19493   }
19494   std::string arg2_str(jarg2);
19495   arg2 = &arg2_str;
19496   arg3 = (int)jarg3;
19497   arg4 = (int)jarg4;
19498   arg5 = (unsigned long)jarg5;
19499   temp6 = (Dali::KeyEvent::State)jarg6;
19500   arg6 = &temp6;
19501   {
19502     try {
19503       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);
19504     } CALL_CATCH_EXCEPTION(0);
19505   }
19506
19507   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
19508
19509   //argout typemap for const std::string&
19510
19511
19512   //argout typemap for const std::string&
19513
19514   return jresult;
19515 }
19516
19517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
19518   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19519
19520   arg1 = (Dali::KeyEvent *)jarg1;
19521   {
19522     try {
19523       delete arg1;
19524     } CALL_CATCH_EXCEPTION();
19525   }
19526
19527 }
19528
19529
19530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
19531   unsigned int jresult ;
19532   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19533   bool result;
19534
19535   arg1 = (Dali::KeyEvent *)jarg1;
19536   {
19537     try {
19538       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
19539     } CALL_CATCH_EXCEPTION(0);
19540   }
19541
19542   jresult = result;
19543   return jresult;
19544 }
19545
19546
19547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
19548   unsigned int jresult ;
19549   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19550   bool result;
19551
19552   arg1 = (Dali::KeyEvent *)jarg1;
19553   {
19554     try {
19555       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
19556     } CALL_CATCH_EXCEPTION(0);
19557   }
19558
19559   jresult = result;
19560   return jresult;
19561 }
19562
19563
19564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
19565   unsigned int jresult ;
19566   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19567   bool result;
19568
19569   arg1 = (Dali::KeyEvent *)jarg1;
19570   {
19571     try {
19572       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
19573     } CALL_CATCH_EXCEPTION(0);
19574   }
19575
19576   jresult = result;
19577   return jresult;
19578 }
19579
19580
19581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
19582   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19583   std::string *arg2 = 0 ;
19584
19585   Dali::KeyEvent arg1 = *argp1;
19586   if (!jarg2) {
19587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19588     return ;
19589   }
19590   std::string arg2_str(jarg2);
19591   arg2 = &arg2_str;
19592
19593   {
19594     try {
19595       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19596     } catch (std::out_of_range& e) {
19597       {
19598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19599       };
19600     } catch (std::exception& e) {
19601       {
19602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19603       };
19604     } catch (Dali::DaliException e) {
19605       {
19606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19607       };
19608     } catch (...) {
19609       {
19610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19611       };
19612     }
19613   }
19614 }
19615
19616
19617 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19618   char * jresult ;
19619
19620   if( jarg1 == NULL )
19621   {
19622     jresult = SWIG_csharp_string_callback( "" );
19623   }
19624   else
19625   {
19626     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19627     std::string *result = 0;
19628
19629     arg1 = ( Dali::KeyEvent * )jarg1;
19630     {
19631       try {
19632         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19633         result = (std::string *) &str;
19634       } catch (std::out_of_range& e) {
19635         {
19636           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19637         };
19638       } catch (std::exception& e) {
19639         {
19640           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19641         };
19642       } catch (Dali::DaliException e) {
19643         {
19644           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19645         };
19646       } catch (...) {
19647         {
19648           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19649         };
19650       }
19651     }
19652
19653     jresult = SWIG_csharp_string_callback(result->c_str());
19654   }
19655
19656   return jresult;
19657 }
19658
19659
19660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19661   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19662   std::string *arg2 = 0 ;
19663
19664   Dali::KeyEvent arg1 = *argp1;
19665   if (!jarg2) {
19666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19667     return ;
19668   }
19669   std::string arg2_str(jarg2);
19670   arg2 = &arg2_str;
19671
19672   {
19673     try {
19674       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19675     } catch (std::out_of_range& e) {
19676       {
19677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19678       };
19679     } catch (std::exception& e) {
19680       {
19681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19682       };
19683     } catch (Dali::DaliException e) {
19684       {
19685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19686       };
19687     } catch (...) {
19688       {
19689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19690       };
19691     }
19692   }
19693 }
19694
19695
19696 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19697   char * jresult ;
19698
19699   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19700   std::string *result = 0;
19701
19702   arg1 = ( Dali::KeyEvent * )jarg1;
19703   {
19704     try {
19705       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19706       result = (std::string *) &str;
19707     } catch (std::out_of_range& e) {
19708       {
19709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19710       };
19711     } catch (std::exception& e) {
19712       {
19713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19714       };
19715     } catch (Dali::DaliException e) {
19716       {
19717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19718       };
19719     } catch (...) {
19720       {
19721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19722       };
19723     }
19724
19725     jresult = SWIG_csharp_string_callback(result->c_str());
19726   }
19727
19728   return jresult;
19729 }
19730
19731
19732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19733   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19734   int arg2 ;
19735
19736   Dali::KeyEvent arg1 = *argp1;
19737   arg2 = (int)jarg2;
19738   {
19739     try {
19740       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19741     } catch (std::out_of_range& e) {
19742       {
19743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19744       };
19745     } catch (std::exception& e) {
19746       {
19747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19748       };
19749     } catch (Dali::DaliException e) {
19750       {
19751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19752       };
19753     } catch (...) {
19754       {
19755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19756       };
19757     }
19758   }
19759 }
19760
19761
19762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19763   int jresult ;
19764   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19765   int result;
19766
19767   arg1 = (Dali::KeyEvent *)jarg1;
19768   {
19769     try {
19770       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19771     } catch (std::out_of_range& e) {
19772       {
19773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19774       };
19775     } catch (std::exception& e) {
19776       {
19777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19778       };
19779     } catch (Dali::DaliException e) {
19780       {
19781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19782       };
19783     } catch (...) {
19784       {
19785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19786       };
19787     }
19788   }
19789
19790   jresult = result;
19791   return jresult;
19792 }
19793
19794
19795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19796   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19797   int arg2 ;
19798
19799   Dali::KeyEvent arg1 = *argp1;
19800   arg2 = (int)jarg2;
19801   {
19802     try {
19803       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19804     } catch (std::out_of_range& e) {
19805       {
19806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19807       };
19808     } catch (std::exception& e) {
19809       {
19810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19811       };
19812     } catch (Dali::DaliException e) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19815       };
19816     } catch (...) {
19817       {
19818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19819       };
19820     }
19821   }
19822 }
19823
19824
19825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19826   int jresult ;
19827   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19828   int result;
19829
19830   arg1 = (Dali::KeyEvent *)jarg1;
19831   {
19832     try {
19833       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19834     } catch (std::out_of_range& e) {
19835       {
19836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (std::exception& e) {
19839       {
19840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19841       };
19842     } catch (Dali::DaliException e) {
19843       {
19844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19845       };
19846     } catch (...) {
19847       {
19848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19849       };
19850     }
19851   }
19852
19853   jresult = result;
19854   return jresult;
19855 }
19856
19857
19858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19859   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19860   unsigned long arg2 ;
19861
19862   Dali::KeyEvent arg1 = *argp1;
19863   arg2 = (int)jarg2;
19864   {
19865     try {
19866       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19882       };
19883     }
19884   }
19885 }
19886
19887
19888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19889   unsigned long jresult ;
19890   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19891   unsigned long result;
19892
19893   arg1 = (Dali::KeyEvent *)jarg1;
19894   {
19895     try {
19896       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19897     } catch (std::out_of_range& e) {
19898       {
19899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19900       };
19901     } catch (std::exception& e) {
19902       {
19903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19904       };
19905     } catch (Dali::DaliException e) {
19906       {
19907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19908       };
19909     } catch (...) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19912       };
19913     }
19914   }
19915
19916   jresult = result;
19917   return jresult;
19918 }
19919
19920
19921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19922   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19923   Dali::KeyEvent::State arg2;
19924
19925   Dali::KeyEvent arg1 = *argp1;
19926   arg2 = (Dali::KeyEvent::State)jarg2;
19927   {
19928     try {
19929       Dali::DevelKeyEvent::SetState(arg1, arg2);
19930     } catch (std::out_of_range& e) {
19931       {
19932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19933       };
19934     } catch (std::exception& e) {
19935       {
19936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19937       };
19938     } catch (Dali::DaliException e) {
19939       {
19940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19941       };
19942     } catch (...) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19945       };
19946     }
19947   }
19948 }
19949
19950
19951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19952   int jresult ;
19953   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19954   Dali::KeyEvent::State result;
19955
19956   arg1 = (Dali::KeyEvent *)jarg1;
19957   {
19958     try {
19959       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19960     } catch (std::out_of_range& e) {
19961       {
19962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19963       };
19964     } catch (std::exception& e) {
19965       {
19966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19967       };
19968     } catch (Dali::DaliException e) {
19969       {
19970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19971       };
19972     } catch (...) {
19973       {
19974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19975       };
19976     }
19977   }
19978
19979   jresult = (int)result;
19980   return jresult;
19981
19982 }
19983
19984 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19985   char * jresult ;
19986
19987   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19988   std::string *result = 0;
19989
19990   arg1 = ( Dali::KeyEvent * )jarg1;
19991   {
19992     try {
19993       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19994       result = (std::string *) &str;
19995     } CALL_CATCH_EXCEPTION(0);
19996
19997   }
19998
19999   jresult = SWIG_csharp_string_callback(result->c_str());
20000   return jresult;
20001 }
20002
20003
20004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
20005   void * jresult ;
20006   Dali::LongPressGestureDetector *result = 0 ;
20007
20008   {
20009     try {
20010       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
20011     } CALL_CATCH_EXCEPTION(0);
20012   }
20013
20014   jresult = (void *)result;
20015   return jresult;
20016 }
20017
20018
20019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20020   void * jresult ;
20021   Dali::LongPressGestureDetector result;
20022
20023   {
20024     try {
20025       result = Dali::LongPressGestureDetector::New();
20026     } CALL_CATCH_EXCEPTION(0);
20027   }
20028
20029   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20030   return jresult;
20031 }
20032
20033
20034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20035   void * jresult ;
20036   unsigned int arg1 ;
20037   Dali::LongPressGestureDetector result;
20038
20039   arg1 = (unsigned int)jarg1;
20040   {
20041     try {
20042       result = Dali::LongPressGestureDetector::New(arg1);
20043     } CALL_CATCH_EXCEPTION(0);
20044   }
20045
20046   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20047   return jresult;
20048 }
20049
20050
20051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20052   void * jresult ;
20053   unsigned int arg1 ;
20054   unsigned int arg2 ;
20055   Dali::LongPressGestureDetector result;
20056
20057   arg1 = (unsigned int)jarg1;
20058   arg2 = (unsigned int)jarg2;
20059   {
20060     try {
20061       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20062     } CALL_CATCH_EXCEPTION(0);
20063   }
20064
20065   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20066   return jresult;
20067 }
20068
20069
20070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20071   void * jresult ;
20072   Dali::BaseHandle arg1 ;
20073   Dali::BaseHandle *argp1 ;
20074   Dali::LongPressGestureDetector result;
20075
20076   argp1 = (Dali::BaseHandle *)jarg1;
20077   if (!argp1) {
20078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20079     return 0;
20080   }
20081   arg1 = *argp1;
20082   {
20083     try {
20084       result = Dali::LongPressGestureDetector::DownCast(arg1);
20085     } CALL_CATCH_EXCEPTION(0);
20086   }
20087
20088   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20094   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20095
20096   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20097   {
20098     try {
20099       delete arg1;
20100     } CALL_CATCH_EXCEPTION();
20101   }
20102
20103 }
20104
20105
20106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20107   void * jresult ;
20108   Dali::LongPressGestureDetector *arg1 = 0 ;
20109   Dali::LongPressGestureDetector *result = 0 ;
20110
20111   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20112   if (!arg1) {
20113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20114     return 0;
20115   }
20116   {
20117     try {
20118       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20119     } CALL_CATCH_EXCEPTION(0);
20120   }
20121
20122   jresult = (void *)result;
20123   return jresult;
20124 }
20125
20126
20127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20128   void * jresult ;
20129   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20130   Dali::LongPressGestureDetector *arg2 = 0 ;
20131   Dali::LongPressGestureDetector *result = 0 ;
20132
20133   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20134   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20135   if (!arg2) {
20136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20137     return 0;
20138   }
20139   {
20140     try {
20141       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20142     } CALL_CATCH_EXCEPTION(0);
20143   }
20144
20145   jresult = (void *)result;
20146   return jresult;
20147 }
20148
20149
20150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20151   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20152   unsigned int arg2 ;
20153
20154   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20155   arg2 = (unsigned int)jarg2;
20156   {
20157     try {
20158       (arg1)->SetTouchesRequired(arg2);
20159     } CALL_CATCH_EXCEPTION();
20160   }
20161
20162 }
20163
20164
20165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20166   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20167   unsigned int arg2 ;
20168   unsigned int arg3 ;
20169
20170   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20171   arg2 = (unsigned int)jarg2;
20172   arg3 = (unsigned int)jarg3;
20173   {
20174     try {
20175       (arg1)->SetTouchesRequired(arg2,arg3);
20176     } CALL_CATCH_EXCEPTION();
20177   }
20178
20179 }
20180
20181
20182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20183   unsigned int jresult ;
20184   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20185   unsigned int result;
20186
20187   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20188   {
20189     try {
20190       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20191     } CALL_CATCH_EXCEPTION(0);
20192   }
20193
20194   jresult = result;
20195   return jresult;
20196 }
20197
20198
20199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20200   unsigned int jresult ;
20201   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20202   unsigned int result;
20203
20204   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20205   {
20206     try {
20207       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20208     } CALL_CATCH_EXCEPTION(0);
20209   }
20210
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20217   void * jresult ;
20218   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20219   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20220
20221   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20222   {
20223     try {
20224       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20225     } CALL_CATCH_EXCEPTION(0);
20226   }
20227
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
20234   void * jresult ;
20235   Dali::Gesture::State arg1 ;
20236   Dali::LongPressGesture *result = 0 ;
20237
20238   arg1 = (Dali::Gesture::State)jarg1;
20239   {
20240     try {
20241       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
20242     } CALL_CATCH_EXCEPTION(0);
20243   }
20244
20245   jresult = (void *)result;
20246   return jresult;
20247 }
20248
20249
20250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20251   void * jresult ;
20252   Dali::LongPressGesture *arg1 = 0 ;
20253   Dali::LongPressGesture *result = 0 ;
20254
20255   arg1 = (Dali::LongPressGesture *)jarg1;
20256   if (!arg1) {
20257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20258     return 0;
20259   }
20260   {
20261     try {
20262       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20263     } CALL_CATCH_EXCEPTION(0);
20264   }
20265
20266   jresult = (void *)result;
20267   return jresult;
20268 }
20269
20270
20271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20272   void * jresult ;
20273   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20274   Dali::LongPressGesture *arg2 = 0 ;
20275   Dali::LongPressGesture *result = 0 ;
20276
20277   arg1 = (Dali::LongPressGesture *)jarg1;
20278   arg2 = (Dali::LongPressGesture *)jarg2;
20279   if (!arg2) {
20280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20281     return 0;
20282   }
20283   {
20284     try {
20285       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20286     } CALL_CATCH_EXCEPTION(0);
20287   }
20288
20289   jresult = (void *)result;
20290   return jresult;
20291 }
20292
20293
20294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20295   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20296
20297   arg1 = (Dali::LongPressGesture *)jarg1;
20298   {
20299     try {
20300       delete arg1;
20301     } CALL_CATCH_EXCEPTION();
20302   }
20303
20304 }
20305
20306
20307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
20308   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20309   unsigned int arg2 ;
20310
20311   arg1 = (Dali::LongPressGesture *)jarg1;
20312   arg2 = (unsigned int)jarg2;
20313   if (arg1) (arg1)->numberOfTouches = arg2;
20314 }
20315
20316
20317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20318   unsigned int jresult ;
20319   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20320   unsigned int result;
20321
20322   arg1 = (Dali::LongPressGesture *)jarg1;
20323   result = (unsigned int) ((arg1)->numberOfTouches);
20324   jresult = result;
20325   return jresult;
20326 }
20327
20328
20329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
20330   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20331   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
20332
20333   arg1 = (Dali::LongPressGesture *)jarg1;
20334   arg2 = (Dali::Vector2 *)jarg2;
20335   if (arg1) (arg1)->screenPoint = *arg2;
20336 }
20337
20338
20339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20340   void * jresult ;
20341   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20342   Dali::Vector2 *result = 0 ;
20343
20344   arg1 = (Dali::LongPressGesture *)jarg1;
20345   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
20346   jresult = (void *)result;
20347   return jresult;
20348 }
20349
20350
20351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
20352   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20353   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
20354
20355   arg1 = (Dali::LongPressGesture *)jarg1;
20356   arg2 = (Dali::Vector2 *)jarg2;
20357   if (arg1) (arg1)->localPoint = *arg2;
20358 }
20359
20360
20361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20362   void * jresult ;
20363   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20364   Dali::Vector2 *result = 0 ;
20365
20366   arg1 = (Dali::LongPressGesture *)jarg1;
20367   result = (Dali::Vector2 *)& ((arg1)->localPoint);
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20374   void * jresult ;
20375   Dali::WheelEvent *result = 0 ;
20376
20377   {
20378     try {
20379       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20380     } CALL_CATCH_EXCEPTION(0);
20381   }
20382
20383   jresult = (void *)result;
20384   return jresult;
20385 }
20386
20387
20388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20389   void * jresult ;
20390   Dali::WheelEvent *arg1 = 0 ;
20391   Dali::WheelEvent *result = 0 ;
20392
20393   arg1 = (Dali::WheelEvent *)jarg1;
20394   if (!arg1) {
20395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20396     return 0;
20397   }
20398   {
20399     try {
20400       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20401     } catch (std::out_of_range& e) {
20402       {
20403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20404       };
20405     } catch (std::exception& e) {
20406       {
20407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (Dali::DaliException e) {
20410       {
20411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20412       };
20413     } catch (...) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20416       };
20417     }
20418   }
20419
20420   jresult = (void *)result;
20421   return jresult;
20422 }
20423
20424
20425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20426   void * jresult ;
20427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20428   Dali::WheelEvent *arg2 = 0 ;
20429   Dali::WheelEvent *result = 0 ;
20430
20431   arg1 = (Dali::WheelEvent *)jarg1;
20432   arg2 = (Dali::WheelEvent *)jarg2;
20433   if (!arg2) {
20434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20435     return 0;
20436   }
20437   {
20438     try {
20439       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20440     } catch (std::out_of_range& e) {
20441       {
20442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20443       };
20444     } catch (std::exception& e) {
20445       {
20446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (Dali::DaliException e) {
20449       {
20450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20451       };
20452     } catch (...) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20455       };
20456     }
20457   }
20458
20459   jresult = (void *)result;
20460   return jresult;
20461 }
20462
20463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20464   void * jresult ;
20465   Dali::WheelEvent::Type arg1 ;
20466   int arg2 ;
20467   unsigned int arg3 ;
20468   Dali::Vector2 arg4 ;
20469   int arg5 ;
20470   unsigned int arg6 ;
20471   Dali::Vector2 *argp4 ;
20472   Dali::WheelEvent result;
20473
20474   arg1 = (Dali::WheelEvent::Type)jarg1;
20475   arg2 = (int)jarg2;
20476   arg3 = (unsigned int)jarg3;
20477   argp4 = (Dali::Vector2 *)jarg4;
20478   if (!argp4) {
20479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20480     return 0;
20481   }
20482   arg4 = *argp4;
20483   arg5 = (int)jarg5;
20484   arg6 = (unsigned int)jarg6;
20485   {
20486     try {
20487       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20488     } CALL_CATCH_EXCEPTION(0);
20489   }
20490
20491   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20497   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20498
20499   arg1 = (Dali::WheelEvent *)jarg1;
20500   {
20501     try {
20502       delete arg1;
20503     } CALL_CATCH_EXCEPTION();
20504   }
20505
20506 }
20507
20508
20509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20510   unsigned int jresult ;
20511   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20512   bool result;
20513
20514   arg1 = (Dali::WheelEvent *)jarg1;
20515   {
20516     try {
20517       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20518     } CALL_CATCH_EXCEPTION(0);
20519   }
20520
20521   jresult = result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
20527   unsigned int jresult ;
20528   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20529   bool result;
20530
20531   arg1 = (Dali::WheelEvent *)jarg1;
20532   {
20533     try {
20534       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
20535     } catch (std::out_of_range& e) {
20536       {
20537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20538       };
20539     } catch (std::exception& e) {
20540       {
20541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20542       };
20543     } catch (Dali::DaliException e) {
20544       {
20545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20546       };
20547     } catch (...) {
20548       {
20549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20550       };
20551     }
20552   }
20553
20554   jresult = result;
20555   return jresult;
20556 }
20557
20558
20559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20560   unsigned int jresult ;
20561   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20562   bool result;
20563
20564   arg1 = (Dali::WheelEvent *)jarg1;
20565   {
20566     try {
20567       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20568     } catch (std::out_of_range& e) {
20569       {
20570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20571       };
20572     } catch (std::exception& e) {
20573       {
20574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20575       };
20576     } catch (Dali::DaliException e) {
20577       {
20578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20579       };
20580     } catch (...) {
20581       {
20582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20583       };
20584     }
20585   }
20586
20587   jresult = result;
20588   return jresult;
20589 }
20590
20591
20592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20593   int jresult ;
20594   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20595   Dali::WheelEvent::Type result;
20596
20597   arg1 = (Dali::WheelEvent *)jarg1;
20598   {
20599     try {
20600       result = ((Dali::WheelEvent const *)arg1)->GetType();
20601     } catch (std::out_of_range& e) {
20602       {
20603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20604       };
20605     } catch (std::exception& e) {
20606       {
20607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20608       };
20609     } catch (Dali::DaliException e) {
20610       {
20611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20612       };
20613     } catch (...) {
20614       {
20615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20616       };
20617     }
20618   }
20619
20620   jresult = (int)result;
20621   return jresult;
20622 }
20623
20624
20625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20626   int jresult ;
20627   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20628   int result;
20629
20630   arg1 = (Dali::WheelEvent *)jarg1;
20631   {
20632     try {
20633       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20634     } catch (std::out_of_range& e) {
20635       {
20636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20637       };
20638     } catch (std::exception& e) {
20639       {
20640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20641       };
20642     } catch (Dali::DaliException e) {
20643       {
20644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20645       };
20646     } catch (...) {
20647       {
20648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20649       };
20650     }
20651   }
20652
20653   jresult = result;
20654   return jresult;
20655 }
20656
20657
20658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20659   unsigned int jresult ;
20660   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20661   unsigned int result;
20662
20663   arg1 = (Dali::WheelEvent *)jarg1;
20664   {
20665     try {
20666       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20667     } CALL_CATCH_EXCEPTION(0);
20668   }
20669
20670   jresult = result;
20671   return jresult;
20672 }
20673
20674
20675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20676   void * jresult ;
20677   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20678   Dali::Vector2 *result = 0 ;
20679
20680   arg1 = (Dali::WheelEvent *)jarg1;
20681   {
20682     try {
20683       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20684     } CALL_CATCH_EXCEPTION(0);
20685   }
20686
20687   jresult = (void *)result;
20688   return jresult;
20689 }
20690
20691
20692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20693   int jresult ;
20694   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20695   int result;
20696
20697   arg1 = (Dali::WheelEvent *)jarg1;
20698   {
20699     try {
20700       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20701     } catch (std::out_of_range& e) {
20702       {
20703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (std::exception& e) {
20706       {
20707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20708       };
20709     } catch (Dali::DaliException e) {
20710       {
20711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20712       };
20713     } catch (...) {
20714       {
20715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20716       };
20717     }
20718   }
20719
20720   jresult = result;
20721   return jresult;
20722 }
20723
20724
20725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20726   unsigned int jresult ;
20727   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20728   unsigned int result;
20729
20730   arg1 = (Dali::WheelEvent *)jarg1;
20731   {
20732     try {
20733       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20734     } catch (std::out_of_range& e) {
20735       {
20736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (std::exception& e) {
20739       {
20740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20741       };
20742     } catch (Dali::DaliException e) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20745       };
20746     } catch (...) {
20747       {
20748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20749       };
20750     }
20751   }
20752
20753   jresult = result;
20754   return jresult;
20755 }
20756
20757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20758   char * jresult ;
20759   Dali::KeyEvent *arg1 = 0 ;
20760   std::string result;
20761
20762   arg1 = (Dali::KeyEvent *)jarg1;
20763   if (!arg1) {
20764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20765     return 0;
20766   }
20767   {
20768     try {
20769       result = arg1->GetDeviceName();
20770     } CALL_CATCH_EXCEPTION(0);
20771   }
20772
20773   jresult = SWIG_csharp_string_callback((&result)->c_str());
20774   return jresult;
20775 }
20776
20777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20778   int jresult ;
20779   Dali::KeyEvent *arg1 = 0 ;
20780   Dali::Device::Class::Type result;
20781
20782   arg1 = (Dali::KeyEvent *)jarg1;
20783   if (!arg1) {
20784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20785     return 0;
20786   }
20787   {
20788     try {
20789       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20790     } CALL_CATCH_EXCEPTION(0);
20791   }
20792
20793   jresult = (int)result;
20794   return jresult;
20795 }
20796
20797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20798   int jresult ;
20799   Dali::KeyEvent *arg1 = 0 ;
20800   Dali::Device::Subclass::Type result;
20801
20802   arg1 = (Dali::KeyEvent *)jarg1;
20803   if (!arg1) {
20804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20805     return 0;
20806   }
20807   {
20808     try {
20809       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20810     } CALL_CATCH_EXCEPTION(0);
20811   }
20812
20813   jresult = (int)result;
20814   return jresult;
20815 }
20816
20817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
20818   Dali::Actor arg1 ;
20819   Dali::Actor *argp1 ;
20820
20821   argp1 = (Dali::Actor *)jarg1;
20822   if (!argp1) {
20823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20824     return ;
20825   }
20826   arg1 = *argp1;
20827   {
20828     try {
20829       arg1.Raise();
20830     } CALL_CATCH_EXCEPTION();
20831   }
20832
20833 }
20834
20835
20836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
20837   Dali::Actor arg1 ;
20838   Dali::Actor *argp1 ;
20839
20840   argp1 = (Dali::Actor *)jarg1;
20841   if (!argp1) {
20842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20843     return ;
20844   }
20845   arg1 = *argp1;
20846   {
20847     try {
20848       arg1.Lower();
20849     } CALL_CATCH_EXCEPTION();
20850   }
20851
20852 }
20853
20854
20855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
20856   Dali::Actor arg1 ;
20857   Dali::Actor *argp1 ;
20858
20859   argp1 = (Dali::Actor *)jarg1;
20860   if (!argp1) {
20861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20862     return ;
20863   }
20864   arg1 = *argp1;
20865   {
20866     try {
20867       arg1.RaiseToTop();
20868     } CALL_CATCH_EXCEPTION();
20869   }
20870
20871 }
20872
20873
20874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20875   Dali::Actor arg1 ;
20876   Dali::Actor *argp1 ;
20877
20878   argp1 = (Dali::Actor *)jarg1;
20879   if (!argp1) {
20880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20881     return ;
20882   }
20883   arg1 = *argp1;
20884   {
20885     try {
20886       arg1.LowerToBottom();
20887     } CALL_CATCH_EXCEPTION();
20888   }
20889
20890 }
20891
20892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20893   Dali::Actor arg1 ;
20894   Dali::Actor arg2 ;
20895   Dali::Actor *argp1 ;
20896   Dali::Actor *argp2 ;
20897
20898   argp1 = (Dali::Actor *)jarg1;
20899   if (!argp1) {
20900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20901     return ;
20902   }
20903   arg1 = *argp1;
20904   argp2 = (Dali::Actor *)jarg2;
20905   if (!argp2) {
20906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20907     return ;
20908   }
20909   arg2 = *argp2;
20910   {
20911     try {
20912       arg1.RaiseAbove(arg2);
20913     } CALL_CATCH_EXCEPTION();
20914   }
20915
20916 }
20917
20918
20919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20920   Dali::Actor arg1 ;
20921   Dali::Actor arg2 ;
20922   Dali::Actor *argp1 ;
20923   Dali::Actor *argp2 ;
20924
20925   argp1 = (Dali::Actor *)jarg1;
20926   if (!argp1) {
20927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20928     return ;
20929   }
20930   arg1 = *argp1;
20931   argp2 = (Dali::Actor *)jarg2;
20932   if (!argp2) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20934     return ;
20935   }
20936   arg2 = *argp2;
20937   {
20938     try {
20939       arg1.LowerBelow(arg2);
20940     } CALL_CATCH_EXCEPTION();
20941   }
20942
20943 }
20944
20945
20946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20947   void * jresult ;
20948   Dali::Actor arg1 ;
20949   Dali::Actor *argp1 ;
20950   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20951
20952   argp1 = (Dali::Actor *)jarg1;
20953   if (!argp1) {
20954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20955     return 0;
20956   }
20957   arg1 = *argp1;
20958   {
20959     try {
20960       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20961     } CALL_CATCH_EXCEPTION(0);
20962   }
20963
20964   jresult = (void *)result;
20965   return jresult;
20966 }
20967
20968
20969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20970   void * jresult ;
20971   Dali::Actor *arg1 ;
20972   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20973
20974   arg1 = (Dali::Actor *)jarg1;
20975   {
20976     try {
20977       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20978     } CALL_CATCH_EXCEPTION(0);
20979   }
20980
20981   jresult = (void *)result;
20982   return jresult;
20983 }
20984
20985
20986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20987   int jresult ;
20988   int result;
20989
20990   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20991   jresult = (int)result;
20992   return jresult;
20993 }
20994
20995
20996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20997   int jresult ;
20998   int result;
20999
21000   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
21001   jresult = (int)result;
21002   return jresult;
21003 }
21004
21005
21006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
21007   int jresult ;
21008   int result;
21009
21010   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
21011   jresult = (int)result;
21012   return jresult;
21013 }
21014
21015
21016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
21017   int jresult ;
21018   int result;
21019
21020   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
21021   jresult = (int)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21027   int jresult ;
21028   int result;
21029
21030   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21031   jresult = (int)result;
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21037   int jresult ;
21038   int result;
21039
21040   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21041   jresult = (int)result;
21042   return jresult;
21043 }
21044
21045
21046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21047   int jresult ;
21048   int result;
21049
21050   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21051   jresult = (int)result;
21052   return jresult;
21053 }
21054
21055
21056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21057   int jresult ;
21058   int result;
21059
21060   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21061   jresult = (int)result;
21062   return jresult;
21063 }
21064
21065
21066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21067   int jresult ;
21068   int result;
21069
21070   result = (int)Dali::Actor::Property::SIZE;
21071   jresult = (int)result;
21072   return jresult;
21073 }
21074
21075
21076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21077   int jresult ;
21078   int result;
21079
21080   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21081   jresult = (int)result;
21082   return jresult;
21083 }
21084
21085
21086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21087   int jresult ;
21088   int result;
21089
21090   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21091   jresult = (int)result;
21092   return jresult;
21093 }
21094
21095
21096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21097   int jresult ;
21098   int result;
21099
21100   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21101   jresult = (int)result;
21102   return jresult;
21103 }
21104
21105
21106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21107   int jresult ;
21108   int result;
21109
21110   result = (int)Dali::Actor::Property::POSITION;
21111   jresult = (int)result;
21112   return jresult;
21113 }
21114
21115
21116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21117   int jresult ;
21118   int result;
21119
21120   result = (int)Dali::Actor::Property::POSITION_X;
21121   jresult = (int)result;
21122   return jresult;
21123 }
21124
21125
21126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21127   int jresult ;
21128   int result;
21129
21130   result = (int)Dali::Actor::Property::POSITION_Y;
21131   jresult = (int)result;
21132   return jresult;
21133 }
21134
21135
21136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21137   int jresult ;
21138   int result;
21139
21140   result = (int)Dali::Actor::Property::POSITION_Z;
21141   jresult = (int)result;
21142   return jresult;
21143 }
21144
21145
21146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21147   int jresult ;
21148   int result;
21149
21150   result = (int)Dali::Actor::Property::WORLD_POSITION;
21151   jresult = (int)result;
21152   return jresult;
21153 }
21154
21155
21156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21157   int jresult ;
21158   int result;
21159
21160   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21161   jresult = (int)result;
21162   return jresult;
21163 }
21164
21165
21166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21167   int jresult ;
21168   int result;
21169
21170   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21171   jresult = (int)result;
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21177   int jresult ;
21178   int result;
21179
21180   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21181   jresult = (int)result;
21182   return jresult;
21183 }
21184
21185
21186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21187   int jresult ;
21188   int result;
21189
21190   result = (int)Dali::Actor::Property::ORIENTATION;
21191   jresult = (int)result;
21192   return jresult;
21193 }
21194
21195
21196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21197   int jresult ;
21198   int result;
21199
21200   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21201   jresult = (int)result;
21202   return jresult;
21203 }
21204
21205
21206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21207   int jresult ;
21208   int result;
21209
21210   result = (int)Dali::Actor::Property::SCALE;
21211   jresult = (int)result;
21212   return jresult;
21213 }
21214
21215
21216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21217   int jresult ;
21218   int result;
21219
21220   result = (int)Dali::Actor::Property::SCALE_X;
21221   jresult = (int)result;
21222   return jresult;
21223 }
21224
21225
21226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21227   int jresult ;
21228   int result;
21229
21230   result = (int)Dali::Actor::Property::SCALE_Y;
21231   jresult = (int)result;
21232   return jresult;
21233 }
21234
21235
21236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21237   int jresult ;
21238   int result;
21239
21240   result = (int)Dali::Actor::Property::SCALE_Z;
21241   jresult = (int)result;
21242   return jresult;
21243 }
21244
21245
21246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21247   int jresult ;
21248   int result;
21249
21250   result = (int)Dali::Actor::Property::WORLD_SCALE;
21251   jresult = (int)result;
21252   return jresult;
21253 }
21254
21255
21256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21257   int jresult ;
21258   int result;
21259
21260   result = (int)Dali::Actor::Property::VISIBLE;
21261   jresult = (int)result;
21262   return jresult;
21263 }
21264
21265
21266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21267   int jresult ;
21268   int result;
21269
21270   result = (int)Dali::Actor::Property::COLOR;
21271   jresult = (int)result;
21272   return jresult;
21273 }
21274
21275
21276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21277   int jresult ;
21278   int result;
21279
21280   result = (int)Dali::Actor::Property::COLOR_RED;
21281   jresult = (int)result;
21282   return jresult;
21283 }
21284
21285
21286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21287   int jresult ;
21288   int result;
21289
21290   result = (int)Dali::Actor::Property::COLOR_GREEN;
21291   jresult = (int)result;
21292   return jresult;
21293 }
21294
21295
21296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21297   int jresult ;
21298   int result;
21299
21300   result = (int)Dali::Actor::Property::COLOR_BLUE;
21301   jresult = (int)result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21307   int jresult ;
21308   int result;
21309
21310   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21311   jresult = (int)result;
21312   return jresult;
21313 }
21314
21315
21316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21317   int jresult ;
21318   int result;
21319
21320   result = (int)Dali::Actor::Property::WORLD_COLOR;
21321   jresult = (int)result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21327   int jresult ;
21328   int result;
21329
21330   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21331   jresult = (int)result;
21332   return jresult;
21333 }
21334
21335
21336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21337   int jresult ;
21338   int result;
21339
21340   result = (int)Dali::Actor::Property::NAME;
21341   jresult = (int)result;
21342   return jresult;
21343 }
21344
21345
21346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21347   int jresult ;
21348   int result;
21349
21350   result = (int)Dali::Actor::Property::SENSITIVE;
21351   jresult = (int)result;
21352   return jresult;
21353 }
21354
21355
21356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21357   int jresult ;
21358   int result;
21359
21360   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21361   jresult = (int)result;
21362   return jresult;
21363 }
21364
21365
21366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21367   int jresult ;
21368   int result;
21369
21370   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21371   jresult = (int)result;
21372   return jresult;
21373 }
21374
21375
21376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21377   int jresult ;
21378   int result;
21379
21380   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21381   jresult = (int)result;
21382   return jresult;
21383 }
21384
21385
21386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21387   int jresult ;
21388   int result;
21389
21390   result = (int)Dali::Actor::Property::COLOR_MODE;
21391   jresult = (int)result;
21392   return jresult;
21393 }
21394
21395
21396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21397   int jresult ;
21398   int result;
21399
21400   result = (int)Dali::Actor::Property::DRAW_MODE;
21401   jresult = (int)result;
21402   return jresult;
21403 }
21404
21405
21406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21407   int jresult ;
21408   int result;
21409
21410   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21411   jresult = (int)result;
21412   return jresult;
21413 }
21414
21415
21416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21417   int jresult ;
21418   int result;
21419
21420   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21421   jresult = (int)result;
21422   return jresult;
21423 }
21424
21425
21426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21427   int jresult ;
21428   int result;
21429
21430   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21431   jresult = (int)result;
21432   return jresult;
21433 }
21434
21435
21436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21437   int jresult ;
21438   int result;
21439
21440   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21441   jresult = (int)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21447   int jresult ;
21448   int result;
21449
21450   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21451   jresult = (int)result;
21452   return jresult;
21453 }
21454
21455
21456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21457   int jresult ;
21458   int result;
21459
21460   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21461   jresult = (int)result;
21462   return jresult;
21463 }
21464
21465
21466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21467   int jresult ;
21468   int result;
21469
21470   result = (int)Dali::Actor::Property::PADDING;
21471   jresult = (int)result;
21472   return jresult;
21473 }
21474
21475
21476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21477   int jresult ;
21478   int result;
21479
21480   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21481   jresult = (int)result;
21482   return jresult;
21483 }
21484
21485
21486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21487   int jresult ;
21488   int result;
21489
21490   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21491   jresult = (int)result;
21492   return jresult;
21493 }
21494
21495
21496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21497   int jresult ;
21498   int result;
21499
21500   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21501   jresult = (int)result;
21502   return jresult;
21503 }
21504
21505
21506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21507   int jresult ;
21508   int result;
21509
21510   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21511   jresult = (int)result;
21512   return jresult;
21513 }
21514
21515 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21516
21517   return Dali::Actor::Property::OPACITY;
21518 }
21519
21520 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21521
21522   return Dali::Actor::Property::SCREEN_POSITION;
21523 }
21524
21525 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21526
21527   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21528 }
21529
21530 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21531   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21532 }
21533
21534 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21535   return Dali::Actor::Property::LAYOUT_DIRECTION;
21536 }
21537
21538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21539   void * jresult ;
21540   Dali::Actor::Property *result = 0 ;
21541
21542   {
21543     try {
21544       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21545     } CALL_CATCH_EXCEPTION(0);
21546   }
21547
21548   jresult = (void *)result;
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21554   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21555
21556   arg1 = (Dali::Actor::Property *)jarg1;
21557   {
21558     try {
21559       delete arg1;
21560     } CALL_CATCH_EXCEPTION();
21561   }
21562
21563 }
21564
21565
21566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21567   void * jresult ;
21568   Dali::Actor *result = 0 ;
21569
21570   {
21571     try {
21572       result = (Dali::Actor *)new Dali::Actor();
21573     } CALL_CATCH_EXCEPTION(0);
21574   }
21575
21576   jresult = (void *)result;
21577   return jresult;
21578 }
21579
21580
21581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21582   void * jresult ;
21583   Dali::Actor result;
21584
21585   {
21586     try {
21587       result = Dali::Actor::New();
21588     } CALL_CATCH_EXCEPTION(0);
21589   }
21590
21591   jresult = new Dali::Actor((const Dali::Actor &)result);
21592   return jresult;
21593 }
21594
21595
21596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21597   void * jresult ;
21598   Dali::BaseHandle arg1 ;
21599   Dali::BaseHandle *argp1 ;
21600   Dali::Actor result;
21601
21602   argp1 = (Dali::BaseHandle *)jarg1;
21603   if (!argp1) {
21604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21605     return 0;
21606   }
21607   arg1 = *argp1;
21608   {
21609     try {
21610       result = Dali::Actor::DownCast(arg1);
21611     } CALL_CATCH_EXCEPTION(0);
21612   }
21613
21614   jresult = new Dali::Actor((const Dali::Actor &)result);
21615   return jresult;
21616 }
21617
21618
21619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21621
21622   arg1 = (Dali::Actor *)jarg1;
21623   {
21624     try {
21625       delete arg1;
21626     } CALL_CATCH_EXCEPTION();
21627   }
21628
21629 }
21630
21631
21632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21633   void * jresult ;
21634   Dali::Actor *arg1 = 0 ;
21635   Dali::Actor *result = 0 ;
21636
21637   arg1 = (Dali::Actor *)jarg1;
21638   if (!arg1) {
21639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21640     return 0;
21641   }
21642   {
21643     try {
21644       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21645     } CALL_CATCH_EXCEPTION(0);
21646   }
21647
21648   jresult = (void *)result;
21649   return jresult;
21650 }
21651
21652
21653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21654   void * jresult ;
21655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21656   Dali::Actor *arg2 = 0 ;
21657   Dali::Actor *result = 0 ;
21658
21659   arg1 = (Dali::Actor *)jarg1;
21660   arg2 = (Dali::Actor *)jarg2;
21661   if (!arg2) {
21662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21663     return 0;
21664   }
21665   {
21666     try {
21667       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21668     } CALL_CATCH_EXCEPTION(0);
21669   }
21670
21671   jresult = (void *)result;
21672   return jresult;
21673 }
21674
21675
21676 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21677   char * jresult ;
21678   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21679   std::string *result = 0 ;
21680   std::string name = "";
21681
21682   arg1 = (Dali::Actor *)jarg1;
21683   {
21684     try {
21685       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21686       result = (std::string *) &name;
21687       jresult = SWIG_csharp_string_callback(result->c_str());
21688     } CALL_CATCH_EXCEPTION(0);
21689   }
21690   return jresult;
21691 }
21692
21693
21694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21696   std::string *arg2 = 0 ;
21697
21698   arg1 = (Dali::Actor *)jarg1;
21699   if (!jarg2) {
21700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21701     return ;
21702   }
21703   std::string arg2_str(jarg2);
21704   arg2 = &arg2_str;
21705   {
21706     try {
21707       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21708     } CALL_CATCH_EXCEPTION();
21709   }
21710
21711
21712   //argout typemap for const std::string&
21713
21714 }
21715
21716
21717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21718   unsigned int jresult ;
21719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21720   unsigned int result;
21721
21722   arg1 = (Dali::Actor *)jarg1;
21723
21724   if(!arg1) {
21725     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21726     return -1;
21727   }
21728
21729   {
21730     try {
21731       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21732     } CALL_CATCH_EXCEPTION(0);
21733   }
21734
21735   jresult = result;
21736   return jresult;
21737 }
21738
21739
21740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21741   unsigned int jresult ;
21742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21743   bool result;
21744
21745   arg1 = (Dali::Actor *)jarg1;
21746   {
21747     try {
21748       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21749     } CALL_CATCH_EXCEPTION(0);
21750   }
21751
21752   jresult = result;
21753   return jresult;
21754 }
21755
21756
21757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
21758   unsigned int jresult ;
21759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21760   bool result;
21761
21762   arg1 = (Dali::Actor *)jarg1;
21763   {
21764     try {
21765       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
21766     } CALL_CATCH_EXCEPTION(0);
21767   }
21768
21769   jresult = result;
21770   return jresult;
21771 }
21772
21773
21774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
21775   unsigned int jresult ;
21776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21777   bool result;
21778
21779   arg1 = (Dali::Actor *)jarg1;
21780   {
21781     try {
21782       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
21783     } CALL_CATCH_EXCEPTION(0);
21784   }
21785
21786   jresult = result;
21787   return jresult;
21788 }
21789
21790
21791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21792   void * jresult ;
21793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21794   Dali::Layer result;
21795
21796   arg1 = (Dali::Actor *)jarg1;
21797   {
21798     try {
21799       result = (arg1)->GetLayer();
21800     } CALL_CATCH_EXCEPTION(0);
21801   }
21802
21803   jresult = new Dali::Layer((const Dali::Layer &)result);
21804   return jresult;
21805 }
21806
21807
21808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21810   Dali::Actor arg2 ;
21811   Dali::Actor *argp2 ;
21812
21813   arg1 = (Dali::Actor *)jarg1;
21814   argp2 = (Dali::Actor *)jarg2;
21815   if (!argp2) {
21816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21817     return ;
21818   }
21819   arg2 = *argp2;
21820   {
21821     try {
21822       (arg1)->Add(arg2);
21823     } CALL_CATCH_EXCEPTION();
21824   }
21825
21826 }
21827
21828
21829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21831   Dali::Actor arg2 ;
21832   Dali::Actor *argp2 ;
21833
21834   arg1 = (Dali::Actor *)jarg1;
21835   argp2 = (Dali::Actor *)jarg2;
21836   if (!argp2) {
21837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21838     return ;
21839   }
21840   arg2 = *argp2;
21841   {
21842     try {
21843       (arg1)->Remove(arg2);
21844     } CALL_CATCH_EXCEPTION();
21845   }
21846
21847 }
21848
21849
21850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21852
21853   arg1 = (Dali::Actor *)jarg1;
21854   {
21855     try {
21856       (arg1)->Unparent();
21857     } CALL_CATCH_EXCEPTION();
21858   }
21859
21860 }
21861
21862
21863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21864   unsigned int jresult ;
21865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21866   unsigned int result;
21867
21868   arg1 = (Dali::Actor *)jarg1;
21869   {
21870     try {
21871       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21872     } CALL_CATCH_EXCEPTION(0);
21873   }
21874
21875   jresult = result;
21876   return jresult;
21877 }
21878
21879
21880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21881   void * jresult ;
21882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21883   unsigned int arg2 ;
21884   Dali::Actor result;
21885
21886   arg1 = (Dali::Actor *)jarg1;
21887   arg2 = (unsigned int)jarg2;
21888   {
21889     try {
21890       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21891     } CALL_CATCH_EXCEPTION(0);
21892   }
21893
21894   jresult = new Dali::Actor((const Dali::Actor &)result);
21895   return jresult;
21896 }
21897
21898
21899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21900   void * jresult ;
21901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21902   std::string *arg2 = 0 ;
21903   Dali::Actor result;
21904
21905   arg1 = (Dali::Actor *)jarg1;
21906   if (!jarg2) {
21907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21908     return 0;
21909   }
21910   std::string arg2_str(jarg2);
21911   arg2 = &arg2_str;
21912   {
21913     try {
21914       result = (arg1)->FindChildByName((std::string const &)*arg2);
21915     } CALL_CATCH_EXCEPTION(0);
21916   }
21917
21918   jresult = new Dali::Actor((const Dali::Actor &)result);
21919
21920   //argout typemap for const std::string&
21921
21922   return jresult;
21923 }
21924
21925
21926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21927   void * jresult ;
21928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21929   unsigned int arg2 ;
21930   Dali::Actor result;
21931
21932   arg1 = (Dali::Actor *)jarg1;
21933   arg2 = (unsigned int)jarg2;
21934   {
21935     try {
21936       result = (arg1)->FindChildById(arg2);
21937     } CALL_CATCH_EXCEPTION(0);
21938   }
21939
21940   jresult = new Dali::Actor((const Dali::Actor &)result);
21941   return jresult;
21942 }
21943
21944
21945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21946   void * jresult ;
21947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21948   Dali::Actor result;
21949
21950   arg1 = (Dali::Actor *)jarg1;
21951   {
21952     try {
21953       result = ((Dali::Actor const *)arg1)->GetParent();
21954     } CALL_CATCH_EXCEPTION(0);
21955   }
21956
21957   jresult = new Dali::Actor((const Dali::Actor &)result);
21958   return jresult;
21959 }
21960
21961
21962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
21963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21964   Dali::Vector3 *arg2 = 0 ;
21965
21966   arg1 = (Dali::Actor *)jarg1;
21967   arg2 = (Dali::Vector3 *)jarg2;
21968   if (!arg2) {
21969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21970     return ;
21971   }
21972   {
21973     try {
21974       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21975     } CALL_CATCH_EXCEPTION();
21976   }
21977
21978 }
21979
21980
21981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21982   void * jresult ;
21983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21984   Dali::Vector3 result;
21985
21986   arg1 = (Dali::Actor *)jarg1;
21987   {
21988     try {
21989       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21990     } CALL_CATCH_EXCEPTION(0);
21991   }
21992
21993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21994   return jresult;
21995 }
21996
21997
21998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
21999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22000   Dali::Vector3 *arg2 = 0 ;
22001
22002   arg1 = (Dali::Actor *)jarg1;
22003   arg2 = (Dali::Vector3 *)jarg2;
22004   if (!arg2) {
22005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22006     return ;
22007   }
22008   {
22009     try {
22010       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22011     } CALL_CATCH_EXCEPTION();
22012   }
22013
22014 }
22015
22016
22017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22018   void * jresult ;
22019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22020   Dali::Vector3 result;
22021
22022   arg1 = (Dali::Actor *)jarg1;
22023   {
22024     try {
22025       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22026     } CALL_CATCH_EXCEPTION(0);
22027   }
22028
22029   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22036   float arg2 ;
22037   float arg3 ;
22038
22039   arg1 = (Dali::Actor *)jarg1;
22040   arg2 = (float)jarg2;
22041   arg3 = (float)jarg3;
22042   {
22043     try {
22044       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22045     } CALL_CATCH_EXCEPTION();
22046   }
22047
22048 }
22049
22050
22051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22053   float arg2 ;
22054   float arg3 ;
22055   float arg4 ;
22056
22057   arg1 = (Dali::Actor *)jarg1;
22058   arg2 = (float)jarg2;
22059   arg3 = (float)jarg3;
22060   arg4 = (float)jarg4;
22061   {
22062     try {
22063       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22064     } CALL_CATCH_EXCEPTION();
22065   }
22066
22067 }
22068
22069
22070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22071   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22072   Dali::Vector2 *arg2 = 0 ;
22073
22074   arg1 = (Dali::Actor *)jarg1;
22075   arg2 = (Dali::Vector2 *)jarg2;
22076   if (!arg2) {
22077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22078     return ;
22079   }
22080   {
22081     try {
22082       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22083     } CALL_CATCH_EXCEPTION();
22084   }
22085
22086 }
22087
22088
22089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22091   Dali::Vector3 *arg2 = 0 ;
22092
22093   arg1 = (Dali::Actor *)jarg1;
22094   arg2 = (Dali::Vector3 *)jarg2;
22095   if (!arg2) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22097     return ;
22098   }
22099   {
22100     try {
22101       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22102     } CALL_CATCH_EXCEPTION();
22103   }
22104
22105 }
22106
22107
22108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22109   void * jresult ;
22110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22111   Dali::Vector3 result;
22112
22113   arg1 = (Dali::Actor *)jarg1;
22114   {
22115     try {
22116       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22117     } CALL_CATCH_EXCEPTION(0);
22118   }
22119
22120   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22121   return jresult;
22122 }
22123
22124
22125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22126   void * jresult ;
22127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22128   Dali::Vector3 result;
22129
22130   arg1 = (Dali::Actor *)jarg1;
22131   {
22132     try {
22133       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22134     } CALL_CATCH_EXCEPTION(0);
22135   }
22136
22137   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22138   return jresult;
22139 }
22140
22141
22142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22143   void * jresult ;
22144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22145   Dali::Vector3 result;
22146
22147   arg1 = (Dali::Actor *)jarg1;
22148   {
22149     try {
22150       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22151     } CALL_CATCH_EXCEPTION(0);
22152   }
22153
22154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22155   return jresult;
22156 }
22157
22158
22159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22161   float arg2 ;
22162   float arg3 ;
22163
22164   arg1 = (Dali::Actor *)jarg1;
22165   arg2 = (float)jarg2;
22166   arg3 = (float)jarg3;
22167   {
22168     try {
22169       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22170     } CALL_CATCH_EXCEPTION();
22171   }
22172
22173 }
22174
22175
22176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22178   float arg2 ;
22179   float arg3 ;
22180   float arg4 ;
22181
22182   arg1 = (Dali::Actor *)jarg1;
22183   arg2 = (float)jarg2;
22184   arg3 = (float)jarg3;
22185   arg4 = (float)jarg4;
22186   {
22187     try {
22188       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22189     } CALL_CATCH_EXCEPTION();
22190   }
22191
22192 }
22193
22194
22195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22197   Dali::Vector3 *arg2 = 0 ;
22198
22199   arg1 = (Dali::Actor *)jarg1;
22200   arg2 = (Dali::Vector3 *)jarg2;
22201   if (!arg2) {
22202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22203     return ;
22204   }
22205   {
22206     try {
22207       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22208     } CALL_CATCH_EXCEPTION();
22209   }
22210
22211 }
22212
22213
22214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22216   float arg2 ;
22217
22218   arg1 = (Dali::Actor *)jarg1;
22219   arg2 = (float)jarg2;
22220   {
22221     try {
22222       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22223     } CALL_CATCH_EXCEPTION();
22224   }
22225
22226 }
22227
22228
22229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22231   float arg2 ;
22232
22233   arg1 = (Dali::Actor *)jarg1;
22234   arg2 = (float)jarg2;
22235   {
22236     try {
22237       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22238     } CALL_CATCH_EXCEPTION();
22239   }
22240
22241 }
22242
22243
22244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22246   float arg2 ;
22247
22248   arg1 = (Dali::Actor *)jarg1;
22249   arg2 = (float)jarg2;
22250   {
22251     try {
22252       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22253     } CALL_CATCH_EXCEPTION();
22254   }
22255
22256 }
22257
22258
22259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22261   Dali::Vector3 *arg2 = 0 ;
22262
22263   arg1 = (Dali::Actor *)jarg1;
22264   arg2 = (Dali::Vector3 *)jarg2;
22265   if (!arg2) {
22266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22267     return ;
22268   }
22269   {
22270     try {
22271       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22272     } CALL_CATCH_EXCEPTION();
22273   }
22274
22275 }
22276
22277
22278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22279   void * jresult ;
22280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22281   Dali::Vector3 result;
22282
22283   arg1 = (Dali::Actor *)jarg1;
22284   {
22285     try {
22286       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22287     } CALL_CATCH_EXCEPTION(0);
22288   }
22289
22290   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22291   return jresult;
22292 }
22293
22294
22295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22296   void * jresult ;
22297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22298   Dali::Vector3 result;
22299
22300   arg1 = (Dali::Actor *)jarg1;
22301   {
22302     try {
22303       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22304     } CALL_CATCH_EXCEPTION(0);
22305   }
22306
22307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22314   bool arg2 ;
22315
22316   arg1 = (Dali::Actor *)jarg1;
22317   arg2 = jarg2 ? true : false;
22318   {
22319     try {
22320       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22321     } CALL_CATCH_EXCEPTION();
22322   }
22323
22324 }
22325
22326
22327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22328   unsigned int jresult ;
22329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22330   bool result;
22331
22332   arg1 = (Dali::Actor *)jarg1;
22333   {
22334     try {
22335       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22336     } CALL_CATCH_EXCEPTION(0);
22337   }
22338
22339   jresult = result;
22340   return jresult;
22341 }
22342
22343
22344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22346   Dali::Degree *arg2 = 0 ;
22347   Dali::Vector3 *arg3 = 0 ;
22348
22349   arg1 = (Dali::Actor *)jarg1;
22350   arg2 = (Dali::Degree *)jarg2;
22351   if (!arg2) {
22352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22353     return ;
22354   }
22355   arg3 = (Dali::Vector3 *)jarg3;
22356   if (!arg3) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22358     return ;
22359   }
22360   {
22361     try {
22362       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22363     } CALL_CATCH_EXCEPTION();
22364   }
22365
22366 }
22367
22368
22369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22371   Dali::Radian *arg2 = 0 ;
22372   Dali::Vector3 *arg3 = 0 ;
22373
22374   arg1 = (Dali::Actor *)jarg1;
22375   arg2 = (Dali::Radian *)jarg2;
22376   if (!arg2) {
22377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22378     return ;
22379   }
22380   arg3 = (Dali::Vector3 *)jarg3;
22381   if (!arg3) {
22382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22383     return ;
22384   }
22385   {
22386     try {
22387       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22388     } CALL_CATCH_EXCEPTION();
22389   }
22390
22391 }
22392
22393
22394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22396   Dali::Quaternion *arg2 = 0 ;
22397
22398   arg1 = (Dali::Actor *)jarg1;
22399   arg2 = (Dali::Quaternion *)jarg2;
22400   if (!arg2) {
22401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22402     return ;
22403   }
22404   {
22405     try {
22406       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22407     } CALL_CATCH_EXCEPTION();
22408   }
22409
22410 }
22411
22412
22413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22415   Dali::Degree *arg2 = 0 ;
22416   Dali::Vector3 *arg3 = 0 ;
22417
22418   arg1 = (Dali::Actor *)jarg1;
22419   arg2 = (Dali::Degree *)jarg2;
22420   if (!arg2) {
22421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22422     return ;
22423   }
22424   arg3 = (Dali::Vector3 *)jarg3;
22425   if (!arg3) {
22426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22427     return ;
22428   }
22429   {
22430     try {
22431       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22432     } CALL_CATCH_EXCEPTION();
22433   }
22434
22435 }
22436
22437
22438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22439   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22440   Dali::Radian *arg2 = 0 ;
22441   Dali::Vector3 *arg3 = 0 ;
22442
22443   arg1 = (Dali::Actor *)jarg1;
22444   arg2 = (Dali::Radian *)jarg2;
22445   if (!arg2) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22447     return ;
22448   }
22449   arg3 = (Dali::Vector3 *)jarg3;
22450   if (!arg3) {
22451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22452     return ;
22453   }
22454   {
22455     try {
22456       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22457     } CALL_CATCH_EXCEPTION();
22458   }
22459
22460 }
22461
22462
22463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22465   Dali::Quaternion *arg2 = 0 ;
22466
22467   arg1 = (Dali::Actor *)jarg1;
22468   arg2 = (Dali::Quaternion *)jarg2;
22469   if (!arg2) {
22470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22471     return ;
22472   }
22473   {
22474     try {
22475       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22476     } CALL_CATCH_EXCEPTION();
22477   }
22478
22479 }
22480
22481
22482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22483   void * jresult ;
22484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22485   Dali::Quaternion result;
22486
22487   arg1 = (Dali::Actor *)jarg1;
22488   {
22489     try {
22490       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22491     } CALL_CATCH_EXCEPTION(0);
22492   }
22493
22494   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22495   return jresult;
22496 }
22497
22498
22499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22501   bool arg2 ;
22502
22503   arg1 = (Dali::Actor *)jarg1;
22504   arg2 = jarg2 ? true : false;
22505   {
22506     try {
22507       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22508     } CALL_CATCH_EXCEPTION();
22509   }
22510
22511 }
22512
22513
22514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22515   unsigned int jresult ;
22516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22517   bool result;
22518
22519   arg1 = (Dali::Actor *)jarg1;
22520   {
22521     try {
22522       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22523     } CALL_CATCH_EXCEPTION(0);
22524   }
22525
22526   jresult = result;
22527   return jresult;
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22532   void * jresult ;
22533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22534   Dali::Quaternion result;
22535
22536   arg1 = (Dali::Actor *)jarg1;
22537   {
22538     try {
22539       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22540     } CALL_CATCH_EXCEPTION(0);
22541   }
22542
22543   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22544   return jresult;
22545 }
22546
22547
22548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22550   float arg2 ;
22551
22552   arg1 = (Dali::Actor *)jarg1;
22553   arg2 = (float)jarg2;
22554   {
22555     try {
22556       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22557     } CALL_CATCH_EXCEPTION();
22558   }
22559
22560 }
22561
22562
22563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22565   float arg2 ;
22566   float arg3 ;
22567   float arg4 ;
22568
22569   arg1 = (Dali::Actor *)jarg1;
22570   arg2 = (float)jarg2;
22571   arg3 = (float)jarg3;
22572   arg4 = (float)jarg4;
22573   {
22574     try {
22575       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22576     } CALL_CATCH_EXCEPTION();
22577   }
22578
22579 }
22580
22581
22582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
22583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22584   Dali::Vector3 *arg2 = 0 ;
22585
22586   arg1 = (Dali::Actor *)jarg1;
22587   arg2 = (Dali::Vector3 *)jarg2;
22588   if (!arg2) {
22589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22590     return ;
22591   }
22592   {
22593     try {
22594       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22595     } CALL_CATCH_EXCEPTION();
22596   }
22597
22598 }
22599
22600
22601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22602   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22603   Dali::Vector3 *arg2 = 0 ;
22604
22605   arg1 = (Dali::Actor *)jarg1;
22606   arg2 = (Dali::Vector3 *)jarg2;
22607   if (!arg2) {
22608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22609     return ;
22610   }
22611   {
22612     try {
22613       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22614     } CALL_CATCH_EXCEPTION();
22615   }
22616
22617 }
22618
22619
22620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22621   void * jresult ;
22622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22623   Dali::Vector3 result;
22624
22625   arg1 = (Dali::Actor *)jarg1;
22626   {
22627     try {
22628       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22629     } CALL_CATCH_EXCEPTION(0);
22630   }
22631
22632   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22633   return jresult;
22634 }
22635
22636
22637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
22638   void * jresult ;
22639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22640   Dali::Vector3 result;
22641
22642   arg1 = (Dali::Actor *)jarg1;
22643   {
22644     try {
22645       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
22646     } CALL_CATCH_EXCEPTION(0);
22647   }
22648
22649   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22650   return jresult;
22651 }
22652
22653
22654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
22655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22656   bool arg2 ;
22657
22658   arg1 = (Dali::Actor *)jarg1;
22659   arg2 = jarg2 ? true : false;
22660   {
22661     try {
22662       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22663     } CALL_CATCH_EXCEPTION();
22664   }
22665
22666 }
22667
22668
22669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22670   unsigned int jresult ;
22671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22672   bool result;
22673
22674   arg1 = (Dali::Actor *)jarg1;
22675   {
22676     try {
22677       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22678     } CALL_CATCH_EXCEPTION(0);
22679   }
22680
22681   jresult = result;
22682   return jresult;
22683 }
22684
22685
22686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22687   void * jresult ;
22688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22689   Dali::Matrix result;
22690
22691   arg1 = (Dali::Actor *)jarg1;
22692   {
22693     try {
22694       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22695     } CALL_CATCH_EXCEPTION(0);
22696   }
22697
22698   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22699   return jresult;
22700 }
22701
22702
22703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22705   bool arg2 ;
22706
22707   arg1 = (Dali::Actor *)jarg1;
22708   arg2 = jarg2 ? true : false;
22709   {
22710     try {
22711       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22712     } CALL_CATCH_EXCEPTION();
22713   }
22714
22715 }
22716
22717
22718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22719   unsigned int jresult ;
22720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22721   bool result;
22722
22723   arg1 = (Dali::Actor *)jarg1;
22724   {
22725     try {
22726       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22727     } CALL_CATCH_EXCEPTION(0);
22728   }
22729
22730   jresult = result;
22731   return jresult;
22732 }
22733
22734
22735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22736   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22737   float arg2 ;
22738
22739   arg1 = (Dali::Actor *)jarg1;
22740   arg2 = (float)jarg2;
22741   {
22742     try {
22743       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22744     } CALL_CATCH_EXCEPTION();
22745   }
22746
22747 }
22748
22749
22750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22751   float jresult ;
22752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22753   float result;
22754
22755   arg1 = (Dali::Actor *)jarg1;
22756   {
22757     try {
22758       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22759     } CALL_CATCH_EXCEPTION(0);
22760   }
22761
22762   jresult = result;
22763   return jresult;
22764 }
22765
22766
22767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22769   Dali::Vector4 *arg2 = 0 ;
22770
22771   arg1 = (Dali::Actor *)jarg1;
22772   arg2 = (Dali::Vector4 *)jarg2;
22773   if (!arg2) {
22774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22775     return ;
22776   }
22777   {
22778     try {
22779       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22780     } CALL_CATCH_EXCEPTION();
22781   }
22782
22783 }
22784
22785
22786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22787   void * jresult ;
22788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22789   Dali::Vector4 result;
22790
22791   arg1 = (Dali::Actor *)jarg1;
22792   {
22793     try {
22794       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22795     } CALL_CATCH_EXCEPTION(0);
22796   }
22797
22798   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22799   return jresult;
22800 }
22801
22802
22803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22805   Dali::ColorMode arg2 ;
22806
22807   arg1 = (Dali::Actor *)jarg1;
22808   arg2 = (Dali::ColorMode)jarg2;
22809   {
22810     try {
22811       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22812     } CALL_CATCH_EXCEPTION();
22813   }
22814
22815 }
22816
22817
22818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22819   int jresult ;
22820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22821   Dali::ColorMode result;
22822
22823   arg1 = (Dali::Actor *)jarg1;
22824   {
22825     try {
22826       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22827     } CALL_CATCH_EXCEPTION(0);
22828   }
22829
22830   jresult = (int)result;
22831   return jresult;
22832 }
22833
22834
22835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22836   void * jresult ;
22837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22838   Dali::Vector4 result;
22839
22840   arg1 = (Dali::Actor *)jarg1;
22841   {
22842     try {
22843       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22844     } CALL_CATCH_EXCEPTION(0);
22845   }
22846
22847   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22854   Dali::DrawMode::Type arg2 ;
22855
22856   arg1 = (Dali::Actor *)jarg1;
22857   arg2 = (Dali::DrawMode::Type)jarg2;
22858   {
22859     try {
22860       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22861     } CALL_CATCH_EXCEPTION();
22862   }
22863
22864 }
22865
22866
22867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22868   int jresult ;
22869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22870   Dali::DrawMode::Type result;
22871
22872   arg1 = (Dali::Actor *)jarg1;
22873   {
22874     try {
22875       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22876     } CALL_CATCH_EXCEPTION(0);
22877   }
22878
22879   jresult = (int)result;
22880   return jresult;
22881 }
22882
22883
22884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22886   bool arg2 ;
22887
22888   arg1 = (Dali::Actor *)jarg1;
22889   arg2 = jarg2 ? true : false;
22890   {
22891     try {
22892       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22893     } CALL_CATCH_EXCEPTION();
22894   }
22895
22896 }
22897
22898
22899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22900   unsigned int jresult ;
22901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22902   bool result;
22903
22904   arg1 = (Dali::Actor *)jarg1;
22905   {
22906     try {
22907       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22908     } CALL_CATCH_EXCEPTION(0);
22909   }
22910
22911   jresult = result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22917   unsigned int jresult ;
22918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22919   float *arg2 = 0 ;
22920   float *arg3 = 0 ;
22921   float arg4 ;
22922   float arg5 ;
22923   bool result;
22924
22925   arg1 = (Dali::Actor *)jarg1;
22926   arg2 = (float *)jarg2;
22927   arg3 = (float *)jarg3;
22928   arg4 = (float)jarg4;
22929   arg5 = (float)jarg5;
22930   {
22931     try {
22932       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22933     } CALL_CATCH_EXCEPTION(0);
22934   }
22935
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22943   bool arg2 ;
22944
22945   arg1 = (Dali::Actor *)jarg1;
22946   arg2 = jarg2 ? true : false;
22947   {
22948     try {
22949       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22950     } CALL_CATCH_EXCEPTION();
22951   }
22952
22953 }
22954
22955
22956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22957   unsigned int jresult ;
22958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22959   bool result;
22960
22961   arg1 = (Dali::Actor *)jarg1;
22962   {
22963     try {
22964       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22965     } CALL_CATCH_EXCEPTION(0);
22966   }
22967
22968   jresult = result;
22969   return jresult;
22970 }
22971
22972
22973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22975   bool arg2 ;
22976
22977   arg1 = (Dali::Actor *)jarg1;
22978   arg2 = jarg2 ? true : false;
22979   {
22980     try {
22981       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22982     } CALL_CATCH_EXCEPTION();
22983   }
22984
22985 }
22986
22987
22988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22989   unsigned int jresult ;
22990   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22991   bool result;
22992
22993   arg1 = (Dali::Actor *)jarg1;
22994   {
22995     try {
22996       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22997     } CALL_CATCH_EXCEPTION(0);
22998   }
22999
23000   jresult = result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
23006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23007   Dali::ResizePolicy::Type arg2 ;
23008   Dali::Dimension::Type arg3 ;
23009
23010   arg1 = (Dali::Actor *)jarg1;
23011   arg2 = (Dali::ResizePolicy::Type)jarg2;
23012   arg3 = (Dali::Dimension::Type)jarg3;
23013   {
23014     try {
23015       (arg1)->SetResizePolicy(arg2,arg3);
23016     } CALL_CATCH_EXCEPTION();
23017   }
23018
23019 }
23020
23021
23022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
23023   int jresult ;
23024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23025   Dali::Dimension::Type arg2 ;
23026   Dali::ResizePolicy::Type result;
23027
23028   arg1 = (Dali::Actor *)jarg1;
23029   arg2 = (Dali::Dimension::Type)jarg2;
23030   {
23031     try {
23032       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23033     } CALL_CATCH_EXCEPTION(0);
23034   }
23035
23036   jresult = (int)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23043   Dali::SizeScalePolicy::Type arg2 ;
23044
23045   arg1 = (Dali::Actor *)jarg1;
23046   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23047   {
23048     try {
23049       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23050     } CALL_CATCH_EXCEPTION();
23051   }
23052
23053 }
23054
23055
23056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23057   int jresult ;
23058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23059   Dali::SizeScalePolicy::Type result;
23060
23061   arg1 = (Dali::Actor *)jarg1;
23062   {
23063     try {
23064       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23065     } CALL_CATCH_EXCEPTION(0);
23066   }
23067
23068   jresult = (int)result;
23069   return jresult;
23070 }
23071
23072
23073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23074   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23075   Dali::Vector3 *arg2 = 0 ;
23076
23077   arg1 = (Dali::Actor *)jarg1;
23078   arg2 = (Dali::Vector3 *)jarg2;
23079   if (!arg2) {
23080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23081     return ;
23082   }
23083   {
23084     try {
23085       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23086     } CALL_CATCH_EXCEPTION();
23087   }
23088
23089 }
23090
23091
23092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23093   void * jresult ;
23094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23095   Dali::Vector3 result;
23096
23097   arg1 = (Dali::Actor *)jarg1;
23098   {
23099     try {
23100       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23101     } CALL_CATCH_EXCEPTION(0);
23102   }
23103
23104   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23110   float jresult ;
23111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23112   float arg2 ;
23113   float result;
23114
23115   arg1 = (Dali::Actor *)jarg1;
23116   arg2 = (float)jarg2;
23117   {
23118     try {
23119       result = (float)(arg1)->GetHeightForWidth(arg2);
23120     } CALL_CATCH_EXCEPTION(0);
23121   }
23122
23123   jresult = result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23129   float jresult ;
23130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23131   float arg2 ;
23132   float result;
23133
23134   arg1 = (Dali::Actor *)jarg1;
23135   arg2 = (float)jarg2;
23136   {
23137     try {
23138       result = (float)(arg1)->GetWidthForHeight(arg2);
23139     } CALL_CATCH_EXCEPTION(0);
23140   }
23141
23142   jresult = result;
23143   return jresult;
23144 }
23145
23146
23147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23148   float jresult ;
23149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23150   Dali::Dimension::Type arg2 ;
23151   float result;
23152
23153   arg1 = (Dali::Actor *)jarg1;
23154   arg2 = (Dali::Dimension::Type)jarg2;
23155   {
23156     try {
23157       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23158     } CALL_CATCH_EXCEPTION(0);
23159   }
23160
23161   jresult = result;
23162   return jresult;
23163 }
23164
23165
23166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23168   Dali::Padding *arg2 = 0 ;
23169
23170   arg1 = (Dali::Actor *)jarg1;
23171   arg2 = (Dali::Padding *)jarg2;
23172   if (!arg2) {
23173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23174     return ;
23175   }
23176   {
23177     try {
23178       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23179     } CALL_CATCH_EXCEPTION();
23180   }
23181
23182 }
23183
23184
23185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23187   Dali::Padding *arg2 = 0 ;
23188
23189   arg1 = (Dali::Actor *)jarg1;
23190   arg2 = (Dali::Padding *)jarg2;
23191   if (!arg2) {
23192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23193     return ;
23194   }
23195   {
23196     try {
23197       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23198     } CALL_CATCH_EXCEPTION();
23199   }
23200
23201 }
23202
23203
23204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23206   Dali::Vector2 *arg2 = 0 ;
23207
23208   arg1 = (Dali::Actor *)jarg1;
23209   arg2 = (Dali::Vector2 *)jarg2;
23210   if (!arg2) {
23211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23212     return ;
23213   }
23214   {
23215     try {
23216       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23217     } CALL_CATCH_EXCEPTION();
23218   }
23219
23220 }
23221
23222
23223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23224   void * jresult ;
23225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23226   Dali::Vector2 result;
23227
23228   arg1 = (Dali::Actor *)jarg1;
23229   {
23230     try {
23231       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23232     } CALL_CATCH_EXCEPTION(0);
23233   }
23234
23235   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23236   return jresult;
23237 }
23238
23239
23240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23242   Dali::Vector2 *arg2 = 0 ;
23243
23244   arg1 = (Dali::Actor *)jarg1;
23245   arg2 = (Dali::Vector2 *)jarg2;
23246   if (!arg2) {
23247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23248     return ;
23249   }
23250   {
23251     try {
23252       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23253     } CALL_CATCH_EXCEPTION();
23254   }
23255
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23260   void * jresult ;
23261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23262   Dali::Vector2 result;
23263
23264   arg1 = (Dali::Actor *)jarg1;
23265   {
23266     try {
23267       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
23268     } CALL_CATCH_EXCEPTION(0);
23269   }
23270
23271   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23277   int jresult ;
23278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23279   int result;
23280
23281   arg1 = (Dali::Actor *)jarg1;
23282   {
23283     try {
23284       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23285       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23286     } CALL_CATCH_EXCEPTION(0);
23287   }
23288
23289   jresult = result;
23290   return jresult;
23291 }
23292
23293
23294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23295   unsigned int jresult ;
23296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23297   Dali::Renderer *arg2 = 0 ;
23298   unsigned int result;
23299
23300   arg1 = (Dali::Actor *)jarg1;
23301   arg2 = (Dali::Renderer *)jarg2;
23302   if (!arg2) {
23303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23304     return 0;
23305   }
23306   {
23307     try {
23308       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23309     } CALL_CATCH_EXCEPTION(0);
23310   }
23311
23312   jresult = result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23318   unsigned int jresult ;
23319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23320   unsigned int result;
23321
23322   arg1 = (Dali::Actor *)jarg1;
23323   {
23324     try {
23325       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23326     } CALL_CATCH_EXCEPTION(0);
23327   }
23328
23329   jresult = result;
23330   return jresult;
23331 }
23332
23333
23334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23335   void * jresult ;
23336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23337   unsigned int arg2 ;
23338   Dali::Renderer result;
23339
23340   arg1 = (Dali::Actor *)jarg1;
23341   arg2 = (unsigned int)jarg2;
23342   {
23343     try {
23344       result = (arg1)->GetRendererAt(arg2);
23345     } CALL_CATCH_EXCEPTION(0);
23346   }
23347
23348   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23349   return jresult;
23350 }
23351
23352
23353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23355   Dali::Renderer *arg2 = 0 ;
23356
23357   arg1 = (Dali::Actor *)jarg1;
23358   arg2 = (Dali::Renderer *)jarg2;
23359   if (!arg2) {
23360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23361     return ;
23362   }
23363   {
23364     try {
23365       (arg1)->RemoveRenderer(*arg2);
23366     } CALL_CATCH_EXCEPTION();
23367   }
23368
23369 }
23370
23371
23372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23374   unsigned int arg2 ;
23375
23376   arg1 = (Dali::Actor *)jarg1;
23377   arg2 = (unsigned int)jarg2;
23378   {
23379     try {
23380       (arg1)->RemoveRenderer(arg2);
23381     } CALL_CATCH_EXCEPTION();
23382   }
23383
23384 }
23385
23386
23387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23388   void * jresult ;
23389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23390   Dali::Actor::TouchEventSignalType *result = 0 ;
23391
23392   arg1 = (Dali::Actor *)jarg1;
23393   {
23394     try {
23395       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
23396     } CALL_CATCH_EXCEPTION(0);
23397   }
23398
23399   jresult = (void *)result;
23400   return jresult;
23401 }
23402
23403
23404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23405   void * jresult ;
23406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23407   Dali::Actor::HoverSignalType *result = 0 ;
23408
23409   arg1 = (Dali::Actor *)jarg1;
23410   {
23411     try {
23412       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23413     } CALL_CATCH_EXCEPTION(0);
23414   }
23415
23416   jresult = (void *)result;
23417   return jresult;
23418 }
23419
23420
23421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23422   void * jresult ;
23423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23424   Dali::Actor::WheelEventSignalType *result = 0 ;
23425
23426   arg1 = (Dali::Actor *)jarg1;
23427   {
23428     try {
23429       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23430     } CALL_CATCH_EXCEPTION(0);
23431   }
23432
23433   jresult = (void *)result;
23434   return jresult;
23435 }
23436
23437
23438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23439   void * jresult ;
23440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23441   Dali::Actor::OnSceneSignalType *result = 0 ;
23442
23443   arg1 = (Dali::Actor *)jarg1;
23444   {
23445     try {
23446       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23447     } CALL_CATCH_EXCEPTION(0);
23448   }
23449
23450   jresult = (void *)result;
23451   return jresult;
23452 }
23453
23454
23455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23456   void * jresult ;
23457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23458   Dali::Actor::OffSceneSignalType *result = 0 ;
23459
23460   arg1 = (Dali::Actor *)jarg1;
23461   {
23462     try {
23463       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23464     } CALL_CATCH_EXCEPTION(0);
23465   }
23466
23467   jresult = (void *)result;
23468   return jresult;
23469 }
23470
23471
23472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23473   void * jresult ;
23474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23475   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23476
23477   arg1 = (Dali::Actor *)jarg1;
23478   {
23479     try {
23480       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23481     } CALL_CATCH_EXCEPTION(0);
23482   }
23483
23484   jresult = (void *)result;
23485   return jresult;
23486 }
23487
23488
23489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23490   Dali::Actor *arg1 = 0 ;
23491
23492   arg1 = (Dali::Actor *)jarg1;
23493   if (!arg1) {
23494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23495     return ;
23496   }
23497   {
23498     try {
23499       Dali::UnparentAndReset(*arg1);
23500     } CALL_CATCH_EXCEPTION();
23501   }
23502
23503 }
23504
23505
23506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23507   int jresult ;
23508   int result;
23509
23510   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23511   jresult = (int)result;
23512   return jresult;
23513 }
23514
23515
23516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23517   int jresult ;
23518   int result;
23519
23520   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23521   jresult = (int)result;
23522   return jresult;
23523 }
23524
23525
23526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23527   int jresult ;
23528   int result;
23529
23530   result = (int)Dali::Layer::Property::BEHAVIOR;
23531   jresult = (int)result;
23532   return jresult;
23533 }
23534
23535
23536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23537   void * jresult ;
23538   Dali::Layer::Property *result = 0 ;
23539
23540   {
23541     try {
23542       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23543     } CALL_CATCH_EXCEPTION(0);
23544   }
23545
23546   jresult = (void *)result;
23547   return jresult;
23548 }
23549
23550
23551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23552   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23553
23554   arg1 = (Dali::Layer::Property *)jarg1;
23555   {
23556     try {
23557       delete arg1;
23558     } CALL_CATCH_EXCEPTION();
23559   }
23560
23561 }
23562
23563
23564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23565   void * jresult ;
23566   Dali::Layer *result = 0 ;
23567
23568   {
23569     try {
23570       result = (Dali::Layer *)new Dali::Layer();
23571     } CALL_CATCH_EXCEPTION(0);
23572   }
23573
23574   jresult = (void *)result;
23575   return jresult;
23576 }
23577
23578
23579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23580   void * jresult ;
23581   Dali::Layer result;
23582
23583   {
23584     try {
23585       result = Dali::Layer::New();
23586     } CALL_CATCH_EXCEPTION(0);
23587   }
23588
23589   jresult = new Dali::Layer((const Dali::Layer &)result);
23590   return jresult;
23591 }
23592
23593
23594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23595   void * jresult ;
23596   Dali::BaseHandle arg1 ;
23597   Dali::BaseHandle *argp1 ;
23598   Dali::Layer result;
23599
23600   argp1 = (Dali::BaseHandle *)jarg1;
23601   if (!argp1) {
23602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23603     return 0;
23604   }
23605   arg1 = *argp1;
23606   {
23607     try {
23608       result = Dali::Layer::DownCast(arg1);
23609     } CALL_CATCH_EXCEPTION(0);
23610   }
23611
23612   jresult = new Dali::Layer((const Dali::Layer &)result);
23613   return jresult;
23614 }
23615
23616
23617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23618   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23619
23620   arg1 = (Dali::Layer *)jarg1;
23621   {
23622     try {
23623       delete arg1;
23624     } CALL_CATCH_EXCEPTION();
23625   }
23626
23627 }
23628
23629
23630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23631   void * jresult ;
23632   Dali::Layer *arg1 = 0 ;
23633   Dali::Layer *result = 0 ;
23634
23635   arg1 = (Dali::Layer *)jarg1;
23636   if (!arg1) {
23637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23638     return 0;
23639   }
23640   {
23641     try {
23642       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23643     } CALL_CATCH_EXCEPTION(0);
23644   }
23645
23646   jresult = (void *)result;
23647   return jresult;
23648 }
23649
23650
23651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23652   void * jresult ;
23653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23654   Dali::Layer *arg2 = 0 ;
23655   Dali::Layer *result = 0 ;
23656
23657   arg1 = (Dali::Layer *)jarg1;
23658   arg2 = (Dali::Layer *)jarg2;
23659   if (!arg2) {
23660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23661     return 0;
23662   }
23663   {
23664     try {
23665       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23666     } CALL_CATCH_EXCEPTION(0);
23667   }
23668
23669   jresult = (void *)result;
23670   return jresult;
23671 }
23672
23673
23674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23675   unsigned int jresult ;
23676   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23677   unsigned int result;
23678
23679   arg1 = (Dali::Layer *)jarg1;
23680   {
23681     try {
23682       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23683     } CALL_CATCH_EXCEPTION(0);
23684   }
23685
23686   jresult = result;
23687   return jresult;
23688 }
23689
23690
23691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23692   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23693
23694   arg1 = (Dali::Layer *)jarg1;
23695   {
23696     try {
23697       (arg1)->Raise();
23698     } CALL_CATCH_EXCEPTION();
23699   }
23700
23701 }
23702
23703
23704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23705   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23706
23707   arg1 = (Dali::Layer *)jarg1;
23708   {
23709     try {
23710       (arg1)->Lower();
23711     } CALL_CATCH_EXCEPTION();
23712   }
23713
23714 }
23715
23716
23717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23718   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23719   Dali::Layer arg2 ;
23720   Dali::Layer *argp2 ;
23721
23722   arg1 = (Dali::Layer *)jarg1;
23723   argp2 = (Dali::Layer *)jarg2;
23724   if (!argp2) {
23725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23726     return ;
23727   }
23728   arg2 = *argp2;
23729   {
23730     try {
23731       (arg1)->RaiseAbove(arg2);
23732     } CALL_CATCH_EXCEPTION();
23733   }
23734
23735 }
23736
23737
23738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23739   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23740   Dali::Layer arg2 ;
23741   Dali::Layer *argp2 ;
23742
23743   arg1 = (Dali::Layer *)jarg1;
23744   argp2 = (Dali::Layer *)jarg2;
23745   if (!argp2) {
23746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23747     return ;
23748   }
23749   arg2 = *argp2;
23750   {
23751     try {
23752       (arg1)->LowerBelow(arg2);
23753     } CALL_CATCH_EXCEPTION();
23754   }
23755
23756 }
23757
23758
23759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23760   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23761
23762   arg1 = (Dali::Layer *)jarg1;
23763   {
23764     try {
23765       (arg1)->RaiseToTop();
23766     } CALL_CATCH_EXCEPTION();
23767   }
23768
23769 }
23770
23771
23772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23773   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23774
23775   arg1 = (Dali::Layer *)jarg1;
23776   {
23777     try {
23778       (arg1)->LowerToBottom();
23779     } CALL_CATCH_EXCEPTION();
23780   }
23781
23782 }
23783
23784
23785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23786   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23787   Dali::Layer arg2 ;
23788   Dali::Layer *argp2 ;
23789
23790   arg1 = (Dali::Layer *)jarg1;
23791   argp2 = (Dali::Layer *)jarg2;
23792   if (!argp2) {
23793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23794     return ;
23795   }
23796   arg2 = *argp2;
23797   {
23798     try {
23799       (arg1)->MoveAbove(arg2);
23800     } CALL_CATCH_EXCEPTION();
23801   }
23802
23803 }
23804
23805
23806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23807   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23808   Dali::Layer arg2 ;
23809   Dali::Layer *argp2 ;
23810
23811   arg1 = (Dali::Layer *)jarg1;
23812   argp2 = (Dali::Layer *)jarg2;
23813   if (!argp2) {
23814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23815     return ;
23816   }
23817   arg2 = *argp2;
23818   {
23819     try {
23820       (arg1)->MoveBelow(arg2);
23821     } CALL_CATCH_EXCEPTION();
23822   }
23823
23824 }
23825
23826
23827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23828   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23829   Dali::Layer::Behavior arg2 ;
23830
23831   arg1 = (Dali::Layer *)jarg1;
23832   arg2 = (Dali::Layer::Behavior)jarg2;
23833   {
23834     try {
23835       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23836     } CALL_CATCH_EXCEPTION();
23837   }
23838
23839 }
23840
23841
23842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23843   int jresult ;
23844   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23845   Dali::Layer::Behavior result;
23846
23847   arg1 = (Dali::Layer *)jarg1;
23848   {
23849     try {
23850       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23851     } CALL_CATCH_EXCEPTION(0);
23852   }
23853
23854   jresult = (int)result;
23855   return jresult;
23856 }
23857
23858
23859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23860   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23861   bool arg2 ;
23862
23863   arg1 = (Dali::Layer *)jarg1;
23864   arg2 = jarg2 ? true : false;
23865   {
23866     try {
23867       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23868     } CALL_CATCH_EXCEPTION();
23869   }
23870
23871 }
23872
23873
23874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23875   unsigned int jresult ;
23876   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23877   bool result;
23878
23879   arg1 = (Dali::Layer *)jarg1;
23880   {
23881     try {
23882       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23883     } CALL_CATCH_EXCEPTION(0);
23884   }
23885
23886   jresult = result;
23887   return jresult;
23888 }
23889
23890
23891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23892   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23893   int arg2 ;
23894   int arg3 ;
23895   int arg4 ;
23896   int arg5 ;
23897
23898   arg1 = (Dali::Layer *)jarg1;
23899   arg2 = (int)jarg2;
23900   arg3 = (int)jarg3;
23901   arg4 = (int)jarg4;
23902   arg5 = (int)jarg5;
23903   {
23904     try {
23905       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23906     } CALL_CATCH_EXCEPTION();
23907   }
23908
23909 }
23910
23911
23912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23913   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23914   Dali::ClippingBox arg2 ;
23915   Dali::ClippingBox *argp2 ;
23916
23917   arg1 = (Dali::Layer *)jarg1;
23918   argp2 = (Dali::ClippingBox *)jarg2;
23919   if (!argp2) {
23920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23921     return ;
23922   }
23923   arg2 = *argp2;
23924   {
23925     try {
23926       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23927     } CALL_CATCH_EXCEPTION();
23928   }
23929
23930 }
23931
23932
23933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23934   void * jresult ;
23935   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23936   Dali::ClippingBox result;
23937
23938   arg1 = (Dali::Layer *)jarg1;
23939   {
23940     try {
23941       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23942     } CALL_CATCH_EXCEPTION(0);
23943   }
23944
23945   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23946   return jresult;
23947 }
23948
23949
23950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23951   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23952   bool arg2 ;
23953
23954   arg1 = (Dali::Layer *)jarg1;
23955   arg2 = jarg2 ? true : false;
23956   {
23957     try {
23958       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23959     } CALL_CATCH_EXCEPTION();
23960   }
23961
23962 }
23963
23964
23965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23966   unsigned int jresult ;
23967   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23968   bool result;
23969
23970   arg1 = (Dali::Layer *)jarg1;
23971   {
23972     try {
23973       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23974     } CALL_CATCH_EXCEPTION(0);
23975   }
23976
23977   jresult = result;
23978   return jresult;
23979 }
23980
23981
23982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23983   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23984   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23985
23986   arg1 = (Dali::Layer *)jarg1;
23987   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23988   {
23989     try {
23990       (arg1)->SetSortFunction(arg2);
23991     } CALL_CATCH_EXCEPTION();
23992   }
23993
23994 }
23995
23996
23997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23998   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23999   bool arg2 ;
24000
24001   arg1 = (Dali::Layer *)jarg1;
24002   arg2 = jarg2 ? true : false;
24003   {
24004     try {
24005       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
24006     } CALL_CATCH_EXCEPTION();
24007   }
24008
24009 }
24010
24011
24012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
24013   unsigned int jresult ;
24014   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24015   bool result;
24016
24017   arg1 = (Dali::Layer *)jarg1;
24018   {
24019     try {
24020       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
24021     } CALL_CATCH_EXCEPTION(0);
24022   }
24023
24024   jresult = result;
24025   return jresult;
24026 }
24027
24028
24029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
24030   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24031   bool arg2 ;
24032
24033   arg1 = (Dali::Layer *)jarg1;
24034   arg2 = jarg2 ? true : false;
24035   {
24036     try {
24037       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24038     } CALL_CATCH_EXCEPTION();
24039   }
24040
24041 }
24042
24043
24044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24045   unsigned int jresult ;
24046   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24047   bool result;
24048
24049   arg1 = (Dali::Layer *)jarg1;
24050   {
24051     try {
24052       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24053     } CALL_CATCH_EXCEPTION(0);
24054   }
24055
24056   jresult = result;
24057   return jresult;
24058 }
24059
24060
24061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24062   void * jresult ;
24063   Dali::Stage result;
24064
24065   {
24066     try {
24067       result = Dali::Stage::GetCurrent();
24068     } CALL_CATCH_EXCEPTION(0);
24069   }
24070
24071   jresult = new Dali::Stage((const Dali::Stage &)result);
24072   return jresult;
24073 }
24074
24075
24076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24077   unsigned int jresult ;
24078   bool result;
24079
24080   {
24081     try {
24082       result = (bool)Dali::Stage::IsInstalled();
24083     } CALL_CATCH_EXCEPTION(0);
24084   }
24085
24086   jresult = result;
24087   return jresult;
24088 }
24089
24090
24091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24092   void * jresult ;
24093   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24094   Dali::Vector2 result;
24095
24096   arg1 = (Dali::Stage *)jarg1;
24097   {
24098     try {
24099       result = ((Dali::Stage const *)arg1)->GetDpi();
24100     } CALL_CATCH_EXCEPTION(0);
24101   }
24102
24103   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24104   return jresult;
24105 }
24106
24107
24108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24109   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24110   float arg2 ;
24111
24112   arg1 = (Dali::Stage *)jarg1;
24113   arg2 = (float)jarg2;
24114   {
24115     try {
24116       (arg1)->KeepRendering(arg2);
24117     } CALL_CATCH_EXCEPTION();
24118   }
24119
24120 }
24121
24122
24123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24124   void * jresult ;
24125   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24126   Dali::Stage::KeyEventSignalType *result = 0 ;
24127
24128   arg1 = (Dali::Stage *)jarg1;
24129   {
24130     try {
24131       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24132     } CALL_CATCH_EXCEPTION(0);
24133   }
24134
24135   jresult = (void *)result;
24136   return jresult;
24137 }
24138
24139
24140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24141   void * jresult ;
24142   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24143   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24144
24145   arg1 = (Dali::Stage *)jarg1;
24146   {
24147     try {
24148       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24149     } CALL_CATCH_EXCEPTION(0);
24150   }
24151
24152   jresult = (void *)result;
24153   return jresult;
24154 }
24155
24156
24157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24158   void * jresult ;
24159   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24160   Dali::Stage::TouchSignalType *result = 0 ;
24161
24162   arg1 = (Dali::Stage *)jarg1;
24163   {
24164     try {
24165       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
24166     } CALL_CATCH_EXCEPTION(0);
24167   }
24168
24169   jresult = (void *)result;
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24175   void * jresult ;
24176   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24177   Dali::Stage::WheelEventSignalType *result = 0 ;
24178
24179   arg1 = (Dali::Stage *)jarg1;
24180   {
24181     try {
24182       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24183     } CALL_CATCH_EXCEPTION(0);
24184   }
24185
24186   jresult = (void *)result;
24187   return jresult;
24188 }
24189
24190
24191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24192   void * jresult ;
24193   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24194   Dali::Stage::ContextStatusSignal *result = 0 ;
24195
24196   arg1 = (Dali::Stage *)jarg1;
24197   {
24198     try {
24199       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24200     } CALL_CATCH_EXCEPTION(0);
24201   }
24202
24203   jresult = (void *)result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
24209   void * jresult ;
24210   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24211   Dali::Stage::ContextStatusSignal *result = 0 ;
24212
24213   arg1 = (Dali::Stage *)jarg1;
24214   {
24215     try {
24216       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
24217     } CALL_CATCH_EXCEPTION(0);
24218   }
24219
24220   jresult = (void *)result;
24221   return jresult;
24222 }
24223
24224
24225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24226   void * jresult ;
24227   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24228   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24229
24230   arg1 = (Dali::Stage *)jarg1;
24231   {
24232     try {
24233       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24234     } CALL_CATCH_EXCEPTION(0);
24235   }
24236
24237   jresult = (void *)result;
24238   return jresult;
24239 }
24240
24241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24242   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24243   Dali::DevelStage::Rendering arg2 ;
24244
24245   arg1 = (Dali::Stage *)jarg1;
24246   arg2 = (Dali::DevelStage::Rendering)jarg2;
24247   {
24248     try {
24249       DevelStage::SetRenderingBehavior(*arg1,arg2);
24250     } CALL_CATCH_EXCEPTION();
24251   }
24252
24253 }
24254
24255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24256
24257   int jresult ;
24258   int result ;
24259   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24260
24261   arg1 = (Dali::Stage *)jarg1;
24262   {
24263     try {
24264       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24265     } CALL_CATCH_EXCEPTION(0);
24266   }
24267
24268   jresult = result;
24269   return jresult;
24270 }
24271
24272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24273   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24274
24275   arg1 = (Dali::RelayoutContainer *)jarg1;
24276   {
24277     try {
24278       delete arg1;
24279     } CALL_CATCH_EXCEPTION();
24280   }
24281
24282 }
24283
24284
24285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24286   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24287   Dali::Actor *arg2 = 0 ;
24288   Dali::Vector2 *arg3 = 0 ;
24289
24290   arg1 = (Dali::RelayoutContainer *)jarg1;
24291   arg2 = (Dali::Actor *)jarg2;
24292   if (!arg2) {
24293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24294     return ;
24295   }
24296   arg3 = (Dali::Vector2 *)jarg3;
24297   if (!arg3) {
24298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24299     return ;
24300   }
24301   {
24302     try {
24303       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24304     } CALL_CATCH_EXCEPTION();
24305   }
24306
24307 }
24308
24309
24310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24311   void * jresult ;
24312   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24313   Dali::CustomActor result;
24314
24315   arg1 = (Dali::CustomActorImpl *)jarg1;
24316   {
24317     try {
24318       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24319     } CALL_CATCH_EXCEPTION(0);
24320   }
24321
24322   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24323   return jresult;
24324 }
24325
24326
24327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24328   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24329   int arg2 ;
24330
24331   arg1 = (Dali::CustomActorImpl *)jarg1;
24332   arg2 = (int)jarg2;
24333   {
24334     try {
24335       (arg1)->OnSceneConnection(arg2);
24336     } CALL_CATCH_EXCEPTION();
24337   }
24338
24339 }
24340
24341
24342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24344
24345   arg1 = (Dali::CustomActorImpl *)jarg1;
24346   {
24347     try {
24348       (arg1)->OnSceneDisconnection();
24349     } CALL_CATCH_EXCEPTION();
24350   }
24351
24352 }
24353
24354
24355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
24356   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24357   Dali::Actor *arg2 = 0 ;
24358
24359   arg1 = (Dali::CustomActorImpl *)jarg1;
24360   arg2 = (Dali::Actor *)jarg2;
24361   if (!arg2) {
24362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24363     return ;
24364   }
24365   {
24366     try {
24367       (arg1)->OnChildAdd(*arg2);
24368     } CALL_CATCH_EXCEPTION();
24369   }
24370
24371 }
24372
24373
24374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24375   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24376   Dali::Actor *arg2 = 0 ;
24377
24378   arg1 = (Dali::CustomActorImpl *)jarg1;
24379   arg2 = (Dali::Actor *)jarg2;
24380   if (!arg2) {
24381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24382     return ;
24383   }
24384   {
24385     try {
24386       (arg1)->OnChildRemove(*arg2);
24387     } CALL_CATCH_EXCEPTION();
24388   }
24389
24390 }
24391
24392
24393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24394   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24395   Dali::Property::Index arg2 ;
24396   Dali::Property::Value arg3 ;
24397   Dali::Property::Value *argp3 ;
24398
24399   arg1 = (Dali::CustomActorImpl *)jarg1;
24400   arg2 = (Dali::Property::Index)jarg2;
24401   argp3 = (Dali::Property::Value *)jarg3;
24402   if (!argp3) {
24403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24404     return ;
24405   }
24406   arg3 = *argp3;
24407   {
24408     try {
24409       (arg1)->OnPropertySet(arg2,arg3);
24410     } CALL_CATCH_EXCEPTION();
24411   }
24412
24413 }
24414
24415
24416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24417   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24418   Dali::Vector3 *arg2 = 0 ;
24419
24420   arg1 = (Dali::CustomActorImpl *)jarg1;
24421   arg2 = (Dali::Vector3 *)jarg2;
24422   if (!arg2) {
24423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24424     return ;
24425   }
24426   {
24427     try {
24428       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24429     } CALL_CATCH_EXCEPTION();
24430   }
24431
24432 }
24433
24434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24435   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24436   Dali::Animation *arg2 = 0 ;
24437   Dali::Vector3 *arg3 = 0 ;
24438
24439   arg1 = (Dali::CustomActorImpl *)jarg1;
24440   arg2 = (Dali::Animation *)jarg2;
24441   if (!arg2) {
24442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24443     return ;
24444   }
24445   arg3 = (Dali::Vector3 *)jarg3;
24446   if (!arg3) {
24447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24448     return ;
24449   }
24450   {
24451     try {
24452       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24453     } CALL_CATCH_EXCEPTION();
24454   }
24455 }
24456
24457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
24458   unsigned int jresult ;
24459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24460   Dali::HoverEvent *arg2 = 0 ;
24461   bool result;
24462
24463   arg1 = (Dali::CustomActorImpl *)jarg1;
24464   arg2 = (Dali::HoverEvent *)jarg2;
24465   if (!arg2) {
24466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
24467     return 0;
24468   }
24469   {
24470     try {
24471       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
24472     } CALL_CATCH_EXCEPTION(0);
24473   }
24474
24475   jresult = result;
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
24481   unsigned int jresult ;
24482   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24483   Dali::KeyEvent *arg2 = 0 ;
24484   bool result;
24485
24486   arg1 = (Dali::CustomActorImpl *)jarg1;
24487   arg2 = (Dali::KeyEvent *)jarg2;
24488   if (!arg2) {
24489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24490     return 0;
24491   }
24492   {
24493     try {
24494       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
24495     } CALL_CATCH_EXCEPTION(0);
24496   }
24497
24498   jresult = result;
24499   return jresult;
24500 }
24501
24502
24503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
24504   unsigned int jresult ;
24505   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24506   Dali::WheelEvent *arg2 = 0 ;
24507   bool result;
24508
24509   arg1 = (Dali::CustomActorImpl *)jarg1;
24510   arg2 = (Dali::WheelEvent *)jarg2;
24511   if (!arg2) {
24512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24513     return 0;
24514   }
24515   {
24516     try {
24517       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
24518     } CALL_CATCH_EXCEPTION(0);
24519   }
24520
24521   jresult = result;
24522   return jresult;
24523 }
24524
24525
24526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24527   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24528   Dali::Vector2 *arg2 = 0 ;
24529   Dali::RelayoutContainer *arg3 = 0 ;
24530
24531   arg1 = (Dali::CustomActorImpl *)jarg1;
24532   arg2 = (Dali::Vector2 *)jarg2;
24533   if (!arg2) {
24534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24535     return ;
24536   }
24537   arg3 = (Dali::RelayoutContainer *)jarg3;
24538   if (!arg3) {
24539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24540     return ;
24541   }
24542   {
24543     try {
24544       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24545     } CALL_CATCH_EXCEPTION();
24546   }
24547
24548 }
24549
24550
24551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24552   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24553   Dali::ResizePolicy::Type arg2 ;
24554   Dali::Dimension::Type arg3 ;
24555
24556   arg1 = (Dali::CustomActorImpl *)jarg1;
24557   arg2 = (Dali::ResizePolicy::Type)jarg2;
24558   arg3 = (Dali::Dimension::Type)jarg3;
24559   {
24560     try {
24561       (arg1)->OnSetResizePolicy(arg2,arg3);
24562     } CALL_CATCH_EXCEPTION();
24563   }
24564
24565 }
24566
24567
24568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24569   void * jresult ;
24570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24571   Dali::Vector3 result;
24572
24573   arg1 = (Dali::CustomActorImpl *)jarg1;
24574   {
24575     try {
24576       result = (arg1)->GetNaturalSize();
24577     } CALL_CATCH_EXCEPTION(0);
24578   }
24579
24580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24581   return jresult;
24582 }
24583
24584
24585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24586   float jresult ;
24587   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24588   Dali::Actor *arg2 = 0 ;
24589   Dali::Dimension::Type arg3 ;
24590   float result;
24591
24592   arg1 = (Dali::CustomActorImpl *)jarg1;
24593   arg2 = (Dali::Actor *)jarg2;
24594   if (!arg2) {
24595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24596     return 0;
24597   }
24598   arg3 = (Dali::Dimension::Type)jarg3;
24599   {
24600     try {
24601       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24602     } CALL_CATCH_EXCEPTION(0);
24603   }
24604
24605   jresult = result;
24606   return jresult;
24607 }
24608
24609
24610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24611   float jresult ;
24612   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24613   float arg2 ;
24614   float result;
24615
24616   arg1 = (Dali::CustomActorImpl *)jarg1;
24617   arg2 = (float)jarg2;
24618   {
24619     try {
24620       result = (float)(arg1)->GetHeightForWidth(arg2);
24621     } CALL_CATCH_EXCEPTION(0);
24622   }
24623
24624   jresult = result;
24625   return jresult;
24626 }
24627
24628
24629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24630   float jresult ;
24631   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24632   float arg2 ;
24633   float result;
24634
24635   arg1 = (Dali::CustomActorImpl *)jarg1;
24636   arg2 = (float)jarg2;
24637   {
24638     try {
24639       result = (float)(arg1)->GetWidthForHeight(arg2);
24640     } CALL_CATCH_EXCEPTION(0);
24641   }
24642
24643   jresult = result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24649   unsigned int jresult ;
24650   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24651   Dali::Dimension::Type arg2 ;
24652   bool result;
24653
24654   arg1 = (Dali::CustomActorImpl *)jarg1;
24655   arg2 = (Dali::Dimension::Type)jarg2;
24656   {
24657     try {
24658       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24659     } CALL_CATCH_EXCEPTION(0);
24660   }
24661
24662   jresult = result;
24663   return jresult;
24664 }
24665
24666
24667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24668   unsigned int jresult ;
24669   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24670   bool result;
24671
24672   arg1 = (Dali::CustomActorImpl *)jarg1;
24673   {
24674     try {
24675       result = (bool)(arg1)->RelayoutDependentOnChildren();
24676     } CALL_CATCH_EXCEPTION(0);
24677   }
24678
24679   jresult = result;
24680   return jresult;
24681 }
24682
24683
24684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24686   Dali::Dimension::Type arg2 ;
24687
24688   arg1 = (Dali::CustomActorImpl *)jarg1;
24689   arg2 = (Dali::Dimension::Type)jarg2;
24690   {
24691     try {
24692       (arg1)->OnCalculateRelayoutSize(arg2);
24693     } CALL_CATCH_EXCEPTION();
24694   }
24695
24696 }
24697
24698
24699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24700   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24701   float arg2 ;
24702   Dali::Dimension::Type arg3 ;
24703
24704   arg1 = (Dali::CustomActorImpl *)jarg1;
24705   arg2 = (float)jarg2;
24706   arg3 = (Dali::Dimension::Type)jarg3;
24707   {
24708     try {
24709       (arg1)->OnLayoutNegotiated(arg2,arg3);
24710     } CALL_CATCH_EXCEPTION();
24711   }
24712
24713 }
24714
24715
24716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
24717   unsigned int jresult ;
24718   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24719   bool result;
24720
24721   arg1 = (Dali::CustomActorImpl *)jarg1;
24722   {
24723     try {
24724       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
24725     } CALL_CATCH_EXCEPTION(0);
24726   }
24727
24728   jresult = result;
24729   return jresult;
24730 }
24731
24732
24733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
24734   unsigned int jresult ;
24735   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24736   bool result;
24737
24738   arg1 = (Dali::CustomActorImpl *)jarg1;
24739   {
24740     try {
24741       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
24742     } CALL_CATCH_EXCEPTION(0);
24743   }
24744
24745   jresult = result;
24746   return jresult;
24747 }
24748
24749
24750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
24751   unsigned int jresult ;
24752   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24753   bool result;
24754
24755   arg1 = (Dali::CustomActorImpl *)jarg1;
24756   {
24757     try {
24758       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
24759     } CALL_CATCH_EXCEPTION(0);
24760   }
24761
24762   jresult = result;
24763   return jresult;
24764 }
24765
24766
24767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
24768   unsigned int jresult ;
24769   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24770   bool result;
24771
24772   arg1 = (Dali::CustomActorImpl *)jarg1;
24773   {
24774     try {
24775       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
24776     } CALL_CATCH_EXCEPTION(0);
24777   }
24778
24779   jresult = result;
24780   return jresult;
24781 }
24782
24783
24784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24785   void * jresult ;
24786   Dali::CustomActor *result = 0 ;
24787
24788   {
24789     try {
24790       result = (Dali::CustomActor *)new Dali::CustomActor();
24791     } CALL_CATCH_EXCEPTION(0);
24792   }
24793
24794   jresult = (void *)result;
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24800   void * jresult ;
24801   Dali::BaseHandle arg1 ;
24802   Dali::BaseHandle *argp1 ;
24803   Dali::CustomActor result;
24804
24805   argp1 = (Dali::BaseHandle *)jarg1;
24806   if (!argp1) {
24807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24808     return 0;
24809   }
24810   arg1 = *argp1;
24811   {
24812     try {
24813       result = Dali::CustomActor::DownCast(arg1);
24814     } CALL_CATCH_EXCEPTION(0);
24815   }
24816
24817   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24818   return jresult;
24819 }
24820
24821
24822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24823   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24824
24825   arg1 = (Dali::CustomActor *)jarg1;
24826   {
24827     try {
24828       delete arg1;
24829     } CALL_CATCH_EXCEPTION();
24830   }
24831
24832 }
24833
24834
24835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24836   void * jresult ;
24837   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24838   Dali::CustomActorImpl *result = 0 ;
24839
24840   arg1 = (Dali::CustomActor *)jarg1;
24841   {
24842     try {
24843       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24844     } CALL_CATCH_EXCEPTION(0);
24845   }
24846
24847   jresult = (void *)result;
24848   return jresult;
24849 }
24850
24851
24852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24853   void * jresult ;
24854   Dali::CustomActorImpl *arg1 = 0 ;
24855   Dali::CustomActor *result = 0 ;
24856
24857   arg1 = (Dali::CustomActorImpl *)jarg1;
24858   if (!arg1) {
24859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24860     return 0;
24861   }
24862   {
24863     try {
24864       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24865     } CALL_CATCH_EXCEPTION(0);
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24874   void * jresult ;
24875   Dali::CustomActor *arg1 = 0 ;
24876   Dali::CustomActor *result = 0 ;
24877
24878   arg1 = (Dali::CustomActor *)jarg1;
24879   if (!arg1) {
24880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24881     return 0;
24882   }
24883   {
24884     try {
24885       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24886     } CALL_CATCH_EXCEPTION(0);
24887   }
24888
24889   jresult = (void *)result;
24890   return jresult;
24891 }
24892
24893
24894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24895   void * jresult ;
24896   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24897   Dali::CustomActor *arg2 = 0 ;
24898   Dali::CustomActor *result = 0 ;
24899
24900   arg1 = (Dali::CustomActor *)jarg1;
24901   arg2 = (Dali::CustomActor *)jarg2;
24902   if (!arg2) {
24903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24904     return 0;
24905   }
24906   {
24907     try {
24908       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24909     } CALL_CATCH_EXCEPTION(0);
24910   }
24911
24912   jresult = (void *)result;
24913   return jresult;
24914 }
24915
24916
24917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24918   int jresult ;
24919   int result;
24920
24921   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24922   jresult = (int)result;
24923   return jresult;
24924 }
24925
24926
24927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24928   int jresult ;
24929   int result;
24930
24931   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24932   jresult = (int)result;
24933   return jresult;
24934 }
24935
24936
24937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24938   int jresult ;
24939   int result;
24940
24941   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24942   jresult = (int)result;
24943   return jresult;
24944 }
24945
24946
24947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24948   int jresult ;
24949   int result;
24950
24951   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24952   jresult = (int)result;
24953   return jresult;
24954 }
24955
24956
24957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24958   int jresult ;
24959   int result;
24960
24961   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24962   jresult = (int)result;
24963   return jresult;
24964 }
24965
24966
24967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24968   int jresult ;
24969   int result;
24970
24971   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24972   jresult = (int)result;
24973   return jresult;
24974 }
24975
24976
24977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24978   int jresult ;
24979   int result;
24980
24981   result = (int)Dali::PanGestureDetector::Property::PANNING;
24982   jresult = (int)result;
24983   return jresult;
24984 }
24985
24986
24987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24988   void * jresult ;
24989   Dali::PanGestureDetector::Property *result = 0 ;
24990
24991   {
24992     try {
24993       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24994     } CALL_CATCH_EXCEPTION(0);
24995   }
24996
24997   jresult = (void *)result;
24998   return jresult;
24999 }
25000
25001
25002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
25003   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
25004
25005   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
25006   {
25007     try {
25008       delete arg1;
25009     } CALL_CATCH_EXCEPTION();
25010   }
25011
25012 }
25013
25014
25015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
25016   void * jresult ;
25017   Dali::Radian *result = 0 ;
25018
25019   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
25020   jresult = (void *)result;
25021   return jresult;
25022 }
25023
25024
25025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
25026   void * jresult ;
25027   Dali::Radian *result = 0 ;
25028
25029   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
25030   jresult = (void *)result;
25031   return jresult;
25032 }
25033
25034
25035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
25036   void * jresult ;
25037   Dali::Radian *result = 0 ;
25038
25039   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
25040   jresult = (void *)result;
25041   return jresult;
25042 }
25043
25044
25045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
25046   void * jresult ;
25047   Dali::Radian *result = 0 ;
25048
25049   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
25050   jresult = (void *)result;
25051   return jresult;
25052 }
25053
25054
25055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
25056   void * jresult ;
25057   Dali::Radian *result = 0 ;
25058
25059   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
25060   jresult = (void *)result;
25061   return jresult;
25062 }
25063
25064
25065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
25066   void * jresult ;
25067   Dali::Radian *result = 0 ;
25068
25069   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
25070   jresult = (void *)result;
25071   return jresult;
25072 }
25073
25074
25075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
25076   void * jresult ;
25077   Dali::Radian *result = 0 ;
25078
25079   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
25080   jresult = (void *)result;
25081   return jresult;
25082 }
25083
25084
25085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
25086   void * jresult ;
25087   Dali::PanGestureDetector *result = 0 ;
25088
25089   {
25090     try {
25091       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
25092     } CALL_CATCH_EXCEPTION(0);
25093   }
25094
25095   jresult = (void *)result;
25096   return jresult;
25097 }
25098
25099
25100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
25101   void * jresult ;
25102   Dali::PanGestureDetector result;
25103
25104   {
25105     try {
25106       result = Dali::PanGestureDetector::New();
25107     } CALL_CATCH_EXCEPTION(0);
25108   }
25109
25110   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25111   return jresult;
25112 }
25113
25114
25115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
25116   void * jresult ;
25117   Dali::BaseHandle arg1 ;
25118   Dali::BaseHandle *argp1 ;
25119   Dali::PanGestureDetector result;
25120
25121   argp1 = (Dali::BaseHandle *)jarg1;
25122   if (!argp1) {
25123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25124     return 0;
25125   }
25126   arg1 = *argp1;
25127   {
25128     try {
25129       result = Dali::PanGestureDetector::DownCast(arg1);
25130     } CALL_CATCH_EXCEPTION(0);
25131   }
25132
25133   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25134   return jresult;
25135 }
25136
25137
25138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25139   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25140
25141   arg1 = (Dali::PanGestureDetector *)jarg1;
25142   {
25143     try {
25144       delete arg1;
25145     } CALL_CATCH_EXCEPTION();
25146   }
25147
25148 }
25149
25150
25151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25152   void * jresult ;
25153   Dali::PanGestureDetector *arg1 = 0 ;
25154   Dali::PanGestureDetector *result = 0 ;
25155
25156   arg1 = (Dali::PanGestureDetector *)jarg1;
25157   if (!arg1) {
25158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25159     return 0;
25160   }
25161   {
25162     try {
25163       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25164     } CALL_CATCH_EXCEPTION(0);
25165   }
25166
25167   jresult = (void *)result;
25168   return jresult;
25169 }
25170
25171
25172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25173   void * jresult ;
25174   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25175   Dali::PanGestureDetector *arg2 = 0 ;
25176   Dali::PanGestureDetector *result = 0 ;
25177
25178   arg1 = (Dali::PanGestureDetector *)jarg1;
25179   arg2 = (Dali::PanGestureDetector *)jarg2;
25180   if (!arg2) {
25181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25182     return 0;
25183   }
25184   {
25185     try {
25186       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25187     } CALL_CATCH_EXCEPTION(0);
25188   }
25189
25190   jresult = (void *)result;
25191   return jresult;
25192 }
25193
25194
25195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25196   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25197   unsigned int arg2 ;
25198
25199   arg1 = (Dali::PanGestureDetector *)jarg1;
25200   arg2 = (unsigned int)jarg2;
25201   {
25202     try {
25203       (arg1)->SetMinimumTouchesRequired(arg2);
25204     } CALL_CATCH_EXCEPTION();
25205   }
25206
25207 }
25208
25209
25210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25211   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25212   unsigned int arg2 ;
25213
25214   arg1 = (Dali::PanGestureDetector *)jarg1;
25215   arg2 = (unsigned int)jarg2;
25216   {
25217     try {
25218       (arg1)->SetMaximumTouchesRequired(arg2);
25219     } CALL_CATCH_EXCEPTION();
25220   }
25221
25222 }
25223
25224
25225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25226   unsigned int jresult ;
25227   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25228   unsigned int result;
25229
25230   arg1 = (Dali::PanGestureDetector *)jarg1;
25231   {
25232     try {
25233       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25234     } CALL_CATCH_EXCEPTION(0);
25235   }
25236
25237   jresult = result;
25238   return jresult;
25239 }
25240
25241
25242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25243   unsigned int jresult ;
25244   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25245   unsigned int result;
25246
25247   arg1 = (Dali::PanGestureDetector *)jarg1;
25248   {
25249     try {
25250       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25251     } CALL_CATCH_EXCEPTION(0);
25252   }
25253
25254   jresult = result;
25255   return jresult;
25256 }
25257
25258
25259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25260   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25261   Dali::Radian arg2 ;
25262   Dali::Radian arg3 ;
25263   Dali::Radian *argp2 ;
25264   Dali::Radian *argp3 ;
25265
25266   arg1 = (Dali::PanGestureDetector *)jarg1;
25267   argp2 = (Dali::Radian *)jarg2;
25268   if (!argp2) {
25269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25270     return ;
25271   }
25272   arg2 = *argp2;
25273   argp3 = (Dali::Radian *)jarg3;
25274   if (!argp3) {
25275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25276     return ;
25277   }
25278   arg3 = *argp3;
25279   {
25280     try {
25281       (arg1)->AddAngle(arg2,arg3);
25282     } CALL_CATCH_EXCEPTION();
25283   }
25284
25285 }
25286
25287
25288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25289   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25290   Dali::Radian arg2 ;
25291   Dali::Radian *argp2 ;
25292
25293   arg1 = (Dali::PanGestureDetector *)jarg1;
25294   argp2 = (Dali::Radian *)jarg2;
25295   if (!argp2) {
25296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25297     return ;
25298   }
25299   arg2 = *argp2;
25300   {
25301     try {
25302       (arg1)->AddAngle(arg2);
25303     } CALL_CATCH_EXCEPTION();
25304   }
25305
25306 }
25307
25308
25309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25310   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25311   Dali::Radian arg2 ;
25312   Dali::Radian arg3 ;
25313   Dali::Radian *argp2 ;
25314   Dali::Radian *argp3 ;
25315
25316   arg1 = (Dali::PanGestureDetector *)jarg1;
25317   argp2 = (Dali::Radian *)jarg2;
25318   if (!argp2) {
25319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25320     return ;
25321   }
25322   arg2 = *argp2;
25323   argp3 = (Dali::Radian *)jarg3;
25324   if (!argp3) {
25325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25326     return ;
25327   }
25328   arg3 = *argp3;
25329   {
25330     try {
25331       (arg1)->AddDirection(arg2,arg3);
25332     } CALL_CATCH_EXCEPTION();
25333   }
25334
25335 }
25336
25337
25338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25339   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25340   Dali::Radian arg2 ;
25341   Dali::Radian *argp2 ;
25342
25343   arg1 = (Dali::PanGestureDetector *)jarg1;
25344   argp2 = (Dali::Radian *)jarg2;
25345   if (!argp2) {
25346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25347     return ;
25348   }
25349   arg2 = *argp2;
25350   {
25351     try {
25352       (arg1)->AddDirection(arg2);
25353     } CALL_CATCH_EXCEPTION();
25354   }
25355
25356 }
25357
25358
25359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25360   unsigned long jresult ;
25361   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25362   size_t result;
25363
25364   arg1 = (Dali::PanGestureDetector *)jarg1;
25365   {
25366     try {
25367       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25368     } CALL_CATCH_EXCEPTION(0);
25369   }
25370
25371   jresult = (unsigned long)result;
25372   return jresult;
25373 }
25374
25375
25376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25377   void * jresult ;
25378   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25379   size_t arg2 ;
25380   Dali::PanGestureDetector::AngleThresholdPair result;
25381
25382   arg1 = (Dali::PanGestureDetector *)jarg1;
25383   arg2 = (size_t)jarg2;
25384   {
25385     try {
25386       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25387     } CALL_CATCH_EXCEPTION(0);
25388   }
25389
25390   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25391   return jresult;
25392 }
25393
25394
25395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25396   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25397
25398   arg1 = (Dali::PanGestureDetector *)jarg1;
25399   {
25400     try {
25401       (arg1)->ClearAngles();
25402     } CALL_CATCH_EXCEPTION();
25403   }
25404
25405 }
25406
25407
25408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25409   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25410   Dali::Radian arg2 ;
25411   Dali::Radian *argp2 ;
25412
25413   arg1 = (Dali::PanGestureDetector *)jarg1;
25414   argp2 = (Dali::Radian *)jarg2;
25415   if (!argp2) {
25416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25417     return ;
25418   }
25419   arg2 = *argp2;
25420   {
25421     try {
25422       (arg1)->RemoveAngle(arg2);
25423     } CALL_CATCH_EXCEPTION();
25424   }
25425
25426 }
25427
25428
25429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25430   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25431   Dali::Radian arg2 ;
25432   Dali::Radian *argp2 ;
25433
25434   arg1 = (Dali::PanGestureDetector *)jarg1;
25435   argp2 = (Dali::Radian *)jarg2;
25436   if (!argp2) {
25437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25438     return ;
25439   }
25440   arg2 = *argp2;
25441   {
25442     try {
25443       (arg1)->RemoveDirection(arg2);
25444     } CALL_CATCH_EXCEPTION();
25445   }
25446
25447 }
25448
25449
25450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25451   void * jresult ;
25452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25453   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25454
25455   arg1 = (Dali::PanGestureDetector *)jarg1;
25456   {
25457     try {
25458       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25459     } CALL_CATCH_EXCEPTION(0);
25460   }
25461
25462   jresult = (void *)result;
25463   return jresult;
25464 }
25465
25466
25467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25468   Dali::PanGesture *arg1 = 0 ;
25469
25470   arg1 = (Dali::PanGesture *)jarg1;
25471   if (!arg1) {
25472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25473     return ;
25474   }
25475   {
25476     try {
25477       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25478     } CALL_CATCH_EXCEPTION();
25479   }
25480
25481 }
25482
25483
25484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25485   void * jresult ;
25486   Dali::PanGesture *result = 0 ;
25487
25488   {
25489     try {
25490       result = (Dali::PanGesture *)new Dali::PanGesture();
25491     } CALL_CATCH_EXCEPTION(0);
25492   }
25493
25494   jresult = (void *)result;
25495   return jresult;
25496 }
25497
25498
25499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25500   void * jresult ;
25501   Dali::Gesture::State arg1 ;
25502   Dali::PanGesture *result = 0 ;
25503
25504   arg1 = (Dali::Gesture::State)jarg1;
25505   {
25506     try {
25507       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
25508     } CALL_CATCH_EXCEPTION(0);
25509   }
25510
25511   jresult = (void *)result;
25512   return jresult;
25513 }
25514
25515
25516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25517   void * jresult ;
25518   Dali::PanGesture *arg1 = 0 ;
25519   Dali::PanGesture *result = 0 ;
25520
25521   arg1 = (Dali::PanGesture *)jarg1;
25522   if (!arg1) {
25523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25524     return 0;
25525   }
25526   {
25527     try {
25528       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25529     } CALL_CATCH_EXCEPTION(0);
25530   }
25531
25532   jresult = (void *)result;
25533   return jresult;
25534 }
25535
25536
25537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25538   void * jresult ;
25539   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25540   Dali::PanGesture *arg2 = 0 ;
25541   Dali::PanGesture *result = 0 ;
25542
25543   arg1 = (Dali::PanGesture *)jarg1;
25544   arg2 = (Dali::PanGesture *)jarg2;
25545   if (!arg2) {
25546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25547     return 0;
25548   }
25549   {
25550     try {
25551       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25552     } CALL_CATCH_EXCEPTION(0);
25553   }
25554
25555   jresult = (void *)result;
25556   return jresult;
25557 }
25558
25559
25560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25561   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25562
25563   arg1 = (Dali::PanGesture *)jarg1;
25564   {
25565     try {
25566       delete arg1;
25567     } CALL_CATCH_EXCEPTION();
25568   }
25569
25570 }
25571
25572
25573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
25574   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25575   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25576
25577   arg1 = (Dali::PanGesture *)jarg1;
25578   arg2 = (Dali::Vector2 *)jarg2;
25579   if (arg1) (arg1)->velocity = *arg2;
25580 }
25581
25582
25583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25584   void * jresult ;
25585   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25586   Dali::Vector2 *result = 0 ;
25587
25588   arg1 = (Dali::PanGesture *)jarg1;
25589   result = (Dali::Vector2 *)& ((arg1)->velocity);
25590   jresult = (void *)result;
25591   return jresult;
25592 }
25593
25594
25595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
25596   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25597   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25598
25599   arg1 = (Dali::PanGesture *)jarg1;
25600   arg2 = (Dali::Vector2 *)jarg2;
25601   if (arg1) (arg1)->displacement = *arg2;
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25606   void * jresult ;
25607   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25608   Dali::Vector2 *result = 0 ;
25609
25610   arg1 = (Dali::PanGesture *)jarg1;
25611   result = (Dali::Vector2 *)& ((arg1)->displacement);
25612   jresult = (void *)result;
25613   return jresult;
25614 }
25615
25616
25617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
25618   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25619   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25620
25621   arg1 = (Dali::PanGesture *)jarg1;
25622   arg2 = (Dali::Vector2 *)jarg2;
25623   if (arg1) (arg1)->position = *arg2;
25624 }
25625
25626
25627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25628   void * jresult ;
25629   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25630   Dali::Vector2 *result = 0 ;
25631
25632   arg1 = (Dali::PanGesture *)jarg1;
25633   result = (Dali::Vector2 *)& ((arg1)->position);
25634   jresult = (void *)result;
25635   return jresult;
25636 }
25637
25638
25639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
25640   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25641   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25642
25643   arg1 = (Dali::PanGesture *)jarg1;
25644   arg2 = (Dali::Vector2 *)jarg2;
25645   if (arg1) (arg1)->screenVelocity = *arg2;
25646 }
25647
25648
25649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25650   void * jresult ;
25651   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25652   Dali::Vector2 *result = 0 ;
25653
25654   arg1 = (Dali::PanGesture *)jarg1;
25655   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
25656   jresult = (void *)result;
25657   return jresult;
25658 }
25659
25660
25661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
25662   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25663   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25664
25665   arg1 = (Dali::PanGesture *)jarg1;
25666   arg2 = (Dali::Vector2 *)jarg2;
25667   if (arg1) (arg1)->screenDisplacement = *arg2;
25668 }
25669
25670
25671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25672   void * jresult ;
25673   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25674   Dali::Vector2 *result = 0 ;
25675
25676   arg1 = (Dali::PanGesture *)jarg1;
25677   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
25678   jresult = (void *)result;
25679   return jresult;
25680 }
25681
25682
25683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
25684   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25685   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25686
25687   arg1 = (Dali::PanGesture *)jarg1;
25688   arg2 = (Dali::Vector2 *)jarg2;
25689   if (arg1) (arg1)->screenPosition = *arg2;
25690 }
25691
25692
25693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25694   void * jresult ;
25695   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25696   Dali::Vector2 *result = 0 ;
25697
25698   arg1 = (Dali::PanGesture *)jarg1;
25699   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
25700   jresult = (void *)result;
25701   return jresult;
25702 }
25703
25704
25705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
25706   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25707   unsigned int arg2 ;
25708
25709   arg1 = (Dali::PanGesture *)jarg1;
25710   arg2 = (unsigned int)jarg2;
25711   if (arg1) (arg1)->numberOfTouches = arg2;
25712 }
25713
25714
25715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25716   unsigned int jresult ;
25717   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25718   unsigned int result;
25719
25720   arg1 = (Dali::PanGesture *)jarg1;
25721   result = (unsigned int) ((arg1)->numberOfTouches);
25722   jresult = result;
25723   return jresult;
25724 }
25725
25726
25727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25728   float jresult ;
25729   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25730   float result;
25731
25732   arg1 = (Dali::PanGesture *)jarg1;
25733   {
25734     try {
25735       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25736     } CALL_CATCH_EXCEPTION(0);
25737   }
25738
25739   jresult = result;
25740   return jresult;
25741 }
25742
25743
25744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
25745   float jresult ;
25746   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25747   float result;
25748
25749   arg1 = (Dali::PanGesture *)jarg1;
25750   {
25751     try {
25752       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
25753     } CALL_CATCH_EXCEPTION(0);
25754   }
25755
25756   jresult = result;
25757   return jresult;
25758 }
25759
25760
25761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
25762   float jresult ;
25763   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25764   float result;
25765
25766   arg1 = (Dali::PanGesture *)jarg1;
25767   {
25768     try {
25769       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
25770     } CALL_CATCH_EXCEPTION(0);
25771   }
25772
25773   jresult = result;
25774   return jresult;
25775 }
25776
25777
25778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
25779   float jresult ;
25780   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25781   float result;
25782
25783   arg1 = (Dali::PanGesture *)jarg1;
25784   {
25785     try {
25786       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
25787     } CALL_CATCH_EXCEPTION(0);
25788   }
25789
25790   jresult = result;
25791   return jresult;
25792 }
25793
25794
25795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25796   void * jresult ;
25797   Dali::PinchGestureDetector *result = 0 ;
25798
25799   {
25800     try {
25801       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25802     } CALL_CATCH_EXCEPTION(0);
25803   }
25804
25805   jresult = (void *)result;
25806   return jresult;
25807 }
25808
25809
25810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25811   void * jresult ;
25812   Dali::PinchGestureDetector result;
25813
25814   {
25815     try {
25816       result = Dali::PinchGestureDetector::New();
25817     } CALL_CATCH_EXCEPTION(0);
25818   }
25819
25820   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25821   return jresult;
25822 }
25823
25824
25825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25826   void * jresult ;
25827   Dali::BaseHandle arg1 ;
25828   Dali::BaseHandle *argp1 ;
25829   Dali::PinchGestureDetector result;
25830
25831   argp1 = (Dali::BaseHandle *)jarg1;
25832   if (!argp1) {
25833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25834     return 0;
25835   }
25836   arg1 = *argp1;
25837   {
25838     try {
25839       result = Dali::PinchGestureDetector::DownCast(arg1);
25840     } CALL_CATCH_EXCEPTION(0);
25841   }
25842
25843   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25844   return jresult;
25845 }
25846
25847
25848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25849   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25850
25851   arg1 = (Dali::PinchGestureDetector *)jarg1;
25852   {
25853     try {
25854       delete arg1;
25855     } CALL_CATCH_EXCEPTION();
25856   }
25857
25858 }
25859
25860
25861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25862   void * jresult ;
25863   Dali::PinchGestureDetector *arg1 = 0 ;
25864   Dali::PinchGestureDetector *result = 0 ;
25865
25866   arg1 = (Dali::PinchGestureDetector *)jarg1;
25867   if (!arg1) {
25868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25869     return 0;
25870   }
25871   {
25872     try {
25873       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25874     } CALL_CATCH_EXCEPTION(0);
25875   }
25876
25877   jresult = (void *)result;
25878   return jresult;
25879 }
25880
25881
25882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25883   void * jresult ;
25884   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25885   Dali::PinchGestureDetector *arg2 = 0 ;
25886   Dali::PinchGestureDetector *result = 0 ;
25887
25888   arg1 = (Dali::PinchGestureDetector *)jarg1;
25889   arg2 = (Dali::PinchGestureDetector *)jarg2;
25890   if (!arg2) {
25891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25892     return 0;
25893   }
25894   {
25895     try {
25896       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25897     } CALL_CATCH_EXCEPTION(0);
25898   }
25899
25900   jresult = (void *)result;
25901   return jresult;
25902 }
25903
25904
25905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25906   void * jresult ;
25907   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25908   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25909
25910   arg1 = (Dali::PinchGestureDetector *)jarg1;
25911   {
25912     try {
25913       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25914     } CALL_CATCH_EXCEPTION(0);
25915   }
25916
25917   jresult = (void *)result;
25918   return jresult;
25919 }
25920
25921
25922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
25923   void * jresult ;
25924   Dali::Gesture::State arg1 ;
25925   Dali::PinchGesture *result = 0 ;
25926
25927   arg1 = (Dali::Gesture::State)jarg1;
25928   {
25929     try {
25930       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
25931     } CALL_CATCH_EXCEPTION(0);
25932   }
25933
25934   jresult = (void *)result;
25935   return jresult;
25936 }
25937
25938
25939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25940   void * jresult ;
25941   Dali::PinchGesture *arg1 = 0 ;
25942   Dali::PinchGesture *result = 0 ;
25943
25944   arg1 = (Dali::PinchGesture *)jarg1;
25945   if (!arg1) {
25946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25947     return 0;
25948   }
25949   {
25950     try {
25951       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
25952     } CALL_CATCH_EXCEPTION(0);
25953   }
25954
25955   jresult = (void *)result;
25956   return jresult;
25957 }
25958
25959
25960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
25961   void * jresult ;
25962   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25963   Dali::PinchGesture *arg2 = 0 ;
25964   Dali::PinchGesture *result = 0 ;
25965
25966   arg1 = (Dali::PinchGesture *)jarg1;
25967   arg2 = (Dali::PinchGesture *)jarg2;
25968   if (!arg2) {
25969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25970     return 0;
25971   }
25972   {
25973     try {
25974       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
25975     } CALL_CATCH_EXCEPTION(0);
25976   }
25977
25978   jresult = (void *)result;
25979   return jresult;
25980 }
25981
25982
25983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
25984   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25985
25986   arg1 = (Dali::PinchGesture *)jarg1;
25987   {
25988     try {
25989       delete arg1;
25990     } CALL_CATCH_EXCEPTION();
25991   }
25992
25993 }
25994
25995
25996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
25997   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25998   float arg2 ;
25999
26000   arg1 = (Dali::PinchGesture *)jarg1;
26001   arg2 = (float)jarg2;
26002   if (arg1) (arg1)->scale = arg2;
26003 }
26004
26005
26006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
26007   float jresult ;
26008   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26009   float result;
26010
26011   arg1 = (Dali::PinchGesture *)jarg1;
26012   result = (float) ((arg1)->scale);
26013   jresult = result;
26014   return jresult;
26015 }
26016
26017
26018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
26019   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26020   float arg2 ;
26021
26022   arg1 = (Dali::PinchGesture *)jarg1;
26023   arg2 = (float)jarg2;
26024   if (arg1) (arg1)->speed = arg2;
26025 }
26026
26027
26028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
26029   float jresult ;
26030   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26031   float result;
26032
26033   arg1 = (Dali::PinchGesture *)jarg1;
26034   result = (float) ((arg1)->speed);
26035   jresult = result;
26036   return jresult;
26037 }
26038
26039
26040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
26041   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26042   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26043
26044   arg1 = (Dali::PinchGesture *)jarg1;
26045   arg2 = (Dali::Vector2 *)jarg2;
26046   if (arg1) (arg1)->screenCenterPoint = *arg2;
26047 }
26048
26049
26050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
26051   void * jresult ;
26052   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26053   Dali::Vector2 *result = 0 ;
26054
26055   arg1 = (Dali::PinchGesture *)jarg1;
26056   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
26057   jresult = (void *)result;
26058   return jresult;
26059 }
26060
26061
26062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
26063   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26064   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26065
26066   arg1 = (Dali::PinchGesture *)jarg1;
26067   arg2 = (Dali::Vector2 *)jarg2;
26068   if (arg1) (arg1)->localCenterPoint = *arg2;
26069 }
26070
26071
26072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
26073   void * jresult ;
26074   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26075   Dali::Vector2 *result = 0 ;
26076
26077   arg1 = (Dali::PinchGesture *)jarg1;
26078   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
26079   jresult = (void *)result;
26080   return jresult;
26081 }
26082
26083
26084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26085   void * jresult ;
26086   Dali::TapGestureDetector *result = 0 ;
26087
26088   {
26089     try {
26090       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26091     } CALL_CATCH_EXCEPTION(0);
26092   }
26093
26094   jresult = (void *)result;
26095   return jresult;
26096 }
26097
26098
26099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26100   void * jresult ;
26101   Dali::TapGestureDetector result;
26102
26103   {
26104     try {
26105       result = Dali::TapGestureDetector::New();
26106     } CALL_CATCH_EXCEPTION(0);
26107   }
26108
26109   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26110   return jresult;
26111 }
26112
26113
26114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26115   void * jresult ;
26116   unsigned int arg1 ;
26117   Dali::TapGestureDetector result;
26118
26119   arg1 = (unsigned int)jarg1;
26120   {
26121     try {
26122       result = Dali::TapGestureDetector::New(arg1);
26123     } CALL_CATCH_EXCEPTION(0);
26124   }
26125
26126   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26127   return jresult;
26128 }
26129
26130
26131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26132   void * jresult ;
26133   Dali::BaseHandle arg1 ;
26134   Dali::BaseHandle *argp1 ;
26135   Dali::TapGestureDetector result;
26136
26137   argp1 = (Dali::BaseHandle *)jarg1;
26138   if (!argp1) {
26139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26140     return 0;
26141   }
26142   arg1 = *argp1;
26143   {
26144     try {
26145       result = Dali::TapGestureDetector::DownCast(arg1);
26146     } CALL_CATCH_EXCEPTION(0);
26147   }
26148
26149   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26150   return jresult;
26151 }
26152
26153
26154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26155   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26156
26157   arg1 = (Dali::TapGestureDetector *)jarg1;
26158   {
26159     try {
26160       delete arg1;
26161     } CALL_CATCH_EXCEPTION();
26162   }
26163
26164 }
26165
26166
26167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26168   void * jresult ;
26169   Dali::TapGestureDetector *arg1 = 0 ;
26170   Dali::TapGestureDetector *result = 0 ;
26171
26172   arg1 = (Dali::TapGestureDetector *)jarg1;
26173   if (!arg1) {
26174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26175     return 0;
26176   }
26177   {
26178     try {
26179       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26180     } CALL_CATCH_EXCEPTION(0);
26181   }
26182
26183   jresult = (void *)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26189   void * jresult ;
26190   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26191   Dali::TapGestureDetector *arg2 = 0 ;
26192   Dali::TapGestureDetector *result = 0 ;
26193
26194   arg1 = (Dali::TapGestureDetector *)jarg1;
26195   arg2 = (Dali::TapGestureDetector *)jarg2;
26196   if (!arg2) {
26197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26198     return 0;
26199   }
26200   {
26201     try {
26202       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26203     } CALL_CATCH_EXCEPTION(0);
26204   }
26205
26206   jresult = (void *)result;
26207   return jresult;
26208 }
26209
26210
26211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26212   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26213   unsigned int arg2 ;
26214
26215   arg1 = (Dali::TapGestureDetector *)jarg1;
26216   arg2 = (unsigned int)jarg2;
26217   {
26218     try {
26219       (arg1)->SetMinimumTapsRequired(arg2);
26220     } CALL_CATCH_EXCEPTION();
26221   }
26222
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26227   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26228   unsigned int arg2 ;
26229
26230   arg1 = (Dali::TapGestureDetector *)jarg1;
26231   arg2 = (unsigned int)jarg2;
26232   {
26233     try {
26234       (arg1)->SetMaximumTapsRequired(arg2);
26235     } CALL_CATCH_EXCEPTION();
26236   }
26237
26238 }
26239
26240
26241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26242   unsigned int jresult ;
26243   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26244   unsigned int result;
26245
26246   arg1 = (Dali::TapGestureDetector *)jarg1;
26247   {
26248     try {
26249       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26250     } CALL_CATCH_EXCEPTION(0);
26251   }
26252
26253   jresult = result;
26254   return jresult;
26255 }
26256
26257
26258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
26259   unsigned int jresult ;
26260   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26261   unsigned int result;
26262
26263   arg1 = (Dali::TapGestureDetector *)jarg1;
26264   {
26265     try {
26266       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
26267     } CALL_CATCH_EXCEPTION(0);
26268   }
26269
26270   jresult = result;
26271   return jresult;
26272 }
26273
26274
26275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26276   void * jresult ;
26277   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26278   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26279
26280   arg1 = (Dali::TapGestureDetector *)jarg1;
26281   {
26282     try {
26283       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26284     } CALL_CATCH_EXCEPTION(0);
26285   }
26286
26287   jresult = (void *)result;
26288   return jresult;
26289 }
26290
26291
26292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26293   void * jresult ;
26294   Dali::TapGesture *result = 0 ;
26295
26296   {
26297     try {
26298       result = (Dali::TapGesture *)new Dali::TapGesture();
26299     } CALL_CATCH_EXCEPTION(0);
26300   }
26301
26302   jresult = (void *)result;
26303   return jresult;
26304 }
26305
26306
26307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26308   void * jresult ;
26309   Dali::TapGesture *arg1 = 0 ;
26310   Dali::TapGesture *result = 0 ;
26311
26312   arg1 = (Dali::TapGesture *)jarg1;
26313   if (!arg1) {
26314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26315     return 0;
26316   }
26317   {
26318     try {
26319       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26320     } CALL_CATCH_EXCEPTION(0);
26321   }
26322
26323   jresult = (void *)result;
26324   return jresult;
26325 }
26326
26327
26328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26329   void * jresult ;
26330   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26331   Dali::TapGesture *arg2 = 0 ;
26332   Dali::TapGesture *result = 0 ;
26333
26334   arg1 = (Dali::TapGesture *)jarg1;
26335   arg2 = (Dali::TapGesture *)jarg2;
26336   if (!arg2) {
26337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26338     return 0;
26339   }
26340   {
26341     try {
26342       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26343     } CALL_CATCH_EXCEPTION(0);
26344   }
26345
26346   jresult = (void *)result;
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26352   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26353
26354   arg1 = (Dali::TapGesture *)jarg1;
26355   {
26356     try {
26357       delete arg1;
26358     } CALL_CATCH_EXCEPTION();
26359   }
26360
26361 }
26362
26363
26364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
26365   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26366   unsigned int arg2 ;
26367
26368   arg1 = (Dali::TapGesture *)jarg1;
26369   arg2 = (unsigned int)jarg2;
26370   if (arg1) (arg1)->numberOfTaps = arg2;
26371 }
26372
26373
26374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26375   unsigned int jresult ;
26376   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26377   unsigned int result;
26378
26379   arg1 = (Dali::TapGesture *)jarg1;
26380   result = (unsigned int) ((arg1)->numberOfTaps);
26381   jresult = result;
26382   return jresult;
26383 }
26384
26385
26386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
26387   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26388   unsigned int arg2 ;
26389
26390   arg1 = (Dali::TapGesture *)jarg1;
26391   arg2 = (unsigned int)jarg2;
26392   if (arg1) (arg1)->numberOfTouches = arg2;
26393 }
26394
26395
26396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26397   unsigned int jresult ;
26398   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26399   unsigned int result;
26400
26401   arg1 = (Dali::TapGesture *)jarg1;
26402   result = (unsigned int) ((arg1)->numberOfTouches);
26403   jresult = result;
26404   return jresult;
26405 }
26406
26407
26408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
26409   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26410   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26411
26412   arg1 = (Dali::TapGesture *)jarg1;
26413   arg2 = (Dali::Vector2 *)jarg2;
26414   if (arg1) (arg1)->screenPoint = *arg2;
26415 }
26416
26417
26418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26419   void * jresult ;
26420   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26421   Dali::Vector2 *result = 0 ;
26422
26423   arg1 = (Dali::TapGesture *)jarg1;
26424   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
26425   jresult = (void *)result;
26426   return jresult;
26427 }
26428
26429
26430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
26431   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26432   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26433
26434   arg1 = (Dali::TapGesture *)jarg1;
26435   arg2 = (Dali::Vector2 *)jarg2;
26436   if (arg1) (arg1)->localPoint = *arg2;
26437 }
26438
26439
26440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26441   void * jresult ;
26442   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26443   Dali::Vector2 *result = 0 ;
26444
26445   arg1 = (Dali::TapGesture *)jarg1;
26446   result = (Dali::Vector2 *)& ((arg1)->localPoint);
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26453   void * jresult ;
26454   Dali::AlphaFunction *result = 0 ;
26455
26456   {
26457     try {
26458       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26459     } CALL_CATCH_EXCEPTION(0);
26460   }
26461
26462   jresult = (void *)result;
26463   return jresult;
26464 }
26465
26466
26467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26468   void * jresult ;
26469   Dali::AlphaFunction::BuiltinFunction arg1 ;
26470   Dali::AlphaFunction *result = 0 ;
26471
26472   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26473   {
26474     try {
26475       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26476     } CALL_CATCH_EXCEPTION(0);
26477   }
26478
26479   jresult = (void *)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
26485   void * jresult ;
26486   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26487   Dali::AlphaFunction *result = 0 ;
26488
26489   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
26490   {
26491     try {
26492       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26493     } CALL_CATCH_EXCEPTION(0);
26494   }
26495
26496   jresult = (void *)result;
26497   return jresult;
26498 }
26499
26500
26501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
26502   void * jresult ;
26503   Dali::Vector2 *arg1 = 0 ;
26504   Dali::Vector2 *arg2 = 0 ;
26505   Dali::AlphaFunction *result = 0 ;
26506
26507   arg1 = (Dali::Vector2 *)jarg1;
26508   if (!arg1) {
26509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26510     return 0;
26511   }
26512   arg2 = (Dali::Vector2 *)jarg2;
26513   if (!arg2) {
26514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26515     return 0;
26516   }
26517   {
26518     try {
26519       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26520     } CALL_CATCH_EXCEPTION(0);
26521   }
26522
26523   jresult = (void *)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26529   void * jresult ;
26530   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26531   Dali::Vector4 result;
26532
26533   arg1 = (Dali::AlphaFunction *)jarg1;
26534   {
26535     try {
26536       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26537     } CALL_CATCH_EXCEPTION(0);
26538   }
26539
26540   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26541   return jresult;
26542 }
26543
26544
26545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26546   void * jresult ;
26547   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26548   Dali::AlphaFunctionPrototype result;
26549
26550   arg1 = (Dali::AlphaFunction *)jarg1;
26551   {
26552     try {
26553       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26554     } CALL_CATCH_EXCEPTION(0);
26555   }
26556
26557   jresult = (void *)result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26563   int jresult ;
26564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26565   Dali::AlphaFunction::BuiltinFunction result;
26566
26567   arg1 = (Dali::AlphaFunction *)jarg1;
26568   {
26569     try {
26570       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26571     } CALL_CATCH_EXCEPTION(0);
26572   }
26573
26574   jresult = (int)result;
26575   return jresult;
26576 }
26577
26578
26579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26580   int jresult ;
26581   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26582   Dali::AlphaFunction::Mode result;
26583
26584   arg1 = (Dali::AlphaFunction *)jarg1;
26585   {
26586     try {
26587       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26588     } CALL_CATCH_EXCEPTION(0);
26589   }
26590
26591   jresult = (int)result;
26592   return jresult;
26593 }
26594
26595
26596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26597   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26598
26599   arg1 = (Dali::AlphaFunction *)jarg1;
26600   {
26601     try {
26602       delete arg1;
26603     } CALL_CATCH_EXCEPTION();
26604   }
26605
26606 }
26607
26608
26609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26610   void * jresult ;
26611   Dali::KeyFrames result;
26612
26613   {
26614     try {
26615       result = Dali::KeyFrames::New();
26616     } CALL_CATCH_EXCEPTION(0);
26617   }
26618
26619   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26625   void * jresult ;
26626   Dali::BaseHandle arg1 ;
26627   Dali::BaseHandle *argp1 ;
26628   Dali::KeyFrames result;
26629
26630   argp1 = (Dali::BaseHandle *)jarg1;
26631   if (!argp1) {
26632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26633     return 0;
26634   }
26635   arg1 = *argp1;
26636   {
26637     try {
26638       result = Dali::KeyFrames::DownCast(arg1);
26639     } CALL_CATCH_EXCEPTION(0);
26640   }
26641
26642   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26643   return jresult;
26644 }
26645
26646
26647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26648   void * jresult ;
26649   Dali::KeyFrames *result = 0 ;
26650
26651   {
26652     try {
26653       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26654     } CALL_CATCH_EXCEPTION(0);
26655   }
26656
26657   jresult = (void *)result;
26658   return jresult;
26659 }
26660
26661
26662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26663   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26664
26665   arg1 = (Dali::KeyFrames *)jarg1;
26666   {
26667     try {
26668       delete arg1;
26669     } CALL_CATCH_EXCEPTION();
26670   }
26671
26672 }
26673
26674
26675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26676   void * jresult ;
26677   Dali::KeyFrames *arg1 = 0 ;
26678   Dali::KeyFrames *result = 0 ;
26679
26680   arg1 = (Dali::KeyFrames *)jarg1;
26681   if (!arg1) {
26682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26683     return 0;
26684   }
26685   {
26686     try {
26687       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26688     } CALL_CATCH_EXCEPTION(0);
26689   }
26690
26691   jresult = (void *)result;
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26697   void * jresult ;
26698   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26699   Dali::KeyFrames *arg2 = 0 ;
26700   Dali::KeyFrames *result = 0 ;
26701
26702   arg1 = (Dali::KeyFrames *)jarg1;
26703   arg2 = (Dali::KeyFrames *)jarg2;
26704   if (!arg2) {
26705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26706     return 0;
26707   }
26708   {
26709     try {
26710       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26711     } CALL_CATCH_EXCEPTION(0);
26712   }
26713
26714   jresult = (void *)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26720   int jresult ;
26721   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26722   Dali::Property::Type result;
26723
26724   arg1 = (Dali::KeyFrames *)jarg1;
26725   {
26726     try {
26727       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26728     } CALL_CATCH_EXCEPTION(0);
26729   }
26730
26731   jresult = (int)result;
26732   return jresult;
26733 }
26734
26735
26736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26737   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26738   float arg2 ;
26739   Dali::Property::Value arg3 ;
26740   Dali::Property::Value *argp3 ;
26741
26742   arg1 = (Dali::KeyFrames *)jarg1;
26743   arg2 = (float)jarg2;
26744   argp3 = (Dali::Property::Value *)jarg3;
26745   if (!argp3) {
26746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26747     return ;
26748   }
26749   arg3 = *argp3;
26750   {
26751     try {
26752       (arg1)->Add(arg2,arg3);
26753     } CALL_CATCH_EXCEPTION();
26754   }
26755
26756 }
26757
26758
26759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26760   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26761   float arg2 ;
26762   Dali::Property::Value arg3 ;
26763   Dali::AlphaFunction arg4 ;
26764   Dali::Property::Value *argp3 ;
26765   Dali::AlphaFunction *argp4 ;
26766
26767   arg1 = (Dali::KeyFrames *)jarg1;
26768   arg2 = (float)jarg2;
26769   argp3 = (Dali::Property::Value *)jarg3;
26770   if (!argp3) {
26771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26772     return ;
26773   }
26774   arg3 = *argp3;
26775   argp4 = (Dali::AlphaFunction *)jarg4;
26776   if (!argp4) {
26777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26778     return ;
26779   }
26780   arg4 = *argp4;
26781   {
26782     try {
26783       (arg1)->Add(arg2,arg3,arg4);
26784     } CALL_CATCH_EXCEPTION();
26785   }
26786
26787 }
26788
26789
26790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26791   int jresult ;
26792   int result;
26793
26794   result = (int)Dali::Path::Property::POINTS;
26795   jresult = (int)result;
26796   return jresult;
26797 }
26798
26799
26800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26801   int jresult ;
26802   int result;
26803
26804   result = (int)Dali::Path::Property::CONTROL_POINTS;
26805   jresult = (int)result;
26806   return jresult;
26807 }
26808
26809
26810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26811   void * jresult ;
26812   Dali::Path::Property *result = 0 ;
26813
26814   {
26815     try {
26816       result = (Dali::Path::Property *)new Dali::Path::Property();
26817     } CALL_CATCH_EXCEPTION(0);
26818   }
26819
26820   jresult = (void *)result;
26821   return jresult;
26822 }
26823
26824
26825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26826   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26827
26828   arg1 = (Dali::Path::Property *)jarg1;
26829   {
26830     try {
26831       delete arg1;
26832     } CALL_CATCH_EXCEPTION();
26833   }
26834
26835 }
26836
26837
26838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26839   void * jresult ;
26840   Dali::Path result;
26841
26842   {
26843     try {
26844       result = Dali::Path::New();
26845     } CALL_CATCH_EXCEPTION(0);
26846   }
26847
26848   jresult = new Dali::Path((const Dali::Path &)result);
26849   return jresult;
26850 }
26851
26852
26853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26854   void * jresult ;
26855   Dali::BaseHandle arg1 ;
26856   Dali::BaseHandle *argp1 ;
26857   Dali::Path result;
26858
26859   argp1 = (Dali::BaseHandle *)jarg1;
26860   if (!argp1) {
26861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26862     return 0;
26863   }
26864   arg1 = *argp1;
26865   {
26866     try {
26867       result = Dali::Path::DownCast(arg1);
26868     } CALL_CATCH_EXCEPTION(0);
26869   }
26870
26871   jresult = new Dali::Path((const Dali::Path &)result);
26872   return jresult;
26873 }
26874
26875
26876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26877   void * jresult ;
26878   Dali::Path *result = 0 ;
26879
26880   {
26881     try {
26882       result = (Dali::Path *)new Dali::Path();
26883     } CALL_CATCH_EXCEPTION(0);
26884   }
26885
26886   jresult = (void *)result;
26887   return jresult;
26888 }
26889
26890
26891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26892   Dali::Path *arg1 = (Dali::Path *) 0 ;
26893
26894   arg1 = (Dali::Path *)jarg1;
26895   {
26896     try {
26897       delete arg1;
26898     } CALL_CATCH_EXCEPTION();
26899   }
26900
26901 }
26902
26903
26904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26905   void * jresult ;
26906   Dali::Path *arg1 = 0 ;
26907   Dali::Path *result = 0 ;
26908
26909   arg1 = (Dali::Path *)jarg1;
26910   if (!arg1) {
26911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26912     return 0;
26913   }
26914   {
26915     try {
26916       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26917     } CALL_CATCH_EXCEPTION(0);
26918   }
26919
26920   jresult = (void *)result;
26921   return jresult;
26922 }
26923
26924
26925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26926   void * jresult ;
26927   Dali::Path *arg1 = (Dali::Path *) 0 ;
26928   Dali::Path *arg2 = 0 ;
26929   Dali::Path *result = 0 ;
26930
26931   arg1 = (Dali::Path *)jarg1;
26932   arg2 = (Dali::Path *)jarg2;
26933   if (!arg2) {
26934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26935     return 0;
26936   }
26937   {
26938     try {
26939       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26940     } CALL_CATCH_EXCEPTION(0);
26941   }
26942
26943   jresult = (void *)result;
26944   return jresult;
26945 }
26946
26947
26948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
26949   Dali::Path *arg1 = (Dali::Path *) 0 ;
26950   Dali::Vector3 *arg2 = 0 ;
26951
26952   arg1 = (Dali::Path *)jarg1;
26953   arg2 = (Dali::Vector3 *)jarg2;
26954   if (!arg2) {
26955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26956     return ;
26957   }
26958   {
26959     try {
26960       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
26961     } CALL_CATCH_EXCEPTION();
26962   }
26963
26964 }
26965
26966
26967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
26968   Dali::Path *arg1 = (Dali::Path *) 0 ;
26969   Dali::Vector3 *arg2 = 0 ;
26970
26971   arg1 = (Dali::Path *)jarg1;
26972   arg2 = (Dali::Vector3 *)jarg2;
26973   if (!arg2) {
26974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26975     return ;
26976   }
26977   {
26978     try {
26979       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
26980     } CALL_CATCH_EXCEPTION();
26981   }
26982
26983 }
26984
26985
26986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
26987   Dali::Path *arg1 = (Dali::Path *) 0 ;
26988   float arg2 ;
26989
26990   arg1 = (Dali::Path *)jarg1;
26991   arg2 = (float)jarg2;
26992   {
26993     try {
26994       (arg1)->GenerateControlPoints(arg2);
26995     } CALL_CATCH_EXCEPTION();
26996   }
26997
26998 }
26999
27000
27001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27002   Dali::Path *arg1 = (Dali::Path *) 0 ;
27003   float arg2 ;
27004   Dali::Vector3 *arg3 = 0 ;
27005   Dali::Vector3 *arg4 = 0 ;
27006
27007   arg1 = (Dali::Path *)jarg1;
27008   arg2 = (float)jarg2;
27009   arg3 = (Dali::Vector3 *)jarg3;
27010   if (!arg3) {
27011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27012     return ;
27013   }
27014   arg4 = (Dali::Vector3 *)jarg4;
27015   if (!arg4) {
27016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27017     return ;
27018   }
27019   {
27020     try {
27021       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
27022     } CALL_CATCH_EXCEPTION();
27023   }
27024
27025 }
27026
27027
27028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
27029   void * jresult ;
27030   Dali::Path *arg1 = (Dali::Path *) 0 ;
27031   size_t arg2 ;
27032   Dali::Vector3 *result = 0 ;
27033
27034   arg1 = (Dali::Path *)jarg1;
27035   arg2 = (size_t)jarg2;
27036   {
27037     try {
27038       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
27039     } CALL_CATCH_EXCEPTION(0);
27040   }
27041
27042   jresult = (void *)result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
27048   void * jresult ;
27049   Dali::Path *arg1 = (Dali::Path *) 0 ;
27050   size_t arg2 ;
27051   Dali::Vector3 *result = 0 ;
27052
27053   arg1 = (Dali::Path *)jarg1;
27054   arg2 = (size_t)jarg2;
27055   {
27056     try {
27057       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
27058     } CALL_CATCH_EXCEPTION(0);
27059   }
27060
27061   jresult = (void *)result;
27062   return jresult;
27063 }
27064
27065
27066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27067   unsigned long jresult ;
27068   Dali::Path *arg1 = (Dali::Path *) 0 ;
27069   size_t result;
27070
27071   arg1 = (Dali::Path *)jarg1;
27072   {
27073     try {
27074       result = ((Dali::Path const *)arg1)->GetPointCount();
27075     } CALL_CATCH_EXCEPTION(0);
27076   }
27077
27078   jresult = (unsigned long)result;
27079   return jresult;
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27084   void * jresult ;
27085   float arg1 ;
27086   Dali::TimePeriod *result = 0 ;
27087
27088   arg1 = (float)jarg1;
27089   {
27090     try {
27091       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27092     } CALL_CATCH_EXCEPTION(0);
27093   }
27094
27095   jresult = (void *)result;
27096   return jresult;
27097 }
27098
27099
27100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27101   void * jresult ;
27102   float arg1 ;
27103   float arg2 ;
27104   Dali::TimePeriod *result = 0 ;
27105
27106   arg1 = (float)jarg1;
27107   arg2 = (float)jarg2;
27108   {
27109     try {
27110       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27111     } CALL_CATCH_EXCEPTION(0);
27112   }
27113
27114   jresult = (void *)result;
27115   return jresult;
27116 }
27117
27118
27119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27120   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27121
27122   arg1 = (Dali::TimePeriod *)jarg1;
27123   {
27124     try {
27125       delete arg1;
27126     } CALL_CATCH_EXCEPTION();
27127   }
27128
27129 }
27130
27131
27132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27133   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27134   float arg2 ;
27135
27136   arg1 = (Dali::TimePeriod *)jarg1;
27137   arg2 = (float)jarg2;
27138   if (arg1) (arg1)->delaySeconds = arg2;
27139 }
27140
27141
27142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27143   float jresult ;
27144   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27145   float result;
27146
27147   arg1 = (Dali::TimePeriod *)jarg1;
27148   result = (float) ((arg1)->delaySeconds);
27149   jresult = result;
27150   return jresult;
27151 }
27152
27153
27154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27155   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27156   float arg2 ;
27157
27158   arg1 = (Dali::TimePeriod *)jarg1;
27159   arg2 = (float)jarg2;
27160   if (arg1) (arg1)->durationSeconds = arg2;
27161 }
27162
27163
27164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27165   float jresult ;
27166   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27167   float result;
27168
27169   arg1 = (Dali::TimePeriod *)jarg1;
27170   result = (float) ((arg1)->durationSeconds);
27171   jresult = result;
27172   return jresult;
27173 }
27174
27175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27176   int jresult ;
27177   int result;
27178
27179   result = (int)Dali::LinearConstrainer::Property::VALUE;
27180   jresult = (int)result;
27181   return jresult;
27182 }
27183
27184
27185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27186   int jresult ;
27187   int result;
27188
27189   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27190   jresult = (int)result;
27191   return jresult;
27192 }
27193
27194
27195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27196   void * jresult ;
27197   Dali::LinearConstrainer::Property *result = 0 ;
27198
27199   {
27200     try {
27201       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27202     } CALL_CATCH_EXCEPTION(0);
27203   }
27204
27205   jresult = (void *)result;
27206   return jresult;
27207 }
27208
27209
27210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27211   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27212
27213   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27214   {
27215     try {
27216       delete arg1;
27217     } CALL_CATCH_EXCEPTION();
27218   }
27219
27220 }
27221
27222
27223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27224   void * jresult ;
27225   Dali::LinearConstrainer result;
27226
27227   {
27228     try {
27229       result = Dali::LinearConstrainer::New();
27230     } CALL_CATCH_EXCEPTION(0);
27231   }
27232
27233   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27234   return jresult;
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27239   void * jresult ;
27240   Dali::BaseHandle arg1 ;
27241   Dali::BaseHandle *argp1 ;
27242   Dali::LinearConstrainer result;
27243
27244   argp1 = (Dali::BaseHandle *)jarg1;
27245   if (!argp1) {
27246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27247     return 0;
27248   }
27249   arg1 = *argp1;
27250   {
27251     try {
27252       result = Dali::LinearConstrainer::DownCast(arg1);
27253     } CALL_CATCH_EXCEPTION(0);
27254   }
27255
27256   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27257   return jresult;
27258 }
27259
27260
27261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27262   void * jresult ;
27263   Dali::LinearConstrainer *result = 0 ;
27264
27265   {
27266     try {
27267       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27268     } CALL_CATCH_EXCEPTION(0);
27269   }
27270
27271   jresult = (void *)result;
27272   return jresult;
27273 }
27274
27275
27276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27277   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27278
27279   arg1 = (Dali::LinearConstrainer *)jarg1;
27280   {
27281     try {
27282       delete arg1;
27283     } CALL_CATCH_EXCEPTION();
27284   }
27285
27286 }
27287
27288
27289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27290   void * jresult ;
27291   Dali::LinearConstrainer *arg1 = 0 ;
27292   Dali::LinearConstrainer *result = 0 ;
27293
27294   arg1 = (Dali::LinearConstrainer *)jarg1;
27295   if (!arg1) {
27296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27297     return 0;
27298   }
27299   {
27300     try {
27301       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27302     } CALL_CATCH_EXCEPTION(0);
27303   }
27304
27305   jresult = (void *)result;
27306   return jresult;
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27311   void * jresult ;
27312   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27313   Dali::LinearConstrainer *arg2 = 0 ;
27314   Dali::LinearConstrainer *result = 0 ;
27315
27316   arg1 = (Dali::LinearConstrainer *)jarg1;
27317   arg2 = (Dali::LinearConstrainer *)jarg2;
27318   if (!arg2) {
27319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27320     return 0;
27321   }
27322   {
27323     try {
27324       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27325     } CALL_CATCH_EXCEPTION(0);
27326   }
27327
27328   jresult = (void *)result;
27329   return jresult;
27330 }
27331
27332
27333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27334   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27335   SwigValueWrapper< Dali::Property > arg2 ;
27336   SwigValueWrapper< Dali::Property > arg3 ;
27337   Dali::Vector2 *arg4 = 0 ;
27338   Dali::Vector2 *arg5 = 0 ;
27339   Dali::Property *argp2 ;
27340   Dali::Property *argp3 ;
27341
27342   arg1 = (Dali::LinearConstrainer *)jarg1;
27343   argp2 = (Dali::Property *)jarg2;
27344   if (!argp2) {
27345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27346     return ;
27347   }
27348   arg2 = *argp2;
27349   argp3 = (Dali::Property *)jarg3;
27350   if (!argp3) {
27351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27352     return ;
27353   }
27354   arg3 = *argp3;
27355   arg4 = (Dali::Vector2 *)jarg4;
27356   if (!arg4) {
27357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27358     return ;
27359   }
27360   arg5 = (Dali::Vector2 *)jarg5;
27361   if (!arg5) {
27362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27363     return ;
27364   }
27365   {
27366     try {
27367       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27368     } CALL_CATCH_EXCEPTION();
27369   }
27370
27371 }
27372
27373
27374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27375   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27376   SwigValueWrapper< Dali::Property > arg2 ;
27377   SwigValueWrapper< Dali::Property > arg3 ;
27378   Dali::Vector2 *arg4 = 0 ;
27379   Dali::Property *argp2 ;
27380   Dali::Property *argp3 ;
27381
27382   arg1 = (Dali::LinearConstrainer *)jarg1;
27383   argp2 = (Dali::Property *)jarg2;
27384   if (!argp2) {
27385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27386     return ;
27387   }
27388   arg2 = *argp2;
27389   argp3 = (Dali::Property *)jarg3;
27390   if (!argp3) {
27391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27392     return ;
27393   }
27394   arg3 = *argp3;
27395   arg4 = (Dali::Vector2 *)jarg4;
27396   if (!arg4) {
27397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27398     return ;
27399   }
27400   {
27401     try {
27402       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27403     } CALL_CATCH_EXCEPTION();
27404   }
27405
27406 }
27407
27408
27409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27410   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27411   Dali::Handle *arg2 = 0 ;
27412
27413   arg1 = (Dali::LinearConstrainer *)jarg1;
27414   arg2 = (Dali::Handle *)jarg2;
27415   if (!arg2) {
27416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27417     return ;
27418   }
27419   {
27420     try {
27421       (arg1)->Remove(*arg2);
27422     } CALL_CATCH_EXCEPTION();
27423   }
27424
27425 }
27426
27427
27428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27429   int jresult ;
27430   int result;
27431
27432   result = (int)Dali::PathConstrainer::Property::FORWARD;
27433   jresult = (int)result;
27434   return jresult;
27435 }
27436
27437
27438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27439   int jresult ;
27440   int result;
27441
27442   result = (int)Dali::PathConstrainer::Property::POINTS;
27443   jresult = (int)result;
27444   return jresult;
27445 }
27446
27447
27448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27449   int jresult ;
27450   int result;
27451
27452   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27453   jresult = (int)result;
27454   return jresult;
27455 }
27456
27457
27458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27459   void * jresult ;
27460   Dali::PathConstrainer::Property *result = 0 ;
27461
27462   {
27463     try {
27464       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27465     } CALL_CATCH_EXCEPTION(0);
27466   }
27467
27468   jresult = (void *)result;
27469   return jresult;
27470 }
27471
27472
27473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27474   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27475
27476   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27477   {
27478     try {
27479       delete arg1;
27480     } CALL_CATCH_EXCEPTION();
27481   }
27482
27483 }
27484
27485
27486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27487   void * jresult ;
27488   Dali::PathConstrainer result;
27489
27490   {
27491     try {
27492       result = Dali::PathConstrainer::New();
27493     } CALL_CATCH_EXCEPTION(0);
27494   }
27495
27496   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27497   return jresult;
27498 }
27499
27500
27501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27502   void * jresult ;
27503   Dali::BaseHandle arg1 ;
27504   Dali::BaseHandle *argp1 ;
27505   Dali::PathConstrainer result;
27506
27507   argp1 = (Dali::BaseHandle *)jarg1;
27508   if (!argp1) {
27509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27510     return 0;
27511   }
27512   arg1 = *argp1;
27513   {
27514     try {
27515       result = Dali::PathConstrainer::DownCast(arg1);
27516     } CALL_CATCH_EXCEPTION(0);
27517   }
27518
27519   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27520   return jresult;
27521 }
27522
27523
27524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27525   void * jresult ;
27526   Dali::PathConstrainer *result = 0 ;
27527
27528   {
27529     try {
27530       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27531     } CALL_CATCH_EXCEPTION(0);
27532   }
27533
27534   jresult = (void *)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27540   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27541
27542   arg1 = (Dali::PathConstrainer *)jarg1;
27543   {
27544     try {
27545       delete arg1;
27546     } CALL_CATCH_EXCEPTION();
27547   }
27548
27549 }
27550
27551
27552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27553   void * jresult ;
27554   Dali::PathConstrainer *arg1 = 0 ;
27555   Dali::PathConstrainer *result = 0 ;
27556
27557   arg1 = (Dali::PathConstrainer *)jarg1;
27558   if (!arg1) {
27559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27560     return 0;
27561   }
27562   {
27563     try {
27564       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27565     } CALL_CATCH_EXCEPTION(0);
27566   }
27567
27568   jresult = (void *)result;
27569   return jresult;
27570 }
27571
27572
27573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27574   void * jresult ;
27575   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27576   Dali::PathConstrainer *arg2 = 0 ;
27577   Dali::PathConstrainer *result = 0 ;
27578
27579   arg1 = (Dali::PathConstrainer *)jarg1;
27580   arg2 = (Dali::PathConstrainer *)jarg2;
27581   if (!arg2) {
27582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27583     return 0;
27584   }
27585   {
27586     try {
27587       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27588     } CALL_CATCH_EXCEPTION(0);
27589   }
27590
27591   jresult = (void *)result;
27592   return jresult;
27593 }
27594
27595
27596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27597   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27598   SwigValueWrapper< Dali::Property > arg2 ;
27599   SwigValueWrapper< Dali::Property > arg3 ;
27600   Dali::Vector2 *arg4 = 0 ;
27601   Dali::Vector2 *arg5 = 0 ;
27602   Dali::Property *argp2 ;
27603   Dali::Property *argp3 ;
27604
27605   arg1 = (Dali::PathConstrainer *)jarg1;
27606   argp2 = (Dali::Property *)jarg2;
27607   if (!argp2) {
27608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27609     return ;
27610   }
27611   arg2 = *argp2;
27612   argp3 = (Dali::Property *)jarg3;
27613   if (!argp3) {
27614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27615     return ;
27616   }
27617   arg3 = *argp3;
27618   arg4 = (Dali::Vector2 *)jarg4;
27619   if (!arg4) {
27620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27621     return ;
27622   }
27623   arg5 = (Dali::Vector2 *)jarg5;
27624   if (!arg5) {
27625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27626     return ;
27627   }
27628   {
27629     try {
27630       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27631     } CALL_CATCH_EXCEPTION();
27632   }
27633
27634 }
27635
27636
27637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27638   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27639   SwigValueWrapper< Dali::Property > arg2 ;
27640   SwigValueWrapper< Dali::Property > arg3 ;
27641   Dali::Vector2 *arg4 = 0 ;
27642   Dali::Property *argp2 ;
27643   Dali::Property *argp3 ;
27644
27645   arg1 = (Dali::PathConstrainer *)jarg1;
27646   argp2 = (Dali::Property *)jarg2;
27647   if (!argp2) {
27648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27649     return ;
27650   }
27651   arg2 = *argp2;
27652   argp3 = (Dali::Property *)jarg3;
27653   if (!argp3) {
27654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27655     return ;
27656   }
27657   arg3 = *argp3;
27658   arg4 = (Dali::Vector2 *)jarg4;
27659   if (!arg4) {
27660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27661     return ;
27662   }
27663   {
27664     try {
27665       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27666     } CALL_CATCH_EXCEPTION();
27667   }
27668
27669 }
27670
27671
27672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27673   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27674   Dali::Handle *arg2 = 0 ;
27675
27676   arg1 = (Dali::PathConstrainer *)jarg1;
27677   arg2 = (Dali::Handle *)jarg2;
27678   if (!arg2) {
27679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27680     return ;
27681   }
27682   {
27683     try {
27684       (arg1)->Remove(*arg2);
27685     } CALL_CATCH_EXCEPTION();
27686   }
27687
27688 }
27689
27690
27691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27692   int jresult ;
27693   Dali::FittingMode::Type result;
27694
27695   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27696   jresult = (int)result;
27697   return jresult;
27698 }
27699
27700
27701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27702   int jresult ;
27703   Dali::SamplingMode::Type result;
27704
27705   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27706   jresult = (int)result;
27707   return jresult;
27708 }
27709
27710
27711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27712   unsigned int jresult ;
27713   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27714   bool result;
27715
27716   arg1 = (Dali::NativeImageInterface *)jarg1;
27717   {
27718     try {
27719       result = (bool)(arg1)->CreateResource();
27720     } CALL_CATCH_EXCEPTION(0);
27721   }
27722
27723   jresult = result;
27724   return jresult;
27725 }
27726
27727
27728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27729   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27730
27731   arg1 = (Dali::NativeImageInterface *)jarg1;
27732   {
27733     try {
27734       (arg1)->DestroyResource();
27735     } CALL_CATCH_EXCEPTION();
27736   }
27737
27738 }
27739
27740
27741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27742   unsigned int jresult ;
27743   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27744   unsigned int result;
27745
27746   arg1 = (Dali::NativeImageInterface *)jarg1;
27747   {
27748     try {
27749       result = (unsigned int)(arg1)->TargetTexture();
27750     } CALL_CATCH_EXCEPTION(0);
27751   }
27752
27753   jresult = result;
27754   return jresult;
27755 }
27756
27757
27758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27759   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27760
27761   arg1 = (Dali::NativeImageInterface *)jarg1;
27762   {
27763     try {
27764       (arg1)->PrepareTexture();
27765     } CALL_CATCH_EXCEPTION();
27766   }
27767
27768 }
27769
27770
27771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27772   unsigned int jresult ;
27773   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27774   unsigned int result;
27775
27776   arg1 = (Dali::NativeImageInterface *)jarg1;
27777   {
27778     try {
27779       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27780     } CALL_CATCH_EXCEPTION(0);
27781   }
27782
27783   jresult = result;
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
27789   unsigned int jresult ;
27790   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27791   unsigned int result;
27792
27793   arg1 = (Dali::NativeImageInterface *)jarg1;
27794   {
27795     try {
27796       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
27797     } CALL_CATCH_EXCEPTION(0);
27798   }
27799
27800   jresult = result;
27801   return jresult;
27802 }
27803
27804
27805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27806   unsigned int jresult ;
27807   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27808   bool result;
27809
27810   arg1 = (Dali::NativeImageInterface *)jarg1;
27811   {
27812     try {
27813       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27814     } CALL_CATCH_EXCEPTION(0);
27815   }
27816
27817   jresult = result;
27818   return jresult;
27819 }
27820
27821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27822   int jresult ;
27823   int result;
27824
27825   result = (int)Dali::CameraActor::Property::TYPE;
27826   jresult = (int)result;
27827   return jresult;
27828 }
27829
27830
27831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27832   int jresult ;
27833   int result;
27834
27835   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27836   jresult = (int)result;
27837   return jresult;
27838 }
27839
27840
27841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27842   int jresult ;
27843   int result;
27844
27845   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27846   jresult = (int)result;
27847   return jresult;
27848 }
27849
27850
27851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27852   int jresult ;
27853   int result;
27854
27855   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27856   jresult = (int)result;
27857   return jresult;
27858 }
27859
27860
27861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27862   int jresult ;
27863   int result;
27864
27865   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27866   jresult = (int)result;
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27872   int jresult ;
27873   int result;
27874
27875   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27876   jresult = (int)result;
27877   return jresult;
27878 }
27879
27880
27881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27882   int jresult ;
27883   int result;
27884
27885   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27886   jresult = (int)result;
27887   return jresult;
27888 }
27889
27890
27891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27892   int jresult ;
27893   int result;
27894
27895   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27896   jresult = (int)result;
27897   return jresult;
27898 }
27899
27900
27901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27902   int jresult ;
27903   int result;
27904
27905   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27906   jresult = (int)result;
27907   return jresult;
27908 }
27909
27910
27911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27912   int jresult ;
27913   int result;
27914
27915   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27916   jresult = (int)result;
27917   return jresult;
27918 }
27919
27920
27921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27922   int jresult ;
27923   int result;
27924
27925   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27926   jresult = (int)result;
27927   return jresult;
27928 }
27929
27930
27931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27932   int jresult ;
27933   int result;
27934
27935   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27936   jresult = (int)result;
27937   return jresult;
27938 }
27939
27940
27941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27942   int jresult ;
27943   int result;
27944
27945   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
27946   jresult = (int)result;
27947   return jresult;
27948 }
27949
27950
27951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
27952   int jresult ;
27953   int result;
27954
27955   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
27956   jresult = (int)result;
27957   return jresult;
27958 }
27959
27960
27961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
27962   void * jresult ;
27963   Dali::CameraActor::Property *result = 0 ;
27964
27965   {
27966     try {
27967       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
27968     } CALL_CATCH_EXCEPTION(0);
27969   }
27970
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
27977   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
27978
27979   arg1 = (Dali::CameraActor::Property *)jarg1;
27980   {
27981     try {
27982       delete arg1;
27983     } CALL_CATCH_EXCEPTION();
27984   }
27985
27986 }
27987
27988
27989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
27990   void * jresult ;
27991   Dali::CameraActor *result = 0 ;
27992
27993   {
27994     try {
27995       result = (Dali::CameraActor *)new Dali::CameraActor();
27996     } CALL_CATCH_EXCEPTION(0);
27997   }
27998
27999   jresult = (void *)result;
28000   return jresult;
28001 }
28002
28003
28004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
28005   void * jresult ;
28006   Dali::CameraActor result;
28007
28008   {
28009     try {
28010       result = Dali::CameraActor::New();
28011     } CALL_CATCH_EXCEPTION(0);
28012   }
28013
28014   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28015   return jresult;
28016 }
28017
28018
28019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
28020   void * jresult ;
28021   Dali::Size *arg1 = 0 ;
28022   Dali::CameraActor result;
28023
28024   arg1 = (Dali::Size *)jarg1;
28025   if (!arg1) {
28026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28027     return 0;
28028   }
28029   {
28030     try {
28031       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
28032     } CALL_CATCH_EXCEPTION(0);
28033   }
28034
28035   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28036   return jresult;
28037 }
28038
28039
28040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
28041   void * jresult ;
28042   Dali::BaseHandle arg1 ;
28043   Dali::BaseHandle *argp1 ;
28044   Dali::CameraActor result;
28045
28046   argp1 = (Dali::BaseHandle *)jarg1;
28047   if (!argp1) {
28048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28049     return 0;
28050   }
28051   arg1 = *argp1;
28052   {
28053     try {
28054       result = Dali::CameraActor::DownCast(arg1);
28055     } CALL_CATCH_EXCEPTION(0);
28056   }
28057
28058   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28059   return jresult;
28060 }
28061
28062
28063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
28064   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28065
28066   arg1 = (Dali::CameraActor *)jarg1;
28067   {
28068     try {
28069       delete arg1;
28070     } CALL_CATCH_EXCEPTION();
28071   }
28072
28073 }
28074
28075
28076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28077   void * jresult ;
28078   Dali::CameraActor *arg1 = 0 ;
28079   Dali::CameraActor *result = 0 ;
28080
28081   arg1 = (Dali::CameraActor *)jarg1;
28082   if (!arg1) {
28083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28084     return 0;
28085   }
28086   {
28087     try {
28088       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28089     } CALL_CATCH_EXCEPTION(0);
28090   }
28091
28092   jresult = (void *)result;
28093   return jresult;
28094 }
28095
28096
28097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28098   void * jresult ;
28099   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28100   Dali::CameraActor *arg2 = 0 ;
28101   Dali::CameraActor *result = 0 ;
28102
28103   arg1 = (Dali::CameraActor *)jarg1;
28104   arg2 = (Dali::CameraActor *)jarg2;
28105   if (!arg2) {
28106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28107     return 0;
28108   }
28109   {
28110     try {
28111       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28112     } CALL_CATCH_EXCEPTION(0);
28113   }
28114
28115   jresult = (void *)result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28121   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28122   Dali::Camera::Type arg2 ;
28123
28124   arg1 = (Dali::CameraActor *)jarg1;
28125   arg2 = (Dali::Camera::Type)jarg2;
28126   {
28127     try {
28128       (arg1)->SetType(arg2);
28129     } CALL_CATCH_EXCEPTION();
28130   }
28131
28132 }
28133
28134
28135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28136   int jresult ;
28137   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28138   Dali::Camera::Type result;
28139
28140   arg1 = (Dali::CameraActor *)jarg1;
28141   {
28142     try {
28143       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28144     } CALL_CATCH_EXCEPTION(0);
28145   }
28146
28147   jresult = (int)result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28153   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28154   Dali::Camera::ProjectionMode arg2 ;
28155
28156   arg1 = (Dali::CameraActor *)jarg1;
28157   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28158   {
28159     try {
28160       (arg1)->SetProjectionMode(arg2);
28161     } CALL_CATCH_EXCEPTION();
28162   }
28163
28164 }
28165
28166
28167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28168   int jresult ;
28169   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28170   Dali::Camera::ProjectionMode result;
28171
28172   arg1 = (Dali::CameraActor *)jarg1;
28173   {
28174     try {
28175       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28176     } CALL_CATCH_EXCEPTION(0);
28177   }
28178
28179   jresult = (int)result;
28180   return jresult;
28181 }
28182
28183
28184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28185   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28186   float arg2 ;
28187
28188   arg1 = (Dali::CameraActor *)jarg1;
28189   arg2 = (float)jarg2;
28190   {
28191     try {
28192       (arg1)->SetFieldOfView(arg2);
28193     } CALL_CATCH_EXCEPTION();
28194   }
28195
28196 }
28197
28198
28199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28200   float jresult ;
28201   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28202   float result;
28203
28204   arg1 = (Dali::CameraActor *)jarg1;
28205   {
28206     try {
28207       result = (float)(arg1)->GetFieldOfView();
28208     } CALL_CATCH_EXCEPTION(0);
28209   }
28210
28211   jresult = result;
28212   return jresult;
28213 }
28214
28215
28216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28217   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28218   float arg2 ;
28219
28220   arg1 = (Dali::CameraActor *)jarg1;
28221   arg2 = (float)jarg2;
28222   {
28223     try {
28224       (arg1)->SetAspectRatio(arg2);
28225     } CALL_CATCH_EXCEPTION();
28226   }
28227
28228 }
28229
28230
28231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28232   float jresult ;
28233   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28234   float result;
28235
28236   arg1 = (Dali::CameraActor *)jarg1;
28237   {
28238     try {
28239       result = (float)(arg1)->GetAspectRatio();
28240     } CALL_CATCH_EXCEPTION(0);
28241   }
28242
28243   jresult = result;
28244   return jresult;
28245 }
28246
28247
28248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28250   float arg2 ;
28251
28252   arg1 = (Dali::CameraActor *)jarg1;
28253   arg2 = (float)jarg2;
28254   {
28255     try {
28256       (arg1)->SetNearClippingPlane(arg2);
28257     } CALL_CATCH_EXCEPTION();
28258   }
28259
28260 }
28261
28262
28263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28264   float jresult ;
28265   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28266   float result;
28267
28268   arg1 = (Dali::CameraActor *)jarg1;
28269   {
28270     try {
28271       result = (float)(arg1)->GetNearClippingPlane();
28272     } CALL_CATCH_EXCEPTION(0);
28273   }
28274
28275   jresult = result;
28276   return jresult;
28277 }
28278
28279
28280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28281   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28282   float arg2 ;
28283
28284   arg1 = (Dali::CameraActor *)jarg1;
28285   arg2 = (float)jarg2;
28286   {
28287     try {
28288       (arg1)->SetFarClippingPlane(arg2);
28289     } CALL_CATCH_EXCEPTION();
28290   }
28291
28292 }
28293
28294
28295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28296   float jresult ;
28297   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28298   float result;
28299
28300   arg1 = (Dali::CameraActor *)jarg1;
28301   {
28302     try {
28303       result = (float)(arg1)->GetFarClippingPlane();
28304     } CALL_CATCH_EXCEPTION(0);
28305   }
28306
28307   jresult = result;
28308   return jresult;
28309 }
28310
28311
28312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28313   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28314   Dali::Vector3 *arg2 = 0 ;
28315
28316   arg1 = (Dali::CameraActor *)jarg1;
28317   arg2 = (Dali::Vector3 *)jarg2;
28318   if (!arg2) {
28319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28320     return ;
28321   }
28322   {
28323     try {
28324       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28325     } CALL_CATCH_EXCEPTION();
28326   }
28327
28328 }
28329
28330
28331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28332   void * jresult ;
28333   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28334   Dali::Vector3 result;
28335
28336   arg1 = (Dali::CameraActor *)jarg1;
28337   {
28338     try {
28339       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28340     } CALL_CATCH_EXCEPTION(0);
28341   }
28342
28343   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28344   return jresult;
28345 }
28346
28347
28348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28349   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28350   bool arg2 ;
28351
28352   arg1 = (Dali::CameraActor *)jarg1;
28353   arg2 = jarg2 ? true : false;
28354   {
28355     try {
28356       (arg1)->SetInvertYAxis(arg2);
28357     } CALL_CATCH_EXCEPTION();
28358   }
28359
28360 }
28361
28362
28363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28364   unsigned int jresult ;
28365   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28366   bool result;
28367
28368   arg1 = (Dali::CameraActor *)jarg1;
28369   {
28370     try {
28371       result = (bool)(arg1)->GetInvertYAxis();
28372     } CALL_CATCH_EXCEPTION(0);
28373   }
28374
28375   jresult = result;
28376   return jresult;
28377 }
28378
28379
28380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28381   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28382   Dali::Size *arg2 = 0 ;
28383
28384   arg1 = (Dali::CameraActor *)jarg1;
28385   arg2 = (Dali::Size *)jarg2;
28386   if (!arg2) {
28387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28388     return ;
28389   }
28390   {
28391     try {
28392       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28393     } CALL_CATCH_EXCEPTION();
28394   }
28395
28396 }
28397
28398
28399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28400   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28401   Dali::Size *arg2 = 0 ;
28402
28403   arg1 = (Dali::CameraActor *)jarg1;
28404   arg2 = (Dali::Size *)jarg2;
28405   if (!arg2) {
28406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28407     return ;
28408   }
28409   {
28410     try {
28411       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28412     } CALL_CATCH_EXCEPTION();
28413   }
28414
28415 }
28416
28417
28418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28419   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28420   float arg2 ;
28421   float arg3 ;
28422   float arg4 ;
28423   float arg5 ;
28424   float arg6 ;
28425   float arg7 ;
28426
28427   arg1 = (Dali::CameraActor *)jarg1;
28428   arg2 = (float)jarg2;
28429   arg3 = (float)jarg3;
28430   arg4 = (float)jarg4;
28431   arg5 = (float)jarg5;
28432   arg6 = (float)jarg6;
28433   arg7 = (float)jarg7;
28434   {
28435     try {
28436       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28437     } CALL_CATCH_EXCEPTION();
28438   }
28439
28440 }
28441
28442
28443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28444   void * jresult ;
28445   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28446
28447   {
28448     try {
28449       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28450     } CALL_CATCH_EXCEPTION(0);
28451   }
28452
28453   jresult = (void *)result;
28454   return jresult;
28455 }
28456
28457
28458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28459   void * jresult ;
28460   std::string arg1 ;
28461   Dali::Property::Value arg2 ;
28462   Dali::Property::Value *argp2 ;
28463   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28464
28465   if (!jarg1) {
28466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28467     return 0;
28468   }
28469   (&arg1)->assign(jarg1);
28470   argp2 = (Dali::Property::Value *)jarg2;
28471   if (!argp2) {
28472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28473     return 0;
28474   }
28475   arg2 = *argp2;
28476   {
28477     try {
28478       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28479     } CALL_CATCH_EXCEPTION(0);
28480   }
28481
28482   jresult = (void *)result;
28483   return jresult;
28484 }
28485
28486
28487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28488   void * jresult ;
28489   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28490   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28491
28492   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28493   if (!arg1) {
28494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28495     return 0;
28496   }
28497   {
28498     try {
28499       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);
28500     } CALL_CATCH_EXCEPTION(0);
28501   }
28502
28503   jresult = (void *)result;
28504   return jresult;
28505 }
28506
28507
28508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28509   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28510   std::string *arg2 = 0 ;
28511
28512   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28513   if (!jarg2) {
28514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28515     return ;
28516   }
28517   std::string arg2_str(jarg2);
28518   arg2 = &arg2_str;
28519   if (arg1) (arg1)->first = *arg2;
28520
28521   //argout typemap for const std::string&
28522
28523 }
28524
28525
28526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28527   char * jresult ;
28528   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28529   std::string *result = 0 ;
28530
28531   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28532   result = (std::string *) & ((arg1)->first);
28533   jresult = SWIG_csharp_string_callback(result->c_str());
28534   return jresult;
28535 }
28536
28537
28538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28539   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28540   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28541
28542   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28543   arg2 = (Dali::Property::Value *)jarg2;
28544   if (arg1) (arg1)->second = *arg2;
28545 }
28546
28547
28548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28549   void * jresult ;
28550   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28551   Dali::Property::Value *result = 0 ;
28552
28553   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28554   result = (Dali::Property::Value *)& ((arg1)->second);
28555   jresult = (void *)result;
28556   return jresult;
28557 }
28558
28559
28560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28561   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28562
28563   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28564   {
28565     try {
28566       delete arg1;
28567     } CALL_CATCH_EXCEPTION();
28568   }
28569
28570 }
28571
28572
28573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28574   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28575
28576   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28577   {
28578     try {
28579       (arg1)->clear();
28580     } CALL_CATCH_EXCEPTION();
28581   }
28582
28583 }
28584
28585
28586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28587   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28588   Dali::TouchPoint *arg2 = 0 ;
28589
28590   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28591   arg2 = (Dali::TouchPoint *)jarg2;
28592   if (!arg2) {
28593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28594     return ;
28595   }
28596   {
28597     try {
28598       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28599     } CALL_CATCH_EXCEPTION();
28600   }
28601
28602 }
28603
28604
28605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28606   unsigned long jresult ;
28607   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28608   std::vector< Dali::TouchPoint >::size_type result;
28609
28610   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28611   {
28612     try {
28613       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28614     } CALL_CATCH_EXCEPTION(0);
28615   }
28616
28617   jresult = (unsigned long)result;
28618   return jresult;
28619 }
28620
28621
28622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
28623   unsigned long jresult ;
28624   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28625   std::vector< Dali::TouchPoint >::size_type result;
28626
28627   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28628   {
28629     try {
28630       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
28631     } CALL_CATCH_EXCEPTION(0);
28632   }
28633
28634   jresult = (unsigned long)result;
28635   return jresult;
28636 }
28637
28638
28639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28640   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28641   std::vector< Dali::TouchPoint >::size_type arg2 ;
28642
28643   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28644   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28645   {
28646     try {
28647       (arg1)->reserve(arg2);
28648     } CALL_CATCH_EXCEPTION();
28649   }
28650
28651 }
28652
28653
28654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28655   void * jresult ;
28656   std::vector< Dali::TouchPoint > *result = 0 ;
28657
28658   {
28659     try {
28660       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28661     } CALL_CATCH_EXCEPTION(0);
28662   }
28663
28664   jresult = (void *)result;
28665   return jresult;
28666 }
28667
28668
28669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28670   void * jresult ;
28671   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28672   std::vector< Dali::TouchPoint > *result = 0 ;
28673
28674   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28675   if (!arg1) {
28676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28677     return 0;
28678   }
28679   {
28680     try {
28681       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28682     } CALL_CATCH_EXCEPTION(0);
28683   }
28684
28685   jresult = (void *)result;
28686   return jresult;
28687 }
28688
28689
28690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28691   void * jresult ;
28692   int arg1 ;
28693   std::vector< Dali::TouchPoint > *result = 0 ;
28694
28695   arg1 = (int)jarg1;
28696   {
28697     try {
28698       try {
28699         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28700       }
28701       catch(std::out_of_range &_e) {
28702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28703         return 0;
28704       }
28705
28706     } CALL_CATCH_EXCEPTION(0);
28707   }
28708
28709   jresult = (void *)result;
28710   return jresult;
28711 }
28712
28713
28714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28715   void * jresult ;
28716   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28717   int arg2 ;
28718   SwigValueWrapper< Dali::TouchPoint > result;
28719
28720   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28721   arg2 = (int)jarg2;
28722   {
28723     try {
28724       try {
28725         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28726       }
28727       catch(std::out_of_range &_e) {
28728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28729         return 0;
28730       }
28731
28732     } CALL_CATCH_EXCEPTION(0);
28733   }
28734
28735   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28736   return jresult;
28737 }
28738
28739
28740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28741   void * jresult ;
28742   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28743   int arg2 ;
28744   Dali::TouchPoint *result = 0 ;
28745
28746   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28747   arg2 = (int)jarg2;
28748   {
28749     try {
28750       try {
28751         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28752       }
28753       catch(std::out_of_range &_e) {
28754         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28755         return 0;
28756       }
28757
28758     } CALL_CATCH_EXCEPTION(0);
28759   }
28760
28761   jresult = (void *)result;
28762   return jresult;
28763 }
28764
28765
28766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28767   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28768   int arg2 ;
28769   Dali::TouchPoint *arg3 = 0 ;
28770
28771   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28772   arg2 = (int)jarg2;
28773   arg3 = (Dali::TouchPoint *)jarg3;
28774   if (!arg3) {
28775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28776     return ;
28777   }
28778   {
28779     try {
28780       try {
28781         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28782       }
28783       catch(std::out_of_range &_e) {
28784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28785         return ;
28786       }
28787
28788     } CALL_CATCH_EXCEPTION();
28789   }
28790
28791 }
28792
28793
28794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28795   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28796   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28797
28798   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28799   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28800   if (!arg2) {
28801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28802     return ;
28803   }
28804   {
28805     try {
28806       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28807     } CALL_CATCH_EXCEPTION();
28808   }
28809
28810 }
28811
28812
28813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28814   void * jresult ;
28815   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28816   int arg2 ;
28817   int arg3 ;
28818   std::vector< Dali::TouchPoint > *result = 0 ;
28819
28820   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28821   arg2 = (int)jarg2;
28822   arg3 = (int)jarg3;
28823   {
28824     try {
28825       try {
28826         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28827       }
28828       catch(std::out_of_range &_e) {
28829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28830         return 0;
28831       }
28832       catch(std::invalid_argument &_e) {
28833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28834         return 0;
28835       }
28836
28837     } CALL_CATCH_EXCEPTION(0);
28838   }
28839
28840   jresult = (void *)result;
28841   return jresult;
28842 }
28843
28844
28845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28846   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28847   int arg2 ;
28848   Dali::TouchPoint *arg3 = 0 ;
28849
28850   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28851   arg2 = (int)jarg2;
28852   arg3 = (Dali::TouchPoint *)jarg3;
28853   if (!arg3) {
28854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28855     return ;
28856   }
28857   {
28858     try {
28859       try {
28860         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28861       }
28862       catch(std::out_of_range &_e) {
28863         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28864         return ;
28865       }
28866
28867     } CALL_CATCH_EXCEPTION();
28868   }
28869
28870 }
28871
28872
28873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28874   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28875   int arg2 ;
28876   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28877
28878   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28879   arg2 = (int)jarg2;
28880   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28881   if (!arg3) {
28882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28883     return ;
28884   }
28885   {
28886     try {
28887       try {
28888         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28889       }
28890       catch(std::out_of_range &_e) {
28891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28892         return ;
28893       }
28894
28895     } CALL_CATCH_EXCEPTION();
28896   }
28897
28898 }
28899
28900
28901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28902   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28903   int arg2 ;
28904
28905   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28906   arg2 = (int)jarg2;
28907   {
28908     try {
28909       try {
28910         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28911       }
28912       catch(std::out_of_range &_e) {
28913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28914         return ;
28915       }
28916
28917     } CALL_CATCH_EXCEPTION();
28918   }
28919
28920 }
28921
28922
28923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28924   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28925   int arg2 ;
28926   int arg3 ;
28927
28928   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28929   arg2 = (int)jarg2;
28930   arg3 = (int)jarg3;
28931   {
28932     try {
28933       try {
28934         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28935       }
28936       catch(std::out_of_range &_e) {
28937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28938         return ;
28939       }
28940       catch(std::invalid_argument &_e) {
28941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28942         return ;
28943       }
28944
28945     } CALL_CATCH_EXCEPTION();
28946   }
28947
28948 }
28949
28950
28951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
28952   void * jresult ;
28953   Dali::TouchPoint *arg1 = 0 ;
28954   int arg2 ;
28955   std::vector< Dali::TouchPoint > *result = 0 ;
28956
28957   arg1 = (Dali::TouchPoint *)jarg1;
28958   if (!arg1) {
28959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28960     return 0;
28961   }
28962   arg2 = (int)jarg2;
28963   {
28964     try {
28965       try {
28966         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
28967       }
28968       catch(std::out_of_range &_e) {
28969         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28970         return 0;
28971       }
28972
28973     } CALL_CATCH_EXCEPTION(0);
28974   }
28975
28976   jresult = (void *)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
28982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28983
28984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28985   {
28986     try {
28987       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
28988     } CALL_CATCH_EXCEPTION();
28989   }
28990
28991 }
28992
28993
28994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
28995   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28996   int arg2 ;
28997   int arg3 ;
28998
28999   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29000   arg2 = (int)jarg2;
29001   arg3 = (int)jarg3;
29002   {
29003     try {
29004       try {
29005         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
29006       }
29007       catch(std::out_of_range &_e) {
29008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29009         return ;
29010       }
29011       catch(std::invalid_argument &_e) {
29012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29013         return ;
29014       }
29015
29016     } CALL_CATCH_EXCEPTION();
29017   }
29018
29019 }
29020
29021
29022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
29023   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29024   int arg2 ;
29025   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29026
29027   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29028   arg2 = (int)jarg2;
29029   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29030   if (!arg3) {
29031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29032     return ;
29033   }
29034   {
29035     try {
29036       try {
29037         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29038       }
29039       catch(std::out_of_range &_e) {
29040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29041         return ;
29042       }
29043
29044     } CALL_CATCH_EXCEPTION();
29045   }
29046
29047 }
29048
29049
29050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
29051   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29052
29053   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29054   {
29055     try {
29056       delete arg1;
29057     } CALL_CATCH_EXCEPTION();
29058   }
29059
29060 }
29061
29062
29063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
29064   void * jresult ;
29065   Dali::Rect< int > *result = 0 ;
29066
29067   {
29068     try {
29069       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29070     } CALL_CATCH_EXCEPTION(0);
29071   }
29072
29073   jresult = (void *)result;
29074   return jresult;
29075 }
29076
29077
29078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29079   void * jresult ;
29080   int arg1 ;
29081   int arg2 ;
29082   int arg3 ;
29083   int arg4 ;
29084   Dali::Rect< int > *result = 0 ;
29085
29086   arg1 = (int)jarg1;
29087   arg2 = (int)jarg2;
29088   arg3 = (int)jarg3;
29089   arg4 = (int)jarg4;
29090   {
29091     try {
29092       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29093     } CALL_CATCH_EXCEPTION(0);
29094   }
29095
29096   jresult = (void *)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29102   void * jresult ;
29103   Dali::Rect< int > *arg1 = 0 ;
29104   Dali::Rect< int > *result = 0 ;
29105
29106   arg1 = (Dali::Rect< int > *)jarg1;
29107   if (!arg1) {
29108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29109     return 0;
29110   }
29111   {
29112     try {
29113       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29114     } CALL_CATCH_EXCEPTION(0);
29115   }
29116
29117   jresult = (void *)result;
29118   return jresult;
29119 }
29120
29121
29122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29123   void * jresult ;
29124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29125   Dali::Rect< int > *arg2 = 0 ;
29126   Dali::Rect< int > *result = 0 ;
29127
29128   arg1 = (Dali::Rect< int > *)jarg1;
29129   arg2 = (Dali::Rect< int > *)jarg2;
29130   if (!arg2) {
29131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29132     return 0;
29133   }
29134   {
29135     try {
29136       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29137     } CALL_CATCH_EXCEPTION(0);
29138   }
29139
29140   jresult = (void *)result;
29141   return jresult;
29142 }
29143
29144
29145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29146   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29147   int arg2 ;
29148   int arg3 ;
29149   int arg4 ;
29150   int arg5 ;
29151
29152   arg1 = (Dali::Rect< int > *)jarg1;
29153   arg2 = (int)jarg2;
29154   arg3 = (int)jarg3;
29155   arg4 = (int)jarg4;
29156   arg5 = (int)jarg5;
29157   {
29158     try {
29159       (arg1)->Set(arg2,arg3,arg4,arg5);
29160     } CALL_CATCH_EXCEPTION();
29161   }
29162
29163 }
29164
29165
29166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29167   unsigned int jresult ;
29168   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29169   bool result;
29170
29171   arg1 = (Dali::Rect< int > *)jarg1;
29172   {
29173     try {
29174       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29175     } CALL_CATCH_EXCEPTION(0);
29176   }
29177
29178   jresult = result;
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29184   int jresult ;
29185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29186   int result;
29187
29188   arg1 = (Dali::Rect< int > *)jarg1;
29189   {
29190     try {
29191       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29192     } CALL_CATCH_EXCEPTION(0);
29193   }
29194
29195   jresult = result;
29196   return jresult;
29197 }
29198
29199
29200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
29201   int jresult ;
29202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29203   int result;
29204
29205   arg1 = (Dali::Rect< int > *)jarg1;
29206   {
29207     try {
29208       result = (int)((Dali::Rect< int > const *)arg1)->Right();
29209     } CALL_CATCH_EXCEPTION(0);
29210   }
29211
29212   jresult = result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
29218   int jresult ;
29219   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29220   int result;
29221
29222   arg1 = (Dali::Rect< int > *)jarg1;
29223   {
29224     try {
29225       result = (int)((Dali::Rect< int > const *)arg1)->Top();
29226     } CALL_CATCH_EXCEPTION(0);
29227   }
29228
29229   jresult = result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
29235   int jresult ;
29236   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29237   int result;
29238
29239   arg1 = (Dali::Rect< int > *)jarg1;
29240   {
29241     try {
29242       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
29243     } CALL_CATCH_EXCEPTION(0);
29244   }
29245
29246   jresult = result;
29247   return jresult;
29248 }
29249
29250
29251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
29252   int jresult ;
29253   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29254   int result;
29255
29256   arg1 = (Dali::Rect< int > *)jarg1;
29257   {
29258     try {
29259       result = (int)((Dali::Rect< int > const *)arg1)->Area();
29260     } CALL_CATCH_EXCEPTION(0);
29261   }
29262
29263   jresult = result;
29264   return jresult;
29265 }
29266
29267
29268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29269   unsigned int jresult ;
29270   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29271   Dali::Rect< int > *arg2 = 0 ;
29272   bool result;
29273
29274   arg1 = (Dali::Rect< int > *)jarg1;
29275   arg2 = (Dali::Rect< int > *)jarg2;
29276   if (!arg2) {
29277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29278     return 0;
29279   }
29280   {
29281     try {
29282       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29283     } CALL_CATCH_EXCEPTION(0);
29284   }
29285
29286   jresult = result;
29287   return jresult;
29288 }
29289
29290
29291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29292   unsigned int jresult ;
29293   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29294   Dali::Rect< int > *arg2 = 0 ;
29295   bool result;
29296
29297   arg1 = (Dali::Rect< int > *)jarg1;
29298   arg2 = (Dali::Rect< int > *)jarg2;
29299   if (!arg2) {
29300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29301     return 0;
29302   }
29303   {
29304     try {
29305       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29306     } CALL_CATCH_EXCEPTION(0);
29307   }
29308
29309   jresult = result;
29310   return jresult;
29311 }
29312
29313
29314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29315   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29316   int arg2 ;
29317
29318   arg1 = (Dali::Rect< int > *)jarg1;
29319   arg2 = (int)jarg2;
29320   if (arg1) (arg1)->x = arg2;
29321 }
29322
29323
29324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29325   int jresult ;
29326   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29327   int result;
29328
29329   arg1 = (Dali::Rect< int > *)jarg1;
29330   result = (int) ((arg1)->x);
29331   jresult = result;
29332   return jresult;
29333 }
29334
29335
29336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29337   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29338   int arg2 ;
29339
29340   arg1 = (Dali::Rect< int > *)jarg1;
29341   arg2 = (int)jarg2;
29342   if (arg1) (arg1)->left = arg2;
29343 }
29344
29345
29346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29347   int jresult ;
29348   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29349   int result;
29350
29351   arg1 = (Dali::Rect< int > *)jarg1;
29352   result = (int) ((arg1)->left);
29353   jresult = result;
29354   return jresult;
29355 }
29356
29357
29358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29359   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29360   int arg2 ;
29361
29362   arg1 = (Dali::Rect< int > *)jarg1;
29363   arg2 = (int)jarg2;
29364   if (arg1) (arg1)->y = arg2;
29365 }
29366
29367
29368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29369   int jresult ;
29370   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29371   int result;
29372
29373   arg1 = (Dali::Rect< int > *)jarg1;
29374   result = (int) ((arg1)->y);
29375   jresult = result;
29376   return jresult;
29377 }
29378
29379
29380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29381   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29382   int arg2 ;
29383
29384   arg1 = (Dali::Rect< int > *)jarg1;
29385   arg2 = (int)jarg2;
29386   if (arg1) (arg1)->right = arg2;
29387 }
29388
29389
29390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29391   int jresult ;
29392   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29393   int result;
29394
29395   arg1 = (Dali::Rect< int > *)jarg1;
29396   result = (int) ((arg1)->right);
29397   jresult = result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29403   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29404   int arg2 ;
29405
29406   arg1 = (Dali::Rect< int > *)jarg1;
29407   arg2 = (int)jarg2;
29408   if (arg1) (arg1)->width = arg2;
29409 }
29410
29411
29412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29413   int jresult ;
29414   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29415   int result;
29416
29417   arg1 = (Dali::Rect< int > *)jarg1;
29418   result = (int) ((arg1)->width);
29419   jresult = result;
29420   return jresult;
29421 }
29422
29423
29424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29425   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29426   int arg2 ;
29427
29428   arg1 = (Dali::Rect< int > *)jarg1;
29429   arg2 = (int)jarg2;
29430   if (arg1) (arg1)->bottom = arg2;
29431 }
29432
29433
29434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29435   int jresult ;
29436   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29437   int result;
29438
29439   arg1 = (Dali::Rect< int > *)jarg1;
29440   result = (int) ((arg1)->bottom);
29441   jresult = result;
29442   return jresult;
29443 }
29444
29445
29446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29447   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29448   int arg2 ;
29449
29450   arg1 = (Dali::Rect< int > *)jarg1;
29451   arg2 = (int)jarg2;
29452   if (arg1) (arg1)->height = arg2;
29453 }
29454
29455
29456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29457   int jresult ;
29458   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29459   int result;
29460
29461   arg1 = (Dali::Rect< int > *)jarg1;
29462   result = (int) ((arg1)->height);
29463   jresult = result;
29464   return jresult;
29465 }
29466
29467
29468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29469   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29470   int arg2 ;
29471
29472   arg1 = (Dali::Rect< int > *)jarg1;
29473   arg2 = (int)jarg2;
29474   if (arg1) (arg1)->top = arg2;
29475 }
29476
29477
29478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29479   int jresult ;
29480   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29481   int result;
29482
29483   arg1 = (Dali::Rect< int > *)jarg1;
29484   result = (int) ((arg1)->top);
29485   jresult = result;
29486   return jresult;
29487 }
29488
29489
29490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29491   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29492
29493   arg1 = (Dali::Rect< int > *)jarg1;
29494   {
29495     try {
29496       delete arg1;
29497     } CALL_CATCH_EXCEPTION();
29498   }
29499
29500 }
29501
29502
29503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29504   void * jresult ;
29505   Dali::Rect< float > *result = 0 ;
29506
29507   {
29508     try {
29509       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29510     } CALL_CATCH_EXCEPTION(0);
29511   }
29512
29513   jresult = (void *)result;
29514   return jresult;
29515 }
29516
29517
29518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29519   void * jresult ;
29520   float arg1 ;
29521   float arg2 ;
29522   float arg3 ;
29523   float arg4 ;
29524   Dali::Rect< float > *result = 0 ;
29525
29526   arg1 = (float)jarg1;
29527   arg2 = (float)jarg2;
29528   arg3 = (float)jarg4;
29529   arg4 = (float)jarg3;
29530   {
29531     try {
29532       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29533     } CALL_CATCH_EXCEPTION(0);
29534   }
29535
29536   jresult = (void *)result;
29537   return jresult;
29538 }
29539
29540
29541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29542   void * jresult ;
29543   Dali::Rect< float > *arg1 = 0 ;
29544   Dali::Rect< float > *result = 0 ;
29545
29546   arg1 = (Dali::Rect< float > *)jarg1;
29547   if (!arg1) {
29548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29549     return 0;
29550   }
29551   {
29552     try {
29553       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29554     } CALL_CATCH_EXCEPTION(0);
29555   }
29556
29557   jresult = (void *)result;
29558   return jresult;
29559 }
29560
29561
29562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29563   void * jresult ;
29564   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29565   Dali::Rect< float > *arg2 = 0 ;
29566   Dali::Rect< float > *result = 0 ;
29567
29568   arg1 = (Dali::Rect< float > *)jarg1;
29569   arg2 = (Dali::Rect< float > *)jarg2;
29570   if (!arg2) {
29571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29572     return 0;
29573   }
29574   {
29575     try {
29576       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29577     } CALL_CATCH_EXCEPTION(0);
29578   }
29579
29580   jresult = (void *)result;
29581   return jresult;
29582 }
29583
29584
29585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29586   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29587   float arg2 ;
29588   float arg3 ;
29589   float arg4 ;
29590   float arg5 ;
29591
29592   arg1 = (Dali::Rect< float > *)jarg1;
29593   arg2 = (float)jarg2;
29594   arg3 = (float)jarg3;
29595   arg4 = (float)jarg5;
29596   arg5 = (float)jarg4;
29597   {
29598     try {
29599       (arg1)->Set(arg2,arg3,arg4,arg5);
29600     } CALL_CATCH_EXCEPTION();
29601   }
29602
29603 }
29604
29605
29606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29607   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29608   float arg2 ;
29609
29610   arg1 = (Dali::Rect< float > *)jarg1;
29611   arg2 = (float)jarg2;
29612   if (arg1) (arg1)->left = arg2;
29613 }
29614
29615
29616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29617   float jresult ;
29618   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29619   float result;
29620
29621   arg1 = (Dali::Rect< float > *)jarg1;
29622   result = (float) ((arg1)->left);
29623   jresult = result;
29624   return jresult;
29625 }
29626
29627
29628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29629   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29630   float arg2 ;
29631
29632   arg1 = (Dali::Rect< float > *)jarg1;
29633   arg2 = (float)jarg2;
29634   if (arg1) (arg1)->left = arg2;
29635 }
29636
29637
29638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29639   float jresult ;
29640   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29641   float result;
29642
29643   arg1 = (Dali::Rect< float > *)jarg1;
29644   result = (float) ((arg1)->left);
29645   jresult = result;
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29651   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29652   float arg2 ;
29653
29654   arg1 = (Dali::Rect< float > *)jarg1;
29655   arg2 = (float)jarg2;
29656   if (arg1) (arg1)->right = arg2;
29657 }
29658
29659
29660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29661   float jresult ;
29662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29663   float result;
29664
29665   arg1 = (Dali::Rect< float > *)jarg1;
29666   result = (float) ((arg1)->right);
29667   jresult = result;
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29673   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29674   float arg2 ;
29675
29676   arg1 = (Dali::Rect< float > *)jarg1;
29677   arg2 = (float)jarg2;
29678   if (arg1) (arg1)->right = arg2;
29679 }
29680
29681
29682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29683   float jresult ;
29684   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29685   float result;
29686
29687   arg1 = (Dali::Rect< float > *)jarg1;
29688   result = (float) ((arg1)->right);
29689   jresult = result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29695   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29696   float arg2 ;
29697
29698   arg1 = (Dali::Rect< float > *)jarg1;
29699   arg2 = (float)jarg2;
29700   if (arg1) (arg1)->bottom = arg2;
29701 }
29702
29703
29704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29705   float jresult ;
29706   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29707   float result;
29708
29709   arg1 = (Dali::Rect< float > *)jarg1;
29710   result = (float) ((arg1)->bottom);
29711   jresult = result;
29712   return jresult;
29713 }
29714
29715
29716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29717   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29718   float arg2 ;
29719
29720   arg1 = (Dali::Rect< float > *)jarg1;
29721   arg2 = (float)jarg2;
29722   if (arg1) (arg1)->top = arg2;
29723 }
29724
29725
29726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29727   float jresult ;
29728   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29729   float result;
29730
29731   arg1 = (Dali::Rect< float > *)jarg1;
29732   result = (float) ((arg1)->top);
29733   jresult = result;
29734   return jresult;
29735 }
29736
29737
29738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29739   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29740
29741   arg1 = (Dali::Rect< float > *)jarg1;
29742   {
29743     try {
29744       delete arg1;
29745     } CALL_CATCH_EXCEPTION();
29746   }
29747
29748 }
29749
29750
29751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29752   int jresult ;
29753   int result;
29754
29755   result = (int)Dali::Vector< int >::BaseType;
29756   jresult = (int)result;
29757   return jresult;
29758 }
29759
29760
29761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29762   void * jresult ;
29763   Dali::Vector< int > *result = 0 ;
29764
29765   {
29766     try {
29767       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29768     } CALL_CATCH_EXCEPTION(0);
29769   }
29770
29771   jresult = (void *)result;
29772   return jresult;
29773 }
29774
29775
29776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29777   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29778
29779   arg1 = (Dali::Vector< int > *)jarg1;
29780   {
29781     try {
29782       delete arg1;
29783     } CALL_CATCH_EXCEPTION();
29784   }
29785
29786 }
29787
29788
29789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29790   void * jresult ;
29791   Dali::Vector< int > *arg1 = 0 ;
29792   Dali::Vector< int > *result = 0 ;
29793
29794   arg1 = (Dali::Vector< int > *)jarg1;
29795   if (!arg1) {
29796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29797     return 0;
29798   }
29799   {
29800     try {
29801       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29802     } CALL_CATCH_EXCEPTION(0);
29803   }
29804
29805   jresult = (void *)result;
29806   return jresult;
29807 }
29808
29809
29810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29811   void * jresult ;
29812   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29813   Dali::Vector< int > *arg2 = 0 ;
29814   Dali::Vector< int > *result = 0 ;
29815
29816   arg1 = (Dali::Vector< int > *)jarg1;
29817   arg2 = (Dali::Vector< int > *)jarg2;
29818   if (!arg2) {
29819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29820     return 0;
29821   }
29822   {
29823     try {
29824       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29825     } CALL_CATCH_EXCEPTION(0);
29826   }
29827
29828   jresult = (void *)result;
29829   return jresult;
29830 }
29831
29832
29833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29834   void * jresult ;
29835   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29836   Dali::Vector< int >::Iterator result;
29837
29838   arg1 = (Dali::Vector< int > *)jarg1;
29839   {
29840     try {
29841       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29842     } CALL_CATCH_EXCEPTION(0);
29843   }
29844
29845   jresult = (void *)result;
29846   return jresult;
29847 }
29848
29849
29850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
29851   void * jresult ;
29852   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29853   Dali::Vector< int >::Iterator result;
29854
29855   arg1 = (Dali::Vector< int > *)jarg1;
29856   {
29857     try {
29858       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
29859     } CALL_CATCH_EXCEPTION(0);
29860   }
29861
29862   jresult = (void *)result;
29863   return jresult;
29864 }
29865
29866
29867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29868   void * jresult ;
29869   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29870   Dali::Vector< int >::SizeType arg2 ;
29871   Dali::Vector< int >::ItemType *result = 0 ;
29872
29873   arg1 = (Dali::Vector< int > *)jarg1;
29874   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29875   {
29876     try {
29877       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29878     } CALL_CATCH_EXCEPTION(0);
29879   }
29880
29881   jresult = (void *)result;
29882   return jresult;
29883 }
29884
29885
29886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29887   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29888   Dali::Vector< int >::ItemType *arg2 = 0 ;
29889   Dali::Vector< int >::ItemType temp2 ;
29890
29891   arg1 = (Dali::Vector< int > *)jarg1;
29892   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29893   arg2 = &temp2;
29894   {
29895     try {
29896       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29897     } CALL_CATCH_EXCEPTION();
29898   }
29899
29900 }
29901
29902
29903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29904   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29905   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29906   Dali::Vector< int >::ItemType *arg3 = 0 ;
29907   Dali::Vector< int >::ItemType temp3 ;
29908
29909   arg1 = (Dali::Vector< int > *)jarg1;
29910   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29911   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29912   arg3 = &temp3;
29913   {
29914     try {
29915       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29916     } CALL_CATCH_EXCEPTION();
29917   }
29918
29919 }
29920
29921
29922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29923   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29924   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29925   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29926   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29927
29928   arg1 = (Dali::Vector< int > *)jarg1;
29929   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29930   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29931   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29932   {
29933     try {
29934       (arg1)->Insert(arg2,arg3,arg4);
29935     } CALL_CATCH_EXCEPTION();
29936   }
29937
29938 }
29939
29940
29941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29942   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29943   Dali::Vector< int >::SizeType arg2 ;
29944
29945   arg1 = (Dali::Vector< int > *)jarg1;
29946   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29947   {
29948     try {
29949       (arg1)->Reserve(arg2);
29950     } CALL_CATCH_EXCEPTION();
29951   }
29952
29953 }
29954
29955
29956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
29957   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29958   Dali::Vector< int >::SizeType arg2 ;
29959
29960   arg1 = (Dali::Vector< int > *)jarg1;
29961   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29962   {
29963     try {
29964       (arg1)->Resize(arg2);
29965     } CALL_CATCH_EXCEPTION();
29966   }
29967
29968 }
29969
29970
29971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
29972   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29973   Dali::Vector< int >::SizeType arg2 ;
29974   Dali::Vector< int >::ItemType *arg3 = 0 ;
29975   Dali::Vector< int >::ItemType temp3 ;
29976
29977   arg1 = (Dali::Vector< int > *)jarg1;
29978   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29979   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29980   arg3 = &temp3;
29981   {
29982     try {
29983       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29984     } CALL_CATCH_EXCEPTION();
29985   }
29986
29987 }
29988
29989
29990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
29991   void * jresult ;
29992   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29993   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29994   Dali::Vector< int >::Iterator result;
29995
29996   arg1 = (Dali::Vector< int > *)jarg1;
29997   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29998   {
29999     try {
30000       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
30001     } CALL_CATCH_EXCEPTION(0);
30002   }
30003
30004   jresult = (void *)result;
30005   return jresult;
30006 }
30007
30008
30009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30010   void * jresult ;
30011   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30012   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30013   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30014   Dali::Vector< int >::Iterator result;
30015
30016   arg1 = (Dali::Vector< int > *)jarg1;
30017   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30018   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30019   {
30020     try {
30021       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
30022     } CALL_CATCH_EXCEPTION(0);
30023   }
30024
30025   jresult = (void *)result;
30026   return jresult;
30027 }
30028
30029
30030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
30031   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30032   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30033
30034   arg1 = (Dali::Vector< int > *)jarg1;
30035   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30036   {
30037     try {
30038       (arg1)->Remove(arg2);
30039     } CALL_CATCH_EXCEPTION();
30040   }
30041
30042 }
30043
30044
30045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
30046   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30047   Dali::Vector< int > *arg2 = 0 ;
30048
30049   arg1 = (Dali::Vector< int > *)jarg1;
30050   arg2 = (Dali::Vector< int > *)jarg2;
30051   if (!arg2) {
30052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
30053     return ;
30054   }
30055   {
30056     try {
30057       (arg1)->Swap(*arg2);
30058     } CALL_CATCH_EXCEPTION();
30059   }
30060
30061 }
30062
30063
30064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30065   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30066
30067   arg1 = (Dali::Vector< int > *)jarg1;
30068   {
30069     try {
30070       (arg1)->Clear();
30071     } CALL_CATCH_EXCEPTION();
30072   }
30073
30074 }
30075
30076
30077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30078   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30079
30080   arg1 = (Dali::Vector< int > *)jarg1;
30081   {
30082     try {
30083       (arg1)->Release();
30084     } CALL_CATCH_EXCEPTION();
30085   }
30086
30087 }
30088
30089
30090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30091   int jresult ;
30092   int result;
30093
30094   result = (int)Dali::Vector< float >::BaseType;
30095   jresult = (int)result;
30096   return jresult;
30097 }
30098
30099
30100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30101   void * jresult ;
30102   Dali::Vector< float > *result = 0 ;
30103
30104   {
30105     try {
30106       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30107     } CALL_CATCH_EXCEPTION(0);
30108   }
30109
30110   jresult = (void *)result;
30111   return jresult;
30112 }
30113
30114
30115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30116   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30117
30118   arg1 = (Dali::Vector< float > *)jarg1;
30119   {
30120     try {
30121       delete arg1;
30122     } CALL_CATCH_EXCEPTION();
30123   }
30124
30125 }
30126
30127
30128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30129   void * jresult ;
30130   Dali::Vector< float > *arg1 = 0 ;
30131   Dali::Vector< float > *result = 0 ;
30132
30133   arg1 = (Dali::Vector< float > *)jarg1;
30134   if (!arg1) {
30135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30136     return 0;
30137   }
30138   {
30139     try {
30140       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30141     } CALL_CATCH_EXCEPTION(0);
30142   }
30143
30144   jresult = (void *)result;
30145   return jresult;
30146 }
30147
30148
30149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30150   void * jresult ;
30151   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30152   Dali::Vector< float > *arg2 = 0 ;
30153   Dali::Vector< float > *result = 0 ;
30154
30155   arg1 = (Dali::Vector< float > *)jarg1;
30156   arg2 = (Dali::Vector< float > *)jarg2;
30157   if (!arg2) {
30158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30159     return 0;
30160   }
30161   {
30162     try {
30163       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30164     } CALL_CATCH_EXCEPTION(0);
30165   }
30166
30167   jresult = (void *)result;
30168   return jresult;
30169 }
30170
30171
30172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30173   void * jresult ;
30174   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30175   Dali::Vector< float >::Iterator result;
30176
30177   arg1 = (Dali::Vector< float > *)jarg1;
30178   {
30179     try {
30180       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30181     } CALL_CATCH_EXCEPTION(0);
30182   }
30183
30184   jresult = (void *)result;
30185   return jresult;
30186 }
30187
30188
30189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
30190   void * jresult ;
30191   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30192   Dali::Vector< float >::Iterator result;
30193
30194   arg1 = (Dali::Vector< float > *)jarg1;
30195   {
30196     try {
30197       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
30198     } CALL_CATCH_EXCEPTION(0);
30199   }
30200
30201   jresult = (void *)result;
30202   return jresult;
30203 }
30204
30205
30206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30207   void * jresult ;
30208   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30209   Dali::Vector< float >::SizeType arg2 ;
30210   Dali::Vector< float >::ItemType *result = 0 ;
30211
30212   arg1 = (Dali::Vector< float > *)jarg1;
30213   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30214   {
30215     try {
30216       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30217     } CALL_CATCH_EXCEPTION(0);
30218   }
30219
30220   jresult = (void *)result;
30221   return jresult;
30222 }
30223
30224
30225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30226   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30227   Dali::Vector< float >::ItemType *arg2 = 0 ;
30228   Dali::Vector< float >::ItemType temp2 ;
30229
30230   arg1 = (Dali::Vector< float > *)jarg1;
30231   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30232   arg2 = &temp2;
30233   {
30234     try {
30235       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30236     } CALL_CATCH_EXCEPTION();
30237   }
30238
30239 }
30240
30241
30242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30243   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30244   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30245   Dali::Vector< float >::ItemType *arg3 = 0 ;
30246   Dali::Vector< float >::ItemType temp3 ;
30247
30248   arg1 = (Dali::Vector< float > *)jarg1;
30249   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30250   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30251   arg3 = &temp3;
30252   {
30253     try {
30254       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30255     } CALL_CATCH_EXCEPTION();
30256   }
30257
30258 }
30259
30260
30261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30262   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30263   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30264   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30265   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30266
30267   arg1 = (Dali::Vector< float > *)jarg1;
30268   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30269   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30270   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30271   {
30272     try {
30273       (arg1)->Insert(arg2,arg3,arg4);
30274     } CALL_CATCH_EXCEPTION();
30275   }
30276
30277 }
30278
30279
30280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30282   Dali::Vector< float >::SizeType arg2 ;
30283
30284   arg1 = (Dali::Vector< float > *)jarg1;
30285   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30286   {
30287     try {
30288       (arg1)->Reserve(arg2);
30289     } CALL_CATCH_EXCEPTION();
30290   }
30291
30292 }
30293
30294 //// ========================= end of part 2 =============================
30295
30296 //// ========================== start part 3 ===============================
30297
30298
30299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30300   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30301   Dali::Vector< float >::SizeType arg2 ;
30302
30303   arg1 = (Dali::Vector< float > *)jarg1;
30304   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30305   {
30306     try {
30307       (arg1)->Resize(arg2);
30308     } CALL_CATCH_EXCEPTION();
30309   }
30310
30311 }
30312
30313
30314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30315   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30316   Dali::Vector< float >::SizeType arg2 ;
30317   Dali::Vector< float >::ItemType *arg3 = 0 ;
30318   Dali::Vector< float >::ItemType temp3 ;
30319
30320   arg1 = (Dali::Vector< float > *)jarg1;
30321   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30322   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30323   arg3 = &temp3;
30324   {
30325     try {
30326       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30327     } CALL_CATCH_EXCEPTION();
30328   }
30329
30330 }
30331
30332
30333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30334   void * jresult ;
30335   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30336   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30337   Dali::Vector< float >::Iterator result;
30338
30339   arg1 = (Dali::Vector< float > *)jarg1;
30340   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30341   {
30342     try {
30343       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30344     } CALL_CATCH_EXCEPTION(0);
30345   }
30346
30347   jresult = (void *)result;
30348   return jresult;
30349 }
30350
30351
30352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30353   void * jresult ;
30354   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30355   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30356   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30357   Dali::Vector< float >::Iterator result;
30358
30359   arg1 = (Dali::Vector< float > *)jarg1;
30360   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30361   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30362   {
30363     try {
30364       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30365     } CALL_CATCH_EXCEPTION(0);
30366   }
30367
30368   jresult = (void *)result;
30369   return jresult;
30370 }
30371
30372
30373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30374   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30375   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30376
30377   arg1 = (Dali::Vector< float > *)jarg1;
30378   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30379   {
30380     try {
30381       (arg1)->Remove(arg2);
30382     } CALL_CATCH_EXCEPTION();
30383   }
30384
30385 }
30386
30387
30388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30389   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30390   Dali::Vector< float > *arg2 = 0 ;
30391
30392   arg1 = (Dali::Vector< float > *)jarg1;
30393   arg2 = (Dali::Vector< float > *)jarg2;
30394   if (!arg2) {
30395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30396     return ;
30397   }
30398   {
30399     try {
30400       (arg1)->Swap(*arg2);
30401     } CALL_CATCH_EXCEPTION();
30402   }
30403
30404 }
30405
30406
30407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30408   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30409
30410   arg1 = (Dali::Vector< float > *)jarg1;
30411   {
30412     try {
30413       (arg1)->Clear();
30414     } CALL_CATCH_EXCEPTION();
30415   }
30416
30417 }
30418
30419
30420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30421   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30422
30423   arg1 = (Dali::Vector< float > *)jarg1;
30424   {
30425     try {
30426       (arg1)->Release();
30427     } CALL_CATCH_EXCEPTION();
30428   }
30429
30430 }
30431
30432
30433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30434   int jresult ;
30435   int result;
30436
30437   result = (int)Dali::Vector< unsigned char >::BaseType;
30438   jresult = (int)result;
30439   return jresult;
30440 }
30441
30442
30443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30444   void * jresult ;
30445   Dali::Vector< unsigned char > *result = 0 ;
30446
30447   {
30448     try {
30449       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30450     } CALL_CATCH_EXCEPTION(0);
30451   }
30452
30453   jresult = (void *)result;
30454   return jresult;
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30459   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30460
30461   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30462   {
30463     try {
30464       delete arg1;
30465     } CALL_CATCH_EXCEPTION();
30466   }
30467
30468 }
30469
30470
30471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30472   void * jresult ;
30473   Dali::Vector< unsigned char > *arg1 = 0 ;
30474   Dali::Vector< unsigned char > *result = 0 ;
30475
30476   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30477   if (!arg1) {
30478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30479     return 0;
30480   }
30481   {
30482     try {
30483       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30484     } CALL_CATCH_EXCEPTION(0);
30485   }
30486
30487   jresult = (void *)result;
30488   return jresult;
30489 }
30490
30491
30492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30493   void * jresult ;
30494   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30495   Dali::Vector< unsigned char > *arg2 = 0 ;
30496   Dali::Vector< unsigned char > *result = 0 ;
30497
30498   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30499   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30500   if (!arg2) {
30501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30502     return 0;
30503   }
30504   {
30505     try {
30506       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30507     } CALL_CATCH_EXCEPTION(0);
30508   }
30509
30510   jresult = (void *)result;
30511   return jresult;
30512 }
30513
30514
30515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30516   void * jresult ;
30517   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30518   Dali::Vector< unsigned char >::Iterator result;
30519
30520   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30521   {
30522     try {
30523       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30524     } CALL_CATCH_EXCEPTION(0);
30525   }
30526
30527   jresult = (void *)result;
30528   return jresult;
30529 }
30530
30531
30532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
30533   void * jresult ;
30534   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30535   Dali::Vector< unsigned char >::Iterator result;
30536
30537   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30538   {
30539     try {
30540       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
30541     } CALL_CATCH_EXCEPTION(0);
30542   }
30543
30544   jresult = (void *)result;
30545   return jresult;
30546 }
30547
30548
30549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30550   void * jresult ;
30551   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30552   Dali::Vector< unsigned char >::SizeType arg2 ;
30553   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30554
30555   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30556   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30557   {
30558     try {
30559       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30560     } CALL_CATCH_EXCEPTION(0);
30561   }
30562
30563   jresult = (void *)result;
30564   return jresult;
30565 }
30566
30567
30568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30569   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30570   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30571   Dali::Vector< unsigned char >::ItemType temp2 ;
30572
30573   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30574   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30575   arg2 = &temp2;
30576   {
30577     try {
30578       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30579     } CALL_CATCH_EXCEPTION();
30580   }
30581
30582 }
30583
30584
30585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30586   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30587   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30588   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30589   Dali::Vector< unsigned char >::ItemType temp3 ;
30590
30591   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30592   arg2 = jarg2;
30593   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30594   arg3 = &temp3;
30595   {
30596     try {
30597       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30598     } CALL_CATCH_EXCEPTION();
30599   }
30600
30601
30602
30603 }
30604
30605
30606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30607   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30608   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30609   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30610   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30611
30612   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30613   arg2 = jarg2;
30614   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30615   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30616   {
30617     try {
30618       (arg1)->Insert(arg2,arg3,arg4);
30619     } CALL_CATCH_EXCEPTION();
30620   }
30621
30622
30623
30624 }
30625
30626
30627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30628   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30629   Dali::Vector< unsigned char >::SizeType arg2 ;
30630
30631   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30632   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30633   {
30634     try {
30635       (arg1)->Reserve(arg2);
30636     } CALL_CATCH_EXCEPTION();
30637   }
30638
30639 }
30640
30641
30642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30643   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30644   Dali::Vector< unsigned char >::SizeType arg2 ;
30645
30646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30647   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30648   {
30649     try {
30650       (arg1)->Resize(arg2);
30651     } CALL_CATCH_EXCEPTION();
30652   }
30653
30654 }
30655
30656
30657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30658   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30659   Dali::Vector< unsigned char >::SizeType arg2 ;
30660   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30661   Dali::Vector< unsigned char >::ItemType temp3 ;
30662
30663   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30664   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30665   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30666   arg3 = &temp3;
30667   {
30668     try {
30669       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30670     } CALL_CATCH_EXCEPTION();
30671   }
30672
30673 }
30674
30675
30676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30677   void * jresult ;
30678   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30679   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30680   Dali::Vector< unsigned char >::Iterator result;
30681
30682   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30683   arg2 = jarg2;
30684   {
30685     try {
30686       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30687     } CALL_CATCH_EXCEPTION(0);
30688   }
30689
30690   jresult = (void *)result;
30691
30692
30693   return jresult;
30694 }
30695
30696
30697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30698   void * jresult ;
30699   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30700   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30701   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30702   Dali::Vector< unsigned char >::Iterator result;
30703
30704   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30705   arg2 = jarg2;
30706   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30707   {
30708     try {
30709       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30710     } CALL_CATCH_EXCEPTION(0);
30711   }
30712
30713   jresult = (void *)result;
30714
30715
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30722   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30723
30724   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30725   arg2 = jarg2;
30726   {
30727     try {
30728       (arg1)->Remove(arg2);
30729     } CALL_CATCH_EXCEPTION();
30730   }
30731
30732
30733
30734 }
30735
30736
30737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30738   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30739   Dali::Vector< unsigned char > *arg2 = 0 ;
30740
30741   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30742   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30743   if (!arg2) {
30744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30745     return ;
30746   }
30747   {
30748     try {
30749       (arg1)->Swap(*arg2);
30750     } CALL_CATCH_EXCEPTION();
30751   }
30752
30753 }
30754
30755
30756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30757   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30758
30759   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30760   {
30761     try {
30762       (arg1)->Clear();
30763     } CALL_CATCH_EXCEPTION();
30764   }
30765
30766 }
30767
30768
30769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30770   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30771
30772   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30773   {
30774     try {
30775       (arg1)->Release();
30776     } CALL_CATCH_EXCEPTION();
30777   }
30778
30779 }
30780
30781
30782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30783   int jresult ;
30784   int result;
30785
30786   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30787   jresult = (int)result;
30788   return jresult;
30789 }
30790
30791
30792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30793   void * jresult ;
30794   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30795
30796   {
30797     try {
30798       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30799     } CALL_CATCH_EXCEPTION(0);
30800   }
30801
30802   jresult = (void *)result;
30803   return jresult;
30804 }
30805
30806
30807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30808   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30809
30810   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30811   {
30812     try {
30813       delete arg1;
30814     } CALL_CATCH_EXCEPTION();
30815   }
30816
30817 }
30818
30819
30820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30821   void * jresult ;
30822   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30823   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30824
30825   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30826   if (!arg1) {
30827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30828     return 0;
30829   }
30830   {
30831     try {
30832       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30833     } CALL_CATCH_EXCEPTION(0);
30834   }
30835
30836   jresult = (void *)result;
30837   return jresult;
30838 }
30839
30840
30841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30842   void * jresult ;
30843   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30844   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30845   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30846
30847   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30848   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30849   if (!arg2) {
30850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30851     return 0;
30852   }
30853   {
30854     try {
30855       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30856     } CALL_CATCH_EXCEPTION(0);
30857   }
30858
30859   jresult = (void *)result;
30860   return jresult;
30861 }
30862
30863
30864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30865   void * jresult ;
30866   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30867   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30868
30869   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30870   {
30871     try {
30872       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30873     } CALL_CATCH_EXCEPTION(0);
30874   }
30875
30876   jresult = (void *)result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
30882   void * jresult ;
30883   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30884   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30885
30886   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30887   {
30888     try {
30889       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
30890     } CALL_CATCH_EXCEPTION(0);
30891   }
30892
30893   jresult = (void *)result;
30894   return jresult;
30895 }
30896
30897
30898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30899   void * jresult ;
30900   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30901   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30902   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30903
30904   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30905   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30906   {
30907     try {
30908       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30909     } CALL_CATCH_EXCEPTION(0);
30910   }
30911
30912   jresult = (void *)result;
30913   return jresult;
30914 }
30915
30916
30917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30918   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30919   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30920
30921   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30922   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30923   if (!arg2) {
30924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30925     return ;
30926   }
30927   {
30928     try {
30929       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30930     } CALL_CATCH_EXCEPTION();
30931   }
30932
30933 }
30934
30935
30936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30937   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30938   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30939   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30940
30941   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30942   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30943   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30944   if (!arg3) {
30945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30946     return ;
30947   }
30948   {
30949     try {
30950       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30951     } CALL_CATCH_EXCEPTION();
30952   }
30953
30954 }
30955
30956
30957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30958   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30959   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30960   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30961   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30962
30963   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30964   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30965   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30966   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
30967   {
30968     try {
30969       (arg1)->Insert(arg2,arg3,arg4);
30970     } CALL_CATCH_EXCEPTION();
30971   }
30972
30973 }
30974
30975
30976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
30977   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30978   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30979
30980   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30981   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30982   {
30983     try {
30984       (arg1)->Reserve(arg2);
30985     } CALL_CATCH_EXCEPTION();
30986   }
30987
30988 }
30989
30990
30991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30992   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30993   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30994
30995   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30996   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30997   {
30998     try {
30999       (arg1)->Resize(arg2);
31000     } CALL_CATCH_EXCEPTION();
31001   }
31002
31003 }
31004
31005
31006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
31007   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31008   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31009   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31010
31011   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31012   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31013   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31014   if (!arg3) {
31015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31016     return ;
31017   }
31018   {
31019     try {
31020       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31021     } CALL_CATCH_EXCEPTION();
31022   }
31023
31024 }
31025
31026
31027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
31028   void * jresult ;
31029   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31030   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31031   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31032
31033   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31034   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31035   {
31036     try {
31037       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
31038     } CALL_CATCH_EXCEPTION(0);
31039   }
31040
31041   jresult = (void *)result;
31042   return jresult;
31043 }
31044
31045
31046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31047   void * jresult ;
31048   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31049   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31050   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31051   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31052
31053   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31054   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31055   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31056   {
31057     try {
31058       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
31059     } CALL_CATCH_EXCEPTION(0);
31060   }
31061
31062   jresult = (void *)result;
31063   return jresult;
31064 }
31065
31066
31067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31068   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31069   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31070
31071   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31072   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31073   {
31074     try {
31075       (arg1)->Remove(arg2);
31076     } CALL_CATCH_EXCEPTION();
31077   }
31078
31079 }
31080
31081
31082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31083   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31084   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31085
31086   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31087   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31088   if (!arg2) {
31089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31090     return ;
31091   }
31092   {
31093     try {
31094       (arg1)->Swap(*arg2);
31095     } CALL_CATCH_EXCEPTION();
31096   }
31097
31098 }
31099
31100
31101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31102   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31103
31104   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31105   {
31106     try {
31107       (arg1)->Clear();
31108     } CALL_CATCH_EXCEPTION();
31109   }
31110
31111 }
31112
31113
31114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31115   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31116
31117   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31118   {
31119     try {
31120       (arg1)->Release();
31121     } CALL_CATCH_EXCEPTION();
31122   }
31123
31124 }
31125
31126
31127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31128   void * jresult ;
31129   Dali::Signal< void () > *result = 0 ;
31130
31131   {
31132     try {
31133       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31134     } CALL_CATCH_EXCEPTION(0);
31135   }
31136
31137   jresult = (void *)result;
31138   return jresult;
31139 }
31140
31141
31142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31143   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31144
31145   arg1 = (Dali::Signal< void () > *)jarg1;
31146   {
31147     try {
31148       delete arg1;
31149     } CALL_CATCH_EXCEPTION();
31150   }
31151
31152 }
31153
31154
31155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31156   unsigned int jresult ;
31157   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31158   bool result;
31159
31160   arg1 = (Dali::Signal< void () > *)jarg1;
31161   {
31162     try {
31163       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31164     } CALL_CATCH_EXCEPTION(0);
31165   }
31166
31167   jresult = result;
31168   return jresult;
31169 }
31170
31171
31172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31173   unsigned long jresult ;
31174   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31175   std::size_t result;
31176
31177   arg1 = (Dali::Signal< void () > *)jarg1;
31178   {
31179     try {
31180       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31181     } CALL_CATCH_EXCEPTION(0);
31182   }
31183
31184   jresult = (unsigned long)result;
31185   return jresult;
31186 }
31187
31188
31189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31190   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31191   void (*arg2)() = (void (*)()) 0 ;
31192
31193   arg1 = (Dali::Signal< void () > *)jarg1;
31194   arg2 = (void (*)())jarg2;
31195   {
31196     try {
31197       (arg1)->Connect(arg2);
31198     } CALL_CATCH_EXCEPTION();
31199   }
31200
31201 }
31202
31203
31204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31205   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31206   void (*arg2)() = (void (*)()) 0 ;
31207
31208   arg1 = (Dali::Signal< void () > *)jarg1;
31209   arg2 = (void (*)())jarg2;
31210   {
31211     try {
31212       (arg1)->Disconnect(arg2);
31213     } CALL_CATCH_EXCEPTION();
31214   }
31215
31216 }
31217
31218
31219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31220   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31221   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31222   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31223
31224   arg1 = (Dali::Signal< void () > *)jarg1;
31225   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31226   arg3 = (Dali::FunctorDelegate *)jarg3;
31227   {
31228     try {
31229       (arg1)->Connect(arg2,arg3);
31230     } CALL_CATCH_EXCEPTION();
31231   }
31232
31233 }
31234
31235
31236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31237   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31238
31239   arg1 = (Dali::Signal< void () > *)jarg1;
31240   {
31241     try {
31242       (arg1)->Emit();
31243     } CALL_CATCH_EXCEPTION();
31244   }
31245
31246 }
31247
31248
31249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31250   unsigned int jresult ;
31251   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31252   bool result;
31253
31254   arg1 = (Dali::Signal< void (float) > *)jarg1;
31255   {
31256     try {
31257       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31258     } CALL_CATCH_EXCEPTION(0);
31259   }
31260
31261   jresult = result;
31262   return jresult;
31263 }
31264
31265
31266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31267   unsigned long jresult ;
31268   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31269   std::size_t result;
31270
31271   arg1 = (Dali::Signal< void (float) > *)jarg1;
31272   {
31273     try {
31274       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31275     } CALL_CATCH_EXCEPTION(0);
31276   }
31277
31278   jresult = (unsigned long)result;
31279   return jresult;
31280 }
31281
31282
31283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31284   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31285   void (*arg2)(float) = (void (*)(float)) 0 ;
31286
31287   arg1 = (Dali::Signal< void (float) > *)jarg1;
31288   arg2 = (void (*)(float))jarg2;
31289   {
31290     try {
31291       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31292     } CALL_CATCH_EXCEPTION();
31293   }
31294
31295 }
31296
31297
31298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31299   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31300   void (*arg2)(float) = (void (*)(float)) 0 ;
31301
31302   arg1 = (Dali::Signal< void (float) > *)jarg1;
31303   arg2 = (void (*)(float))jarg2;
31304   {
31305     try {
31306       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31307     } CALL_CATCH_EXCEPTION();
31308   }
31309
31310 }
31311
31312
31313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31314   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31315   float arg2 ;
31316
31317   arg1 = (Dali::Signal< void (float) > *)jarg1;
31318   arg2 = (float)jarg2;
31319   {
31320     try {
31321       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31322     } CALL_CATCH_EXCEPTION();
31323   }
31324
31325 }
31326
31327
31328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31329   void * jresult ;
31330   Dali::Signal< void (float) > *result = 0 ;
31331
31332   {
31333     try {
31334       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31335     } CALL_CATCH_EXCEPTION(0);
31336   }
31337
31338   jresult = (void *)result;
31339   return jresult;
31340 }
31341
31342
31343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31344   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31345
31346   arg1 = (Dali::Signal< void (float) > *)jarg1;
31347   {
31348     try {
31349       delete arg1;
31350     } CALL_CATCH_EXCEPTION();
31351   }
31352
31353 }
31354
31355
31356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31357   unsigned int jresult ;
31358   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31359   bool result;
31360
31361   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31362   {
31363     try {
31364       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31365     } CALL_CATCH_EXCEPTION(0);
31366   }
31367
31368   jresult = result;
31369   return jresult;
31370 }
31371
31372
31373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31374   unsigned long jresult ;
31375   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31376   std::size_t result;
31377
31378   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31379   {
31380     try {
31381       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31382     } CALL_CATCH_EXCEPTION(0);
31383   }
31384
31385   jresult = (unsigned long)result;
31386   return jresult;
31387 }
31388
31389
31390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31391   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31392   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31393
31394   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31395   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31396   {
31397     try {
31398       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31399     } CALL_CATCH_EXCEPTION();
31400   }
31401
31402 }
31403
31404
31405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31406   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31407   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31408
31409   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31410   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31411   {
31412     try {
31413       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31414     } CALL_CATCH_EXCEPTION();
31415   }
31416
31417 }
31418
31419
31420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31421   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31422   Dali::BaseHandle arg2 ;
31423   Dali::BaseHandle *argp2 ;
31424
31425   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31426   argp2 = (Dali::BaseHandle *)jarg2;
31427   if (!argp2) {
31428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31429     return ;
31430   }
31431   arg2 = *argp2;
31432   {
31433     try {
31434       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31435     } CALL_CATCH_EXCEPTION();
31436   }
31437
31438 }
31439
31440
31441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31442   void * jresult ;
31443   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31444
31445   {
31446     try {
31447       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31448     } CALL_CATCH_EXCEPTION(0);
31449   }
31450
31451   jresult = (void *)result;
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31457   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31458
31459   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31460   {
31461     try {
31462       delete arg1;
31463     } CALL_CATCH_EXCEPTION();
31464   }
31465
31466 }
31467
31468
31469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31470   unsigned int jresult ;
31471   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31472   bool result;
31473
31474   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31475   {
31476     try {
31477       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31478     } CALL_CATCH_EXCEPTION(0);
31479   }
31480
31481   jresult = result;
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31487   unsigned long jresult ;
31488   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31489   std::size_t result;
31490
31491   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31492   {
31493     try {
31494       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31495     } CALL_CATCH_EXCEPTION(0);
31496   }
31497
31498   jresult = (unsigned long)result;
31499   return jresult;
31500 }
31501
31502
31503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31504   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31505   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31506
31507   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31508   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31509   {
31510     try {
31511       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31512     } CALL_CATCH_EXCEPTION();
31513   }
31514
31515 }
31516
31517
31518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31519   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31520   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31521
31522   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31523   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31524   {
31525     try {
31526       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31527     } CALL_CATCH_EXCEPTION();
31528   }
31529
31530 }
31531
31532
31533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31534   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31535   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31536
31537   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31538   arg2 = (Dali::RefObject *)jarg2;
31539   {
31540     try {
31541       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31542     } CALL_CATCH_EXCEPTION();
31543   }
31544
31545 }
31546
31547
31548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31549   void * jresult ;
31550   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31551
31552   {
31553     try {
31554       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31555     } CALL_CATCH_EXCEPTION(0);
31556   }
31557
31558   jresult = (void *)result;
31559   return jresult;
31560 }
31561
31562
31563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31564   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31565
31566   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31567   {
31568     try {
31569       delete arg1;
31570     } CALL_CATCH_EXCEPTION();
31571   }
31572
31573 }
31574
31575
31576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31577   unsigned int jresult ;
31578   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31579   bool result;
31580
31581   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31582   {
31583     try {
31584       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31585     } CALL_CATCH_EXCEPTION(0);
31586   }
31587
31588   jresult = result;
31589   return jresult;
31590 }
31591
31592
31593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31594   unsigned long jresult ;
31595   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31596   std::size_t result;
31597
31598   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31599   {
31600     try {
31601       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31602     } CALL_CATCH_EXCEPTION(0);
31603   }
31604
31605   jresult = (unsigned long)result;
31606   return jresult;
31607 }
31608
31609
31610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31611   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31612   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31613
31614   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31615   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31616   {
31617     try {
31618       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31619     } CALL_CATCH_EXCEPTION();
31620   }
31621
31622 }
31623
31624
31625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31626   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31627   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31628
31629   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31630   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31631   {
31632     try {
31633       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31634     } CALL_CATCH_EXCEPTION();
31635   }
31636
31637 }
31638
31639
31640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31641   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31642   Dali::PropertyNotification *arg2 = 0 ;
31643
31644   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31645   arg2 = (Dali::PropertyNotification *)jarg2;
31646   if (!arg2) {
31647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31648     return ;
31649   }
31650   {
31651     try {
31652       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31653     } CALL_CATCH_EXCEPTION();
31654   }
31655
31656 }
31657
31658
31659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31660   void * jresult ;
31661   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31662
31663   {
31664     try {
31665       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31666     } CALL_CATCH_EXCEPTION(0);
31667   }
31668
31669   jresult = (void *)result;
31670   return jresult;
31671 }
31672
31673
31674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31675   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31676
31677   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31678   {
31679     try {
31680       delete arg1;
31681     } CALL_CATCH_EXCEPTION();
31682   }
31683
31684 }
31685
31686
31687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31688   void * jresult ;
31689   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31690
31691   {
31692     try {
31693       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31694     } CALL_CATCH_EXCEPTION(0);
31695   }
31696
31697   jresult = (void *)result;
31698   return jresult;
31699 }
31700
31701
31702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31703   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31704
31705   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31706   {
31707     try {
31708       delete arg1;
31709     } CALL_CATCH_EXCEPTION();
31710   }
31711
31712 }
31713
31714
31715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31716   unsigned int jresult ;
31717   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31718   bool result;
31719
31720   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31721   {
31722     try {
31723       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);
31724     } CALL_CATCH_EXCEPTION(0);
31725   }
31726
31727   jresult = result;
31728   return jresult;
31729 }
31730
31731
31732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31733   unsigned long jresult ;
31734   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31735   std::size_t result;
31736
31737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31738   {
31739     try {
31740       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);
31741     } CALL_CATCH_EXCEPTION(0);
31742   }
31743
31744   jresult = (unsigned long)result;
31745   return jresult;
31746 }
31747
31748
31749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31750   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31751   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31752
31753   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31754   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31755   {
31756     try {
31757       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31758     } CALL_CATCH_EXCEPTION();
31759   }
31760
31761 }
31762
31763
31764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31765   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31766   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31767
31768   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31769   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31770   {
31771     try {
31772       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31773     } CALL_CATCH_EXCEPTION();
31774   }
31775
31776 }
31777
31778
31779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31780   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31781   Dali::Actor arg2 ;
31782   Dali::LongPressGesture *arg3 = 0 ;
31783   Dali::Actor *argp2 ;
31784
31785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31786   argp2 = (Dali::Actor *)jarg2;
31787   if (!argp2) {
31788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31789     return ;
31790   }
31791   arg2 = *argp2;
31792   arg3 = (Dali::LongPressGesture *)jarg3;
31793   if (!arg3) {
31794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31795     return ;
31796   }
31797   {
31798     try {
31799       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31800     } CALL_CATCH_EXCEPTION();
31801   }
31802
31803 }
31804
31805
31806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31807   void * jresult ;
31808   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31809
31810   {
31811     try {
31812       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31813     } CALL_CATCH_EXCEPTION(0);
31814   }
31815
31816   jresult = (void *)result;
31817   return jresult;
31818 }
31819
31820
31821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31822   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31823
31824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31825   {
31826     try {
31827       delete arg1;
31828     } CALL_CATCH_EXCEPTION();
31829   }
31830
31831 }
31832
31833
31834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31835   unsigned int jresult ;
31836   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31837   bool result;
31838
31839   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31840   {
31841     try {
31842       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);
31843     } CALL_CATCH_EXCEPTION(0);
31844   }
31845
31846   jresult = result;
31847   return jresult;
31848 }
31849
31850
31851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31852   unsigned long jresult ;
31853   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31854   std::size_t result;
31855
31856   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31857   {
31858     try {
31859       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);
31860     } CALL_CATCH_EXCEPTION(0);
31861   }
31862
31863   jresult = (unsigned long)result;
31864   return jresult;
31865 }
31866
31867
31868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31869   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31870   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31871
31872   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31873   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31874   {
31875     try {
31876       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31877     } CALL_CATCH_EXCEPTION();
31878   }
31879
31880 }
31881
31882
31883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31884   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31885   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31886
31887   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31888   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31889   {
31890     try {
31891       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31892     } CALL_CATCH_EXCEPTION();
31893   }
31894
31895 }
31896
31897
31898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31899   unsigned int jresult ;
31900   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31901   Dali::Actor arg2 ;
31902   Dali::TouchEvent *arg3 = 0 ;
31903   Dali::Actor *argp2 ;
31904   bool result;
31905
31906   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31907   argp2 = (Dali::Actor *)jarg2;
31908   if (!argp2) {
31909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31910     return 0;
31911   }
31912   arg2 = *argp2;
31913   arg3 = (Dali::TouchEvent *)jarg3;
31914   if (!arg3) {
31915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31916     return 0;
31917   }
31918   {
31919     try {
31920       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31921     } CALL_CATCH_EXCEPTION(0);
31922   }
31923
31924   jresult = result;
31925   return jresult;
31926 }
31927
31928
31929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31930   void * jresult ;
31931   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31932
31933   {
31934     try {
31935       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31936     } CALL_CATCH_EXCEPTION(0);
31937   }
31938
31939   jresult = (void *)result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
31945   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31946
31947   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31948   {
31949     try {
31950       delete arg1;
31951     } CALL_CATCH_EXCEPTION();
31952   }
31953
31954 }
31955
31956
31957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
31958   unsigned int jresult ;
31959   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31960   bool result;
31961
31962   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31963   {
31964     try {
31965       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);
31966     } CALL_CATCH_EXCEPTION(0);
31967   }
31968
31969   jresult = result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
31975   unsigned long jresult ;
31976   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31977   std::size_t result;
31978
31979   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31980   {
31981     try {
31982       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);
31983     } CALL_CATCH_EXCEPTION(0);
31984   }
31985
31986   jresult = (unsigned long)result;
31987   return jresult;
31988 }
31989
31990
31991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
31992   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31993   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31994
31995   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31996   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31997   {
31998     try {
31999       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32000     } CALL_CATCH_EXCEPTION();
32001   }
32002
32003 }
32004
32005
32006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
32007   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32008   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32009
32010   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32011   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32012   {
32013     try {
32014       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32015     } CALL_CATCH_EXCEPTION();
32016   }
32017
32018 }
32019
32020
32021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32022   unsigned int jresult ;
32023   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32024   Dali::Actor arg2 ;
32025   Dali::HoverEvent *arg3 = 0 ;
32026   Dali::Actor *argp2 ;
32027   bool result;
32028
32029   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32030   argp2 = (Dali::Actor *)jarg2;
32031   if (!argp2) {
32032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32033     return 0;
32034   }
32035   arg2 = *argp2;
32036   arg3 = (Dali::HoverEvent *)jarg3;
32037   if (!arg3) {
32038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32039     return 0;
32040   }
32041   {
32042     try {
32043       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
32044     } CALL_CATCH_EXCEPTION(0);
32045   }
32046
32047   jresult = result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
32053   void * jresult ;
32054   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
32055
32056   {
32057     try {
32058       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
32059     } CALL_CATCH_EXCEPTION(0);
32060   }
32061
32062   jresult = (void *)result;
32063   return jresult;
32064 }
32065
32066
32067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32068   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32069
32070   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32071   {
32072     try {
32073       delete arg1;
32074     } CALL_CATCH_EXCEPTION();
32075   }
32076
32077 }
32078
32079
32080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32081   unsigned int jresult ;
32082   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32083   bool result;
32084
32085   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32086   {
32087     try {
32088       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);
32089     } CALL_CATCH_EXCEPTION(0);
32090   }
32091
32092   jresult = result;
32093   return jresult;
32094 }
32095
32096
32097 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32098   unsigned long jresult ;
32099   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32100   std::size_t result;
32101
32102   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32103   {
32104     try {
32105       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);
32106     } CALL_CATCH_EXCEPTION(0);
32107   }
32108
32109   jresult = (unsigned long)result;
32110   return jresult;
32111 }
32112
32113
32114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32115   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32116   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32117
32118   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32119   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32120   {
32121     try {
32122       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32123     } CALL_CATCH_EXCEPTION();
32124   }
32125
32126 }
32127
32128
32129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32130   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32131   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32132
32133   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32134   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32135   {
32136     try {
32137       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32138     } CALL_CATCH_EXCEPTION();
32139   }
32140
32141 }
32142
32143
32144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32145   unsigned int jresult ;
32146   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32147   Dali::Actor arg2 ;
32148   Dali::WheelEvent *arg3 = 0 ;
32149   Dali::Actor *argp2 ;
32150   bool result;
32151
32152   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32153   argp2 = (Dali::Actor *)jarg2;
32154   if (!argp2) {
32155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32156     return 0;
32157   }
32158   arg2 = *argp2;
32159   arg3 = (Dali::WheelEvent *)jarg3;
32160   if (!arg3) {
32161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32162     return 0;
32163   }
32164   {
32165     try {
32166       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32167     } CALL_CATCH_EXCEPTION(0);
32168   }
32169
32170   jresult = result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32176   void * jresult ;
32177   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32178
32179   {
32180     try {
32181       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32182     } CALL_CATCH_EXCEPTION(0);
32183   }
32184
32185   jresult = (void *)result;
32186   return jresult;
32187 }
32188
32189
32190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32191   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32192
32193   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32194   {
32195     try {
32196       delete arg1;
32197     } CALL_CATCH_EXCEPTION();
32198   }
32199
32200 }
32201
32202
32203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32204   unsigned int jresult ;
32205   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32206   bool result;
32207
32208   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32209   {
32210     try {
32211       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32212     } CALL_CATCH_EXCEPTION(0);
32213   }
32214
32215   jresult = result;
32216   return jresult;
32217 }
32218
32219
32220 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32221   unsigned long jresult ;
32222   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32223   std::size_t result;
32224
32225   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32226   {
32227     try {
32228       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32229     } CALL_CATCH_EXCEPTION(0);
32230   }
32231
32232   jresult = (unsigned long)result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32238   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32239   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32240
32241   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32242   arg2 = (void (*)(Dali::Actor))jarg2;
32243   {
32244     try {
32245       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32246     } CALL_CATCH_EXCEPTION();
32247   }
32248
32249 }
32250
32251
32252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32253   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32254   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32255
32256   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32257   arg2 = (void (*)(Dali::Actor))jarg2;
32258   {
32259     try {
32260       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32261     } CALL_CATCH_EXCEPTION();
32262   }
32263
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32268   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32269   Dali::Actor arg2 ;
32270   Dali::Actor *argp2 ;
32271
32272   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32273   argp2 = (Dali::Actor *)jarg2;
32274   if (!argp2) {
32275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32276     return ;
32277   }
32278   arg2 = *argp2;
32279   {
32280     try {
32281       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32282     } CALL_CATCH_EXCEPTION();
32283   }
32284
32285 }
32286
32287
32288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32289   void * jresult ;
32290   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32291
32292   {
32293     try {
32294       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32295     } CALL_CATCH_EXCEPTION(0);
32296   }
32297
32298   jresult = (void *)result;
32299   return jresult;
32300 }
32301
32302
32303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32304   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32305
32306   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32307   {
32308     try {
32309       delete arg1;
32310     } CALL_CATCH_EXCEPTION();
32311   }
32312
32313 }
32314
32315
32316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32317   unsigned int jresult ;
32318   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32319   bool result;
32320
32321   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32322   {
32323     try {
32324       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32325     } CALL_CATCH_EXCEPTION(0);
32326   }
32327
32328   jresult = result;
32329   return jresult;
32330 }
32331
32332
32333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32334   unsigned long jresult ;
32335   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32336   std::size_t result;
32337
32338   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32339   {
32340     try {
32341       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32342     } CALL_CATCH_EXCEPTION(0);
32343   }
32344
32345   jresult = (unsigned long)result;
32346   return jresult;
32347 }
32348
32349
32350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32351   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32352   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32353
32354   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32355   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32356   {
32357     try {
32358       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32359     } CALL_CATCH_EXCEPTION();
32360   }
32361
32362 }
32363
32364
32365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32366   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32367   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32368
32369   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32370   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32371   {
32372     try {
32373       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32374     } CALL_CATCH_EXCEPTION();
32375   }
32376
32377 }
32378
32379
32380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32381   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32382   Dali::KeyEvent *arg2 = 0 ;
32383
32384   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32385   arg2 = (Dali::KeyEvent *)jarg2;
32386   if (!arg2) {
32387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32388     return ;
32389   }
32390   {
32391     try {
32392       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32393     } CALL_CATCH_EXCEPTION();
32394   }
32395
32396 }
32397
32398
32399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32400   void * jresult ;
32401   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32402
32403   {
32404     try {
32405       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32406     } CALL_CATCH_EXCEPTION(0);
32407   }
32408
32409   jresult = (void *)result;
32410   return jresult;
32411 }
32412
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32415   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32416
32417   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32418   {
32419     try {
32420       delete arg1;
32421     } CALL_CATCH_EXCEPTION();
32422   }
32423
32424 }
32425
32426
32427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32428   unsigned int jresult ;
32429   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32430   bool result;
32431
32432   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32433   {
32434     try {
32435       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32436     } CALL_CATCH_EXCEPTION(0);
32437   }
32438
32439   jresult = result;
32440   return jresult;
32441 }
32442
32443
32444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32445   unsigned long jresult ;
32446   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32447   std::size_t result;
32448
32449   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32450   {
32451     try {
32452       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32453     } CALL_CATCH_EXCEPTION(0);
32454   }
32455
32456   jresult = (unsigned long)result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32462   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32463   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32464
32465   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32466   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32467   {
32468     try {
32469       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32470     } CALL_CATCH_EXCEPTION();
32471   }
32472
32473 }
32474
32475
32476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32477   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32478   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32479
32480   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32481   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32482   {
32483     try {
32484       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32485     } CALL_CATCH_EXCEPTION();
32486   }
32487
32488 }
32489
32490
32491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32492   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32493   Dali::TouchEvent *arg2 = 0 ;
32494
32495   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32496   arg2 = (Dali::TouchEvent *)jarg2;
32497   if (!arg2) {
32498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32499     return ;
32500   }
32501   {
32502     try {
32503       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32504     } CALL_CATCH_EXCEPTION();
32505   }
32506
32507 }
32508
32509
32510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32511   void * jresult ;
32512   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32513
32514   {
32515     try {
32516       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32517     } CALL_CATCH_EXCEPTION(0);
32518   }
32519
32520   jresult = (void *)result;
32521   return jresult;
32522 }
32523
32524
32525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32526   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32527
32528   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32529   {
32530     try {
32531       delete arg1;
32532     } CALL_CATCH_EXCEPTION();
32533   }
32534
32535 }
32536
32537
32538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32539   unsigned int jresult ;
32540   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32541   bool result;
32542
32543   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32544   {
32545     try {
32546       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32547     } CALL_CATCH_EXCEPTION(0);
32548   }
32549
32550   jresult = result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32556   unsigned long jresult ;
32557   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32558   std::size_t result;
32559
32560   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32561   {
32562     try {
32563       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32564     } CALL_CATCH_EXCEPTION(0);
32565   }
32566
32567   jresult = (unsigned long)result;
32568   return jresult;
32569 }
32570
32571
32572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32573   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32574   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32575
32576   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32577   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32578   {
32579     try {
32580       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32581     } CALL_CATCH_EXCEPTION();
32582   }
32583
32584 }
32585
32586
32587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32588   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32589   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32590
32591   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32592   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32593   {
32594     try {
32595       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32596     } CALL_CATCH_EXCEPTION();
32597   }
32598
32599 }
32600
32601
32602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32603   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32604   Dali::WheelEvent *arg2 = 0 ;
32605
32606   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32607   arg2 = (Dali::WheelEvent *)jarg2;
32608   if (!arg2) {
32609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32610     return ;
32611   }
32612   {
32613     try {
32614       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32615     } CALL_CATCH_EXCEPTION();
32616   }
32617
32618 }
32619
32620
32621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32622   void * jresult ;
32623   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32624
32625   {
32626     try {
32627       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32628     } CALL_CATCH_EXCEPTION(0);
32629   }
32630
32631   jresult = (void *)result;
32632   return jresult;
32633 }
32634
32635
32636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32637   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32638
32639   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32640   {
32641     try {
32642       delete arg1;
32643     } CALL_CATCH_EXCEPTION();
32644   }
32645
32646 }
32647
32648
32649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32650   void * jresult ;
32651   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32652
32653   {
32654     try {
32655       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32656     } CALL_CATCH_EXCEPTION(0);
32657   }
32658
32659   jresult = (void *)result;
32660   return jresult;
32661 }
32662
32663
32664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32665   void * jresult ;
32666   Dali::Radian arg1 ;
32667   Dali::Radian arg2 ;
32668   Dali::Radian *argp1 ;
32669   Dali::Radian *argp2 ;
32670   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32671
32672   argp1 = (Dali::Radian *)jarg1;
32673   if (!argp1) {
32674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32675     return 0;
32676   }
32677   arg1 = *argp1;
32678   argp2 = (Dali::Radian *)jarg2;
32679   if (!argp2) {
32680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32681     return 0;
32682   }
32683   arg2 = *argp2;
32684   {
32685     try {
32686       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32687     } CALL_CATCH_EXCEPTION(0);
32688   }
32689
32690   jresult = (void *)result;
32691   return jresult;
32692 }
32693
32694
32695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32696   void * jresult ;
32697   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32698   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32699
32700   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32701   if (!arg1) {
32702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32703     return 0;
32704   }
32705   {
32706     try {
32707       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32708     } CALL_CATCH_EXCEPTION(0);
32709   }
32710
32711   jresult = (void *)result;
32712   return jresult;
32713 }
32714
32715
32716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32717   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32718   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32719
32720   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32721   arg2 = (Dali::Radian *)jarg2;
32722   if (arg1) (arg1)->first = *arg2;
32723 }
32724
32725
32726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32727   void * jresult ;
32728   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32729   Dali::Radian *result = 0 ;
32730
32731   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32732   result = (Dali::Radian *)& ((arg1)->first);
32733   jresult = (void *)result;
32734   return jresult;
32735 }
32736
32737
32738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32739   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32740   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32741
32742   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32743   arg2 = (Dali::Radian *)jarg2;
32744   if (arg1) (arg1)->second = *arg2;
32745 }
32746
32747
32748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32749   void * jresult ;
32750   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32751   Dali::Radian *result = 0 ;
32752
32753   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32754   result = (Dali::Radian *)& ((arg1)->second);
32755   jresult = (void *)result;
32756   return jresult;
32757 }
32758
32759
32760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32761   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32762
32763   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32764   {
32765     try {
32766       delete arg1;
32767     } CALL_CATCH_EXCEPTION();
32768   }
32769
32770 }
32771
32772
32773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32774   unsigned int jresult ;
32775   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32776   bool result;
32777
32778   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32779   {
32780     try {
32781       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);
32782     } CALL_CATCH_EXCEPTION(0);
32783   }
32784
32785   jresult = result;
32786   return jresult;
32787 }
32788
32789
32790 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32791   unsigned long jresult ;
32792   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32793   std::size_t result;
32794
32795   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32796   {
32797     try {
32798       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);
32799     } CALL_CATCH_EXCEPTION(0);
32800   }
32801
32802   jresult = (unsigned long)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32808   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32809   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32810
32811   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32812   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32813   {
32814     try {
32815       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32816     } CALL_CATCH_EXCEPTION();
32817   }
32818
32819 }
32820
32821
32822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32823   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32824   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32825
32826   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32827   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32828   {
32829     try {
32830       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32831     } CALL_CATCH_EXCEPTION();
32832   }
32833
32834 }
32835
32836
32837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32838   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32839   Dali::Actor arg2 ;
32840   Dali::PanGesture *arg3 = 0 ;
32841   Dali::Actor *argp2 ;
32842
32843   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32844   argp2 = (Dali::Actor *)jarg2;
32845   if (!argp2) {
32846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32847     return ;
32848   }
32849   arg2 = *argp2;
32850   arg3 = (Dali::PanGesture *)jarg3;
32851   if (!arg3) {
32852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32853     return ;
32854   }
32855   {
32856     try {
32857       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32858     } CALL_CATCH_EXCEPTION();
32859   }
32860
32861 }
32862
32863
32864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32865   void * jresult ;
32866   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32867
32868   {
32869     try {
32870       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32871     } CALL_CATCH_EXCEPTION(0);
32872   }
32873
32874   jresult = (void *)result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32880   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32881
32882   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32883   {
32884     try {
32885       delete arg1;
32886     } CALL_CATCH_EXCEPTION();
32887   }
32888
32889 }
32890
32891
32892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32893   unsigned int jresult ;
32894   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32895   bool result;
32896
32897   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32898   {
32899     try {
32900       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);
32901     } CALL_CATCH_EXCEPTION(0);
32902   }
32903
32904   jresult = result;
32905   return jresult;
32906 }
32907
32908
32909 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32910   unsigned long jresult ;
32911   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32912   std::size_t result;
32913
32914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32915   {
32916     try {
32917       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);
32918     } CALL_CATCH_EXCEPTION(0);
32919   }
32920
32921   jresult = (unsigned long)result;
32922   return jresult;
32923 }
32924
32925
32926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32928   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32929
32930   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32931   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32932   {
32933     try {
32934       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32935     } CALL_CATCH_EXCEPTION();
32936   }
32937
32938 }
32939
32940
32941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32942   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32943   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32944
32945   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32946   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32947   {
32948     try {
32949       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32950     } CALL_CATCH_EXCEPTION();
32951   }
32952
32953 }
32954
32955
32956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32957   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32958   Dali::Actor arg2 ;
32959   Dali::PinchGesture *arg3 = 0 ;
32960   Dali::Actor *argp2 ;
32961
32962   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32963   argp2 = (Dali::Actor *)jarg2;
32964   if (!argp2) {
32965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32966     return ;
32967   }
32968   arg2 = *argp2;
32969   arg3 = (Dali::PinchGesture *)jarg3;
32970   if (!arg3) {
32971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
32972     return ;
32973   }
32974   {
32975     try {
32976       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
32977     } CALL_CATCH_EXCEPTION();
32978   }
32979
32980 }
32981
32982
32983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
32984   void * jresult ;
32985   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
32986
32987   {
32988     try {
32989       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
32990     } CALL_CATCH_EXCEPTION(0);
32991   }
32992
32993   jresult = (void *)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
32999   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33000
33001   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33002   {
33003     try {
33004       delete arg1;
33005     } CALL_CATCH_EXCEPTION();
33006   }
33007
33008 }
33009
33010
33011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
33012   unsigned int jresult ;
33013   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33014   bool result;
33015
33016   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33017   {
33018     try {
33019       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);
33020     } CALL_CATCH_EXCEPTION(0);
33021   }
33022
33023   jresult = result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33029   unsigned long jresult ;
33030   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33031   std::size_t result;
33032
33033   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33034   {
33035     try {
33036       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);
33037     } CALL_CATCH_EXCEPTION(0);
33038   }
33039
33040   jresult = (unsigned long)result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33046   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33047   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33048
33049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33050   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33051   {
33052     try {
33053       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33054     } CALL_CATCH_EXCEPTION();
33055   }
33056
33057 }
33058
33059
33060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33061   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33062   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33063
33064   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33065   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33066   {
33067     try {
33068       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33069     } CALL_CATCH_EXCEPTION();
33070   }
33071
33072 }
33073
33074
33075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33076   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33077   Dali::Actor arg2 ;
33078   Dali::TapGesture *arg3 = 0 ;
33079   Dali::Actor *argp2 ;
33080
33081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33082   argp2 = (Dali::Actor *)jarg2;
33083   if (!argp2) {
33084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33085     return ;
33086   }
33087   arg2 = *argp2;
33088   arg3 = (Dali::TapGesture *)jarg3;
33089   if (!arg3) {
33090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33091     return ;
33092   }
33093   {
33094     try {
33095       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33096     } CALL_CATCH_EXCEPTION();
33097   }
33098
33099 }
33100
33101
33102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33103   void * jresult ;
33104   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33105
33106   {
33107     try {
33108       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33109     } CALL_CATCH_EXCEPTION(0);
33110   }
33111
33112   jresult = (void *)result;
33113   return jresult;
33114 }
33115
33116
33117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33118   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33119
33120   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33121   {
33122     try {
33123       delete arg1;
33124     } CALL_CATCH_EXCEPTION();
33125   }
33126
33127 }
33128
33129
33130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33131   unsigned int jresult ;
33132   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33133   bool result = false;
33134
33135   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33136   {
33137     try {
33138       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);
33139     } CALL_CATCH_EXCEPTION(0);
33140   }
33141   jresult = result;
33142   return jresult;
33143 }
33144
33145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33146   unsigned long jresult ;
33147   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33148   std::size_t result = 0;
33149
33150   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33151   {
33152     try {
33153       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);
33154     }CALL_CATCH_EXCEPTION(0);
33155   }
33156   jresult = (unsigned long)result;
33157   return jresult;
33158 }
33159
33160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33161   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33162   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33163
33164   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33165   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33166   {
33167     try {
33168       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33169     } CALL_CATCH_EXCEPTION();
33170   }
33171 }
33172
33173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33174   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33175   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33176
33177   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33178   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33179   {
33180     try {
33181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33182     } CALL_CATCH_EXCEPTION();
33183   }
33184 }
33185
33186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33187   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33188   Dali::Actor arg2 ;
33189   //bool arg3 ;
33190   Dali::LayoutDirection::Type arg4 ;
33191   Dali::Actor *argp2 ;
33192
33193   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33194   argp2 = (Dali::Actor *)jarg2;
33195   if (!argp2) {
33196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33197     return ;
33198   }
33199   arg2 = *argp2;
33200   //arg3 = jarg3 ? true : false;
33201   arg4 = (Dali::LayoutDirection::Type)jarg4;
33202   {
33203     try {
33204       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33205     } CALL_CATCH_EXCEPTION();
33206   }
33207 }
33208
33209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33210   void * jresult ;
33211   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33212
33213   {
33214     try {
33215       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33216     } CALL_CATCH_EXCEPTION(0);
33217   }
33218   jresult = (void *)result;
33219   return jresult;
33220 }
33221
33222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33223   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33224
33225   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33226   {
33227     try {
33228       delete arg1;
33229     } CALL_CATCH_EXCEPTION();
33230   }
33231 }
33232
33233
33234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_iewVisibilityChangedSignal_Empty(void * jarg1) {
33235   unsigned int jresult ;
33236   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33237   bool result = false;
33238
33239   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33240   {
33241     try {
33242           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);
33243     } CALL_CATCH_EXCEPTION(0);
33244   }
33245   jresult = result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33251   unsigned long jresult ;
33252   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33253   std::size_t result;
33254
33255   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33256   {
33257     try {
33258       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);
33259     } CALL_CATCH_EXCEPTION(0);
33260   }
33261
33262   jresult = (unsigned long)result;
33263   return jresult;
33264 }
33265
33266
33267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33268   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33269   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33270
33271   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33272   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33273   {
33274     try {
33275       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33276     } CALL_CATCH_EXCEPTION();
33277   }
33278
33279 }
33280
33281
33282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33283   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33284   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33285
33286   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33287   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33288   {
33289     try {
33290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33291     } CALL_CATCH_EXCEPTION();
33292   }
33293
33294 }
33295
33296
33297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33298   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33299   Dali::Actor arg2 ;
33300   bool arg3 ;
33301   Dali::DevelActor::VisibilityChange::Type arg4 ;
33302   Dali::Actor *argp2 ;
33303
33304   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33305   argp2 = (Dali::Actor *)jarg2;
33306   if (!argp2) {
33307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33308     return ;
33309   }
33310   arg2 = *argp2;
33311   arg3 = jarg3 ? true : false;
33312   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33313   {
33314     try {
33315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33316     } CALL_CATCH_EXCEPTION();
33317   }
33318
33319 }
33320
33321
33322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33323   void * jresult ;
33324   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33325
33326   {
33327     try {
33328       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33329     } CALL_CATCH_EXCEPTION(0);
33330   }
33331
33332   jresult = (void *)result;
33333   return jresult;
33334 }
33335
33336
33337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33338   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33339
33340   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33341   {
33342     try {
33343       delete arg1;
33344     } CALL_CATCH_EXCEPTION();
33345   }
33346
33347 }
33348
33349
33350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33351   void * jresult ;
33352   Dali::Timer *result = 0 ;
33353
33354   {
33355     try {
33356       result = (Dali::Timer *)new Dali::Timer();
33357     } CALL_CATCH_EXCEPTION(0);
33358   }
33359
33360   jresult = (void *)result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33366   void * jresult ;
33367   unsigned int arg1 ;
33368   Dali::Timer result;
33369
33370   arg1 = (unsigned int)jarg1;
33371   {
33372     try {
33373       result = Dali::Timer::New(arg1);
33374     } CALL_CATCH_EXCEPTION(0);
33375   }
33376
33377   jresult = new Dali::Timer((const Dali::Timer &)result);
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33383   void * jresult ;
33384   Dali::Timer *arg1 = 0 ;
33385   Dali::Timer *result = 0 ;
33386
33387   arg1 = (Dali::Timer *)jarg1;
33388   if (!arg1) {
33389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33390     return 0;
33391   }
33392   {
33393     try {
33394       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33395     } CALL_CATCH_EXCEPTION(0);
33396   }
33397
33398   jresult = (void *)result;
33399   return jresult;
33400 }
33401
33402
33403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33404   void * jresult ;
33405   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33406   Dali::Timer *arg2 = 0 ;
33407   Dali::Timer *result = 0 ;
33408
33409   arg1 = (Dali::Timer *)jarg1;
33410   arg2 = (Dali::Timer *)jarg2;
33411   if (!arg2) {
33412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33413     return 0;
33414   }
33415   {
33416     try {
33417       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33418     } CALL_CATCH_EXCEPTION(0);
33419   }
33420
33421   jresult = (void *)result;
33422   return jresult;
33423 }
33424
33425
33426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33427   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33428
33429   arg1 = (Dali::Timer *)jarg1;
33430   {
33431     try {
33432       delete arg1;
33433     } CALL_CATCH_EXCEPTION();
33434   }
33435
33436 }
33437
33438
33439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33440   void * jresult ;
33441   Dali::BaseHandle arg1 ;
33442   Dali::BaseHandle *argp1 ;
33443   Dali::Timer result;
33444
33445   argp1 = (Dali::BaseHandle *)jarg1;
33446   if (!argp1) {
33447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33448     return 0;
33449   }
33450   arg1 = *argp1;
33451   {
33452     try {
33453       result = Dali::Timer::DownCast(arg1);
33454     } CALL_CATCH_EXCEPTION(0);
33455   }
33456
33457   jresult = new Dali::Timer((const Dali::Timer &)result);
33458   return jresult;
33459 }
33460
33461
33462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33463   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33464
33465   arg1 = (Dali::Timer *)jarg1;
33466   {
33467     try {
33468       (arg1)->Start();
33469     } CALL_CATCH_EXCEPTION();
33470   }
33471
33472 }
33473
33474
33475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33476   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33477
33478   arg1 = (Dali::Timer *)jarg1;
33479   {
33480     try {
33481       (arg1)->Stop();
33482     } CALL_CATCH_EXCEPTION();
33483   }
33484
33485 }
33486
33487
33488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33489   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33490   unsigned int arg2 ;
33491
33492   arg1 = (Dali::Timer *)jarg1;
33493   arg2 = (unsigned int)jarg2;
33494   {
33495     try {
33496       (arg1)->SetInterval(arg2);
33497     } CALL_CATCH_EXCEPTION();
33498   }
33499
33500 }
33501
33502
33503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33504   unsigned int jresult ;
33505   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33506   unsigned int result;
33507
33508   arg1 = (Dali::Timer *)jarg1;
33509   {
33510     try {
33511       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33512     } CALL_CATCH_EXCEPTION(0);
33513   }
33514
33515   jresult = result;
33516   return jresult;
33517 }
33518
33519
33520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33521   unsigned int jresult ;
33522   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33523   bool result;
33524
33525   arg1 = (Dali::Timer *)jarg1;
33526   {
33527     try {
33528       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33529     } CALL_CATCH_EXCEPTION(0);
33530   }
33531
33532   jresult = result;
33533   return jresult;
33534 }
33535
33536
33537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33538   void * jresult ;
33539   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33540   Dali::Timer::TimerSignalType *result = 0 ;
33541
33542   arg1 = (Dali::Timer *)jarg1;
33543   {
33544     try {
33545       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33546     } CALL_CATCH_EXCEPTION(0);
33547   }
33548
33549   jresult = (void *)result;
33550   return jresult;
33551 }
33552
33553
33554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33555   unsigned int jresult ;
33556   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33557   bool result;
33558
33559   arg1 = (Dali::Signal< bool () > *)jarg1;
33560   {
33561     try {
33562       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33563     } CALL_CATCH_EXCEPTION(0);
33564   }
33565
33566   jresult = result;
33567   return jresult;
33568 }
33569
33570
33571 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33572   unsigned long jresult ;
33573   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33574   std::size_t result;
33575
33576   arg1 = (Dali::Signal< bool () > *)jarg1;
33577   {
33578     try {
33579       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33580     } CALL_CATCH_EXCEPTION(0);
33581   }
33582
33583   jresult = (unsigned long)result;
33584   return jresult;
33585 }
33586
33587
33588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33589   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33590   bool (*arg2)() = (bool (*)()) 0 ;
33591
33592   arg1 = (Dali::Signal< bool () > *)jarg1;
33593   arg2 = (bool (*)())jarg2;
33594   {
33595     try {
33596       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33597     } CALL_CATCH_EXCEPTION();
33598   }
33599
33600 }
33601
33602
33603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33604   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33605   bool (*arg2)() = (bool (*)()) 0 ;
33606
33607   arg1 = (Dali::Signal< bool () > *)jarg1;
33608   arg2 = (bool (*)())jarg2;
33609   {
33610     try {
33611       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33612     } CALL_CATCH_EXCEPTION();
33613   }
33614
33615 }
33616
33617
33618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33619   unsigned int jresult ;
33620   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33621   bool result;
33622
33623   arg1 = (Dali::Signal< bool () > *)jarg1;
33624   {
33625     try {
33626       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33627     } CALL_CATCH_EXCEPTION(0);
33628   }
33629
33630   jresult = result;
33631   return jresult;
33632 }
33633
33634
33635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33636   void * jresult ;
33637   Dali::Signal< bool () > *result = 0 ;
33638
33639   {
33640     try {
33641       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33642     } CALL_CATCH_EXCEPTION(0);
33643   }
33644
33645   jresult = (void *)result;
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33651   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33652
33653   arg1 = (Dali::Signal< bool () > *)jarg1;
33654   {
33655     try {
33656       delete arg1;
33657     } CALL_CATCH_EXCEPTION();
33658   }
33659
33660 }
33661
33662
33663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33664   int jresult ;
33665   int result;
33666
33667   {
33668     try {
33669       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33670     } CALL_CATCH_EXCEPTION(0);
33671   }
33672
33673   jresult = (int)result;
33674   return jresult;
33675 }
33676
33677
33678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33679   int jresult ;
33680   int result;
33681
33682   {
33683     try {
33684       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33685     } CALL_CATCH_EXCEPTION(0);
33686   }
33687
33688   jresult = (int)result;
33689   return jresult;
33690 }
33691
33692
33693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33694   int jresult ;
33695   int result;
33696
33697   {
33698     try {
33699       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33700     } CALL_CATCH_EXCEPTION(0);
33701   }
33702
33703   jresult = (int)result;
33704   return jresult;
33705 }
33706
33707
33708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33709   int jresult ;
33710   int result;
33711
33712   {
33713     try {
33714       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33715     } CALL_CATCH_EXCEPTION(0);
33716   }
33717
33718   jresult = (int)result;
33719   return jresult;
33720 }
33721
33722
33723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33724   int jresult ;
33725   int result;
33726
33727   {
33728     try {
33729       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33730     } CALL_CATCH_EXCEPTION(0);
33731   }
33732
33733   jresult = (int)result;
33734   return jresult;
33735 }
33736
33737
33738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33739   int jresult ;
33740   int result;
33741
33742   {
33743     try {
33744       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33745     } CALL_CATCH_EXCEPTION(0);
33746   }
33747
33748   jresult = (int)result;
33749   return jresult;
33750 }
33751
33752
33753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33754   int jresult ;
33755   int result;
33756
33757   {
33758     try {
33759       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33760     } CALL_CATCH_EXCEPTION(0);
33761   }
33762
33763   jresult = (int)result;
33764   return jresult;
33765 }
33766
33767
33768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33769   int jresult ;
33770   int result;
33771
33772   {
33773     try {
33774       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33775     } CALL_CATCH_EXCEPTION(0);
33776   }
33777
33778   jresult = (int)result;
33779   return jresult;
33780 }
33781
33782
33783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33784   int jresult ;
33785   int result;
33786
33787   {
33788     try {
33789       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33790     } CALL_CATCH_EXCEPTION(0);
33791   }
33792
33793   jresult = (int)result;
33794   return jresult;
33795 }
33796
33797
33798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33799   int jresult ;
33800   int result;
33801
33802   {
33803     try {
33804       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33805     } CALL_CATCH_EXCEPTION(0);
33806   }
33807
33808   jresult = (int)result;
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33814   int jresult ;
33815   int result;
33816
33817   {
33818     try {
33819       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33820     } CALL_CATCH_EXCEPTION(0);
33821   }
33822
33823   jresult = (int)result;
33824   return jresult;
33825 }
33826
33827
33828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33829   int jresult ;
33830   int result;
33831
33832   {
33833     try {
33834       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33835     } CALL_CATCH_EXCEPTION(0);
33836   }
33837
33838   jresult = (int)result;
33839   return jresult;
33840 }
33841
33842
33843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33844   int jresult ;
33845   int result;
33846
33847   {
33848     try {
33849       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33850     } CALL_CATCH_EXCEPTION(0);
33851   }
33852
33853   jresult = (int)result;
33854   return jresult;
33855 }
33856
33857
33858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33859   int jresult ;
33860   int result;
33861
33862   {
33863     try {
33864       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33865     } CALL_CATCH_EXCEPTION(0);
33866   }
33867
33868   jresult = (int)result;
33869   return jresult;
33870 }
33871
33872
33873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33874   int jresult ;
33875   int result;
33876
33877   {
33878     try {
33879       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33880     } CALL_CATCH_EXCEPTION(0);
33881   }
33882
33883   jresult = (int)result;
33884   return jresult;
33885 }
33886
33887
33888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33889   int jresult ;
33890   int result;
33891
33892   {
33893     try {
33894       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33895     } CALL_CATCH_EXCEPTION(0);
33896   }
33897
33898   jresult = (int)result;
33899   return jresult;
33900 }
33901
33902
33903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33904   int jresult ;
33905   int result;
33906
33907   {
33908     try {
33909       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33910     } CALL_CATCH_EXCEPTION(0);
33911   }
33912
33913   jresult = (int)result;
33914   return jresult;
33915 }
33916
33917
33918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33919   int jresult ;
33920   int result;
33921
33922   {
33923     try {
33924       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33925     } CALL_CATCH_EXCEPTION(0);
33926   }
33927
33928   jresult = (int)result;
33929   return jresult;
33930 }
33931
33932
33933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33934   int jresult ;
33935   int result;
33936
33937   {
33938     try {
33939       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33940     } CALL_CATCH_EXCEPTION(0);
33941   }
33942
33943   jresult = (int)result;
33944   return jresult;
33945 }
33946
33947
33948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
33949   int jresult ;
33950   int result;
33951
33952   {
33953     try {
33954       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
33955     } CALL_CATCH_EXCEPTION(0);
33956   }
33957
33958   jresult = (int)result;
33959   return jresult;
33960 }
33961
33962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
33963   int jresult ;
33964   int result;
33965
33966   {
33967     try {
33968       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
33969     } CALL_CATCH_EXCEPTION(0);
33970   }
33971
33972   jresult = (int)result;
33973   return jresult;
33974 }
33975
33976
33977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
33978   int jresult ;
33979   int result;
33980   {
33981     try
33982     {
33983       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
33984     } CALL_CATCH_EXCEPTION(0);
33985   }
33986
33987   jresult = (int)result;
33988   return jresult;
33989 }
33990
33991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
33992   int jresult ;
33993   int result;
33994   {
33995     try
33996     {
33997       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
33998     } CALL_CATCH_EXCEPTION(0);
33999   }
34000
34001   jresult = (int)result;
34002   return jresult;
34003 }
34004
34005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
34006   int jresult ;
34007   int result;
34008   {
34009     try
34010     {
34011       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
34012     } CALL_CATCH_EXCEPTION(0);
34013   }
34014
34015   jresult = (int)result;
34016   return jresult;
34017 }
34018
34019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
34020   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
34021 }
34022
34023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
34024   int jresult ;
34025   int result;
34026   {
34027     try
34028     {
34029       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
34030     } CALL_CATCH_EXCEPTION(0);
34031   }
34032
34033   jresult = (int)result;
34034   return jresult;
34035 }
34036
34037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
34038   int jresult ;
34039   int result;
34040   {
34041     try
34042     {
34043       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
34044     } CALL_CATCH_EXCEPTION(0);
34045   }
34046
34047   jresult = (int)result;
34048   return jresult;
34049 }
34050
34051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
34052   int jresult ;
34053   int result;
34054
34055   {
34056     try {
34057       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
34058     } CALL_CATCH_EXCEPTION(0);
34059   }
34060
34061   jresult = (int)result;
34062   return jresult;
34063 }
34064
34065
34066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34067   int jresult ;
34068   int result;
34069
34070   {
34071     try {
34072       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34073     } CALL_CATCH_EXCEPTION(0);
34074   }
34075
34076   jresult = (int)result;
34077   return jresult;
34078 }
34079
34080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34081   int jresult ;
34082   int result;
34083   {
34084     try
34085     {
34086       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34087     } CALL_CATCH_EXCEPTION(0);
34088   }
34089
34090   jresult = (int)result;
34091   return jresult;
34092 }
34093
34094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34095   int jresult ;
34096   int result;
34097   {
34098     try
34099     {
34100       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34101     } CALL_CATCH_EXCEPTION(0);
34102   }
34103
34104   jresult = (int)result;
34105   return jresult;
34106 }
34107
34108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34109   int jresult ;
34110   int result;
34111   {
34112     try
34113     {
34114       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34115     } CALL_CATCH_EXCEPTION(0);
34116   }
34117
34118   jresult = (int)result;
34119   return jresult;
34120 }
34121
34122
34123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34124   int jresult ;
34125   int result;
34126   {
34127     try
34128     {
34129       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34130     } CALL_CATCH_EXCEPTION(0);
34131   }
34132
34133   jresult = (int)result;
34134   return jresult;
34135 }
34136
34137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34138   int jresult ;
34139   int result;
34140   {
34141     try
34142     {
34143       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34144     } CALL_CATCH_EXCEPTION(0);
34145   }
34146
34147   jresult = (int)result;
34148   return jresult;
34149 }
34150
34151
34152
34153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34154   int jresult ;
34155   int result;
34156
34157   {
34158     try {
34159       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34160     } CALL_CATCH_EXCEPTION(0);
34161   }
34162
34163   jresult = (int)result;
34164   return jresult;
34165 }
34166
34167
34168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34169   int jresult ;
34170   int result;
34171
34172   {
34173     try {
34174       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34175     } CALL_CATCH_EXCEPTION(0);
34176   }
34177
34178   jresult = (int)result;
34179   return jresult;
34180 }
34181
34182
34183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34184   int jresult ;
34185   int result;
34186
34187   {
34188     try {
34189       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34190     } CALL_CATCH_EXCEPTION(0);
34191   }
34192
34193   jresult = (int)result;
34194   return jresult;
34195 }
34196
34197
34198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34199   int jresult ;
34200   int result;
34201
34202   {
34203     try {
34204       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34205     } CALL_CATCH_EXCEPTION(0);
34206   }
34207
34208   jresult = (int)result;
34209   return jresult;
34210 }
34211
34212
34213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34214   int jresult ;
34215   int result;
34216
34217   {
34218     try {
34219       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34220     } CALL_CATCH_EXCEPTION(0);
34221   }
34222
34223   jresult = (int)result;
34224   return jresult;
34225 }
34226
34227
34228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34229   int jresult ;
34230   int result;
34231
34232   {
34233     try {
34234       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34235     } CALL_CATCH_EXCEPTION(0);
34236   }
34237
34238   jresult = (int)result;
34239   return jresult;
34240 }
34241
34242
34243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34244   int jresult ;
34245   int result;
34246
34247   {
34248     try {
34249       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34250     } CALL_CATCH_EXCEPTION(0);
34251   }
34252
34253   jresult = (int)result;
34254   return jresult;
34255 }
34256
34257 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34258   int jresult ;
34259   int result;
34260
34261   {
34262     try {
34263       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34264     } CALL_CATCH_EXCEPTION(0);
34265   }
34266
34267   jresult = (int)result;
34268   return jresult;
34269 }
34270
34271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34272   int jresult ;
34273   int result;
34274
34275   {
34276     try {
34277       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34278     } CALL_CATCH_EXCEPTION(0);
34279   }
34280
34281   jresult = (int)result;
34282   return jresult;
34283 }
34284
34285
34286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34287   int jresult ;
34288   int result;
34289
34290   {
34291     try {
34292       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34293     } CALL_CATCH_EXCEPTION(0);
34294   }
34295
34296   jresult = (int)result;
34297   return jresult;
34298 }
34299
34300
34301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34302   int jresult ;
34303   int result;
34304
34305   {
34306     try {
34307       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34308     } CALL_CATCH_EXCEPTION(0);
34309   }
34310
34311   jresult = (int)result;
34312   return jresult;
34313 }
34314
34315
34316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34317   int jresult ;
34318   int result;
34319
34320   {
34321     try {
34322       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34323     } CALL_CATCH_EXCEPTION(0);
34324   }
34325
34326   jresult = (int)result;
34327   return jresult;
34328 }
34329
34330
34331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34332   int jresult ;
34333   int result;
34334
34335   {
34336     try {
34337       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34338     } CALL_CATCH_EXCEPTION(0);
34339   }
34340
34341   jresult = (int)result;
34342   return jresult;
34343 }
34344
34345
34346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34347   int jresult ;
34348   int result;
34349
34350   {
34351     try {
34352       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34353     } CALL_CATCH_EXCEPTION(0);
34354   }
34355
34356   jresult = (int)result;
34357   return jresult;
34358 }
34359
34360
34361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34362   int jresult ;
34363   int result;
34364
34365   {
34366     try {
34367       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34368     } CALL_CATCH_EXCEPTION(0);
34369   }
34370
34371   jresult = (int)result;
34372   return jresult;
34373 }
34374
34375
34376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34377   int jresult ;
34378   int result;
34379
34380   {
34381     try {
34382       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34383     } CALL_CATCH_EXCEPTION(0);
34384   }
34385
34386   jresult = (int)result;
34387   return jresult;
34388 }
34389
34390
34391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34392   int jresult ;
34393   int result;
34394
34395   {
34396     try {
34397       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34398     } CALL_CATCH_EXCEPTION(0);
34399   }
34400
34401   jresult = (int)result;
34402   return jresult;
34403 }
34404
34405
34406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34407   int jresult ;
34408   int result;
34409
34410   {
34411     try {
34412       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34413     } CALL_CATCH_EXCEPTION(0);
34414   }
34415
34416   jresult = (int)result;
34417   return jresult;
34418 }
34419
34420
34421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34422   int jresult ;
34423   int result;
34424
34425   {
34426     try {
34427       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34428     } CALL_CATCH_EXCEPTION(0);
34429   }
34430
34431   jresult = (int)result;
34432   return jresult;
34433 }
34434
34435
34436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34437   int jresult ;
34438   int result;
34439
34440   {
34441     try {
34442       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34443     } CALL_CATCH_EXCEPTION(0);
34444   }
34445
34446   jresult = (int)result;
34447   return jresult;
34448 }
34449
34450
34451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34452   int jresult ;
34453   int result;
34454
34455   {
34456     try {
34457       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34458     } CALL_CATCH_EXCEPTION(0);
34459   }
34460
34461   jresult = (int)result;
34462   return jresult;
34463 }
34464
34465
34466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34467   int jresult ;
34468   int result;
34469
34470   {
34471     try {
34472       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34473     } CALL_CATCH_EXCEPTION(0);
34474   }
34475
34476   jresult = (int)result;
34477   return jresult;
34478 }
34479
34480
34481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34482   int jresult ;
34483   int result;
34484
34485   {
34486     try {
34487       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34488     } CALL_CATCH_EXCEPTION(0);
34489   }
34490
34491   jresult = (int)result;
34492   return jresult;
34493 }
34494
34495
34496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34497   int jresult ;
34498   int result;
34499
34500   {
34501     try {
34502       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34503     } CALL_CATCH_EXCEPTION(0);
34504   }
34505
34506   jresult = (int)result;
34507   return jresult;
34508 }
34509
34510
34511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34512   int jresult ;
34513   int result;
34514
34515   {
34516     try {
34517       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34518     } CALL_CATCH_EXCEPTION(0);
34519   }
34520
34521   jresult = (int)result;
34522   return jresult;
34523 }
34524
34525
34526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34527   int jresult ;
34528   int result;
34529
34530   {
34531     try {
34532       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34533     } CALL_CATCH_EXCEPTION(0);
34534   }
34535
34536   jresult = (int)result;
34537   return jresult;
34538 }
34539
34540
34541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34542   int jresult ;
34543   int result;
34544
34545   {
34546     try {
34547       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34548     } CALL_CATCH_EXCEPTION(0);
34549   }
34550
34551   jresult = (int)result;
34552   return jresult;
34553 }
34554
34555
34556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34557   int jresult ;
34558   int result;
34559
34560   {
34561     try {
34562       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34563     } CALL_CATCH_EXCEPTION(0);
34564   }
34565
34566   jresult = (int)result;
34567   return jresult;
34568 }
34569
34570
34571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34572   int jresult ;
34573   int result;
34574
34575   {
34576     try {
34577       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34578     } CALL_CATCH_EXCEPTION(0);
34579   }
34580
34581   jresult = (int)result;
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34587   int jresult ;
34588   int result;
34589
34590   {
34591     try {
34592       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34593     } CALL_CATCH_EXCEPTION(0);
34594   }
34595
34596   jresult = (int)result;
34597   return jresult;
34598 }
34599
34600
34601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34602   int jresult ;
34603   int result;
34604
34605   {
34606     try {
34607       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34608     } CALL_CATCH_EXCEPTION(0);
34609   }
34610
34611   jresult = (int)result;
34612   return jresult;
34613 }
34614
34615
34616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34617   int jresult ;
34618   int result;
34619
34620   {
34621     try {
34622       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34623     } CALL_CATCH_EXCEPTION(0);
34624   }
34625
34626   jresult = (int)result;
34627   return jresult;
34628 }
34629
34630
34631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34632   int jresult ;
34633   int result;
34634
34635   {
34636     try {
34637       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34638     } CALL_CATCH_EXCEPTION(0);
34639   }
34640
34641   jresult = (int)result;
34642   return jresult;
34643 }
34644
34645
34646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34647   int jresult ;
34648   int result;
34649
34650   {
34651     try {
34652       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34653     } CALL_CATCH_EXCEPTION(0);
34654   }
34655
34656   jresult = (int)result;
34657   return jresult;
34658 }
34659
34660
34661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34662   int jresult ;
34663   int result;
34664
34665   {
34666     try {
34667       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34668     } CALL_CATCH_EXCEPTION(0);
34669   }
34670
34671   jresult = (int)result;
34672   return jresult;
34673 }
34674
34675
34676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34677   int jresult ;
34678   int result;
34679
34680   {
34681     try {
34682       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34683     } CALL_CATCH_EXCEPTION(0);
34684   }
34685
34686   jresult = (int)result;
34687   return jresult;
34688 }
34689
34690
34691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34692   void * jresult ;
34693   Dali::Toolkit::Builder *result = 0 ;
34694
34695   {
34696     try {
34697       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34698     } CALL_CATCH_EXCEPTION(0);
34699   }
34700
34701   jresult = (void *)result;
34702   return jresult;
34703 }
34704
34705
34706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34707   void * jresult ;
34708   Dali::Toolkit::Builder result;
34709
34710   {
34711     try {
34712       result = Dali::Toolkit::Builder::New();
34713     } CALL_CATCH_EXCEPTION(0);
34714   }
34715
34716   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34717   return jresult;
34718 }
34719
34720
34721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34722   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34723
34724   arg1 = (Dali::Toolkit::Builder *)jarg1;
34725   {
34726     try {
34727       delete arg1;
34728     } CALL_CATCH_EXCEPTION();
34729   }
34730
34731 }
34732
34733
34734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34735   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34736   std::string *arg2 = 0 ;
34737   Dali::Toolkit::Builder::UIFormat arg3 ;
34738
34739   arg1 = (Dali::Toolkit::Builder *)jarg1;
34740   if (!jarg2) {
34741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34742     return ;
34743   }
34744   std::string arg2_str(jarg2);
34745   arg2 = &arg2_str;
34746   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34747   {
34748     try {
34749       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34750     } CALL_CATCH_EXCEPTION();
34751   }
34752
34753
34754   //argout typemap for const std::string&
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34761   std::string *arg2 = 0 ;
34762
34763   arg1 = (Dali::Toolkit::Builder *)jarg1;
34764   if (!jarg2) {
34765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34766     return ;
34767   }
34768   std::string arg2_str(jarg2);
34769   arg2 = &arg2_str;
34770   {
34771     try {
34772       (arg1)->LoadFromString((std::string const &)*arg2);
34773     } CALL_CATCH_EXCEPTION();
34774   }
34775
34776
34777   //argout typemap for const std::string&
34778
34779 }
34780
34781
34782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34783   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34784   Dali::Property::Map *arg2 = 0 ;
34785
34786   arg1 = (Dali::Toolkit::Builder *)jarg1;
34787   arg2 = (Dali::Property::Map *)jarg2;
34788   if (!arg2) {
34789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34790     return ;
34791   }
34792   {
34793     try {
34794       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34795     } CALL_CATCH_EXCEPTION();
34796   }
34797
34798 }
34799
34800
34801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34802   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34803   std::string *arg2 = 0 ;
34804   Dali::Property::Value *arg3 = 0 ;
34805
34806   arg1 = (Dali::Toolkit::Builder *)jarg1;
34807   if (!jarg2) {
34808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34809     return ;
34810   }
34811   std::string arg2_str(jarg2);
34812   arg2 = &arg2_str;
34813   arg3 = (Dali::Property::Value *)jarg3;
34814   if (!arg3) {
34815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34816     return ;
34817   }
34818   {
34819     try {
34820       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34821     } CALL_CATCH_EXCEPTION();
34822   }
34823
34824
34825   //argout typemap for const std::string&
34826
34827 }
34828
34829
34830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34831   void * jresult ;
34832   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34833   Dali::Property::Map *result = 0 ;
34834
34835   arg1 = (Dali::Toolkit::Builder *)jarg1;
34836   {
34837     try {
34838       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34839     } CALL_CATCH_EXCEPTION(0);
34840   }
34841
34842   jresult = (void *)result;
34843   return jresult;
34844 }
34845
34846
34847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34848   void * jresult ;
34849   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34850   std::string *arg2 = 0 ;
34851   Dali::Property::Value *result = 0 ;
34852
34853   arg1 = (Dali::Toolkit::Builder *)jarg1;
34854   if (!jarg2) {
34855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34856     return 0;
34857   }
34858   std::string arg2_str(jarg2);
34859   arg2 = &arg2_str;
34860   {
34861     try {
34862       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34863     } CALL_CATCH_EXCEPTION(0);
34864   }
34865
34866   jresult = (void *)result;
34867
34868   //argout typemap for const std::string&
34869
34870   return jresult;
34871 }
34872
34873
34874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34875   void * jresult ;
34876   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34877   std::string *arg2 = 0 ;
34878   Dali::Animation result;
34879
34880   arg1 = (Dali::Toolkit::Builder *)jarg1;
34881   if (!jarg2) {
34882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34883     return 0;
34884   }
34885   std::string arg2_str(jarg2);
34886   arg2 = &arg2_str;
34887   {
34888     try {
34889       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34890     } CALL_CATCH_EXCEPTION(0);
34891   }
34892
34893   jresult = new Dali::Animation((const Dali::Animation &)result);
34894
34895   //argout typemap for const std::string&
34896
34897   return jresult;
34898 }
34899
34900
34901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34902   void * jresult ;
34903   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34904   std::string *arg2 = 0 ;
34905   Dali::Property::Map *arg3 = 0 ;
34906   Dali::Animation result;
34907
34908   arg1 = (Dali::Toolkit::Builder *)jarg1;
34909   if (!jarg2) {
34910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34911     return 0;
34912   }
34913   std::string arg2_str(jarg2);
34914   arg2 = &arg2_str;
34915   arg3 = (Dali::Property::Map *)jarg3;
34916   if (!arg3) {
34917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34918     return 0;
34919   }
34920   {
34921     try {
34922       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34923     } CALL_CATCH_EXCEPTION(0);
34924   }
34925
34926   jresult = new Dali::Animation((const Dali::Animation &)result);
34927
34928   //argout typemap for const std::string&
34929
34930   return jresult;
34931 }
34932
34933
34934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34935   void * jresult ;
34936   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34937   std::string *arg2 = 0 ;
34938   Dali::Actor arg3 ;
34939   Dali::Actor *argp3 ;
34940   Dali::Animation result;
34941
34942   arg1 = (Dali::Toolkit::Builder *)jarg1;
34943   if (!jarg2) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34945     return 0;
34946   }
34947   std::string arg2_str(jarg2);
34948   arg2 = &arg2_str;
34949   argp3 = (Dali::Actor *)jarg3;
34950   if (!argp3) {
34951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34952     return 0;
34953   }
34954   arg3 = *argp3;
34955   {
34956     try {
34957       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
34958     } CALL_CATCH_EXCEPTION(0);
34959   }
34960
34961   jresult = new Dali::Animation((const Dali::Animation &)result);
34962
34963   //argout typemap for const std::string&
34964
34965   return jresult;
34966 }
34967
34968
34969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
34970   void * jresult ;
34971   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34972   std::string *arg2 = 0 ;
34973   Dali::Property::Map *arg3 = 0 ;
34974   Dali::Actor arg4 ;
34975   Dali::Actor *argp4 ;
34976   Dali::Animation result;
34977
34978   arg1 = (Dali::Toolkit::Builder *)jarg1;
34979   if (!jarg2) {
34980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34981     return 0;
34982   }
34983   std::string arg2_str(jarg2);
34984   arg2 = &arg2_str;
34985   arg3 = (Dali::Property::Map *)jarg3;
34986   if (!arg3) {
34987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34988     return 0;
34989   }
34990   argp4 = (Dali::Actor *)jarg4;
34991   if (!argp4) {
34992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34993     return 0;
34994   }
34995   arg4 = *argp4;
34996   {
34997     try {
34998       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
34999     } CALL_CATCH_EXCEPTION(0);
35000   }
35001
35002   jresult = new Dali::Animation((const Dali::Animation &)result);
35003
35004   //argout typemap for const std::string&
35005
35006   return jresult;
35007 }
35008
35009
35010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
35011   void * jresult ;
35012   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35013   std::string *arg2 = 0 ;
35014   Dali::BaseHandle result;
35015
35016   arg1 = (Dali::Toolkit::Builder *)jarg1;
35017   if (!jarg2) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35019     return 0;
35020   }
35021   std::string arg2_str(jarg2);
35022   arg2 = &arg2_str;
35023   {
35024     try {
35025       result = (arg1)->Create((std::string const &)*arg2);
35026     } CALL_CATCH_EXCEPTION(0);
35027   }
35028
35029   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35030
35031   //argout typemap for const std::string&
35032
35033   return jresult;
35034 }
35035
35036
35037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35038   void * jresult ;
35039   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35040   std::string *arg2 = 0 ;
35041   Dali::Property::Map *arg3 = 0 ;
35042   Dali::BaseHandle result;
35043
35044   arg1 = (Dali::Toolkit::Builder *)jarg1;
35045   if (!jarg2) {
35046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35047     return 0;
35048   }
35049   std::string arg2_str(jarg2);
35050   arg2 = &arg2_str;
35051   arg3 = (Dali::Property::Map *)jarg3;
35052   if (!arg3) {
35053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35054     return 0;
35055   }
35056   {
35057     try {
35058       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35059     } CALL_CATCH_EXCEPTION(0);
35060   }
35061
35062   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35063
35064   //argout typemap for const std::string&
35065
35066   return jresult;
35067 }
35068
35069
35070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35071   void * jresult ;
35072   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35073   std::string *arg2 = 0 ;
35074   Dali::BaseHandle result;
35075
35076   arg1 = (Dali::Toolkit::Builder *)jarg1;
35077   if (!jarg2) {
35078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35079     return 0;
35080   }
35081   std::string arg2_str(jarg2);
35082   arg2 = &arg2_str;
35083   {
35084     try {
35085       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35086     } CALL_CATCH_EXCEPTION(0);
35087   }
35088
35089   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35090
35091   //argout typemap for const std::string&
35092
35093   return jresult;
35094 }
35095
35096
35097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35098   unsigned int jresult ;
35099   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35100   std::string *arg2 = 0 ;
35101   Dali::Handle *arg3 = 0 ;
35102   bool result;
35103
35104   arg1 = (Dali::Toolkit::Builder *)jarg1;
35105   if (!jarg2) {
35106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35107     return 0;
35108   }
35109   std::string arg2_str(jarg2);
35110   arg2 = &arg2_str;
35111   arg3 = (Dali::Handle *)jarg3;
35112   if (!arg3) {
35113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35114     return 0;
35115   }
35116   {
35117     try {
35118       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35119     } CALL_CATCH_EXCEPTION(0);
35120   }
35121
35122   jresult = result;
35123
35124   //argout typemap for const std::string&
35125
35126   return jresult;
35127 }
35128
35129
35130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35131   unsigned int jresult ;
35132   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35133   Dali::Handle *arg2 = 0 ;
35134   std::string *arg3 = 0 ;
35135   bool result;
35136
35137   arg1 = (Dali::Toolkit::Builder *)jarg1;
35138   arg2 = (Dali::Handle *)jarg2;
35139   if (!arg2) {
35140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35141     return 0;
35142   }
35143   if (!jarg3) {
35144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35145     return 0;
35146   }
35147   std::string arg3_str(jarg3);
35148   arg3 = &arg3_str;
35149   {
35150     try {
35151       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35152     } CALL_CATCH_EXCEPTION(0);
35153   }
35154
35155   jresult = result;
35156
35157   //argout typemap for const std::string&
35158
35159   return jresult;
35160 }
35161
35162
35163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35164   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35165   Dali::Actor arg2 ;
35166   Dali::Actor *argp2 ;
35167
35168   arg1 = (Dali::Toolkit::Builder *)jarg1;
35169   argp2 = (Dali::Actor *)jarg2;
35170   if (!argp2) {
35171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35172     return ;
35173   }
35174   arg2 = *argp2;
35175   {
35176     try {
35177       (arg1)->AddActors(arg2);
35178     } CALL_CATCH_EXCEPTION();
35179   }
35180
35181 }
35182
35183
35184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35185   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35186   std::string *arg2 = 0 ;
35187   Dali::Actor arg3 ;
35188   Dali::Actor *argp3 ;
35189
35190   arg1 = (Dali::Toolkit::Builder *)jarg1;
35191   if (!jarg2) {
35192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35193     return ;
35194   }
35195   std::string arg2_str(jarg2);
35196   arg2 = &arg2_str;
35197   argp3 = (Dali::Actor *)jarg3;
35198   if (!argp3) {
35199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35200     return ;
35201   }
35202   arg3 = *argp3;
35203   {
35204     try {
35205       (arg1)->AddActors((std::string const &)*arg2,arg3);
35206     } CALL_CATCH_EXCEPTION();
35207   }
35208
35209
35210   //argout typemap for const std::string&
35211
35212 }
35213
35214
35215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35216   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35217   std::string *arg2 = 0 ;
35218
35219   arg1 = (Dali::Toolkit::Builder *)jarg1;
35220   if (!jarg2) {
35221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35222     return ;
35223   }
35224   std::string arg2_str(jarg2);
35225   arg2 = &arg2_str;
35226   {
35227     try {
35228       (arg1)->CreateRenderTask((std::string const &)*arg2);
35229     } CALL_CATCH_EXCEPTION();
35230   }
35231
35232
35233   //argout typemap for const std::string&
35234
35235 }
35236
35237
35238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35239   void * jresult ;
35240   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35241   std::string *arg2 = 0 ;
35242   Dali::Path result;
35243
35244   arg1 = (Dali::Toolkit::Builder *)jarg1;
35245   if (!jarg2) {
35246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35247     return 0;
35248   }
35249   std::string arg2_str(jarg2);
35250   arg2 = &arg2_str;
35251   {
35252     try {
35253       result = (arg1)->GetPath((std::string const &)*arg2);
35254     } CALL_CATCH_EXCEPTION(0);
35255   }
35256
35257   jresult = new Dali::Path((const Dali::Path &)result);
35258
35259   //argout typemap for const std::string&
35260
35261   return jresult;
35262 }
35263
35264
35265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35266   void * jresult ;
35267   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35268   std::string *arg2 = 0 ;
35269   Dali::PathConstrainer result;
35270
35271   arg1 = (Dali::Toolkit::Builder *)jarg1;
35272   if (!jarg2) {
35273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35274     return 0;
35275   }
35276   std::string arg2_str(jarg2);
35277   arg2 = &arg2_str;
35278   {
35279     try {
35280       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35281     } CALL_CATCH_EXCEPTION(0);
35282   }
35283
35284   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35285
35286   //argout typemap for const std::string&
35287
35288   return jresult;
35289 }
35290
35291
35292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35293   void * jresult ;
35294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35295   std::string *arg2 = 0 ;
35296   Dali::LinearConstrainer result;
35297
35298   arg1 = (Dali::Toolkit::Builder *)jarg1;
35299   if (!jarg2) {
35300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35301     return 0;
35302   }
35303   std::string arg2_str(jarg2);
35304   arg2 = &arg2_str;
35305   {
35306     try {
35307       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35308     } CALL_CATCH_EXCEPTION(0);
35309   }
35310
35311   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35312
35313   //argout typemap for const std::string&
35314
35315   return jresult;
35316 }
35317
35318
35319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35320   void * jresult ;
35321   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35322   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35323
35324   arg1 = (Dali::Toolkit::Builder *)jarg1;
35325   {
35326     try {
35327       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35328     } CALL_CATCH_EXCEPTION(0);
35329   }
35330
35331   jresult = (void *)result;
35332   return jresult;
35333 }
35334
35335
35336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35337   void * jresult ;
35338   Dali::Toolkit::TransitionData *result = 0 ;
35339
35340   {
35341     try {
35342       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35343     } CALL_CATCH_EXCEPTION(0);
35344   }
35345
35346   jresult = (void *)result;
35347   return jresult;
35348 }
35349
35350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35351   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35352
35353   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35354   {
35355     try {
35356       delete arg1;
35357     } CALL_CATCH_EXCEPTION();
35358   }
35359
35360 }
35361
35362
35363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35364   void * jresult ;
35365   Dali::Property::Map *arg1 = 0 ;
35366   Dali::Toolkit::TransitionData result;
35367
35368   arg1 = (Dali::Property::Map *)jarg1;
35369   if (!arg1) {
35370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35371     return 0;
35372   }
35373   {
35374     try {
35375       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35376     } CALL_CATCH_EXCEPTION(0);
35377   }
35378
35379   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35380   return jresult;
35381 }
35382
35383
35384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35385   void * jresult ;
35386   Dali::Property::Array *arg1 = 0 ;
35387   Dali::Toolkit::TransitionData result;
35388
35389   arg1 = (Dali::Property::Array *)jarg1;
35390   if (!arg1) {
35391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35392     return 0;
35393   }
35394   {
35395     try {
35396       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35397     } CALL_CATCH_EXCEPTION(0);
35398   }
35399
35400   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35401   return jresult;
35402 }
35403
35404
35405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35406   void * jresult ;
35407   Dali::BaseHandle arg1 ;
35408   Dali::BaseHandle *argp1 ;
35409   Dali::Toolkit::TransitionData result;
35410
35411   argp1 = (Dali::BaseHandle *)jarg1;
35412   if (!argp1) {
35413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35414     return 0;
35415   }
35416   arg1 = *argp1;
35417   {
35418     try {
35419       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35420     } CALL_CATCH_EXCEPTION(0);
35421   }
35422
35423   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35424   return jresult;
35425 }
35426
35427
35428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35429   void * jresult ;
35430   Dali::Toolkit::TransitionData *arg1 = 0 ;
35431   Dali::Toolkit::TransitionData *result = 0 ;
35432
35433   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35434   if (!arg1) {
35435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35436     return 0;
35437   }
35438   {
35439     try {
35440       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35441     } CALL_CATCH_EXCEPTION(0);
35442   }
35443
35444   jresult = (void *)result;
35445   return jresult;
35446 }
35447
35448
35449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35450   void * jresult ;
35451   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35452   Dali::Toolkit::TransitionData *arg2 = 0 ;
35453   Dali::Toolkit::TransitionData *result = 0 ;
35454
35455   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35456   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35457   if (!arg2) {
35458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35459     return 0;
35460   }
35461   {
35462     try {
35463       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35464     } CALL_CATCH_EXCEPTION(0);
35465   }
35466
35467   jresult = (void *)result;
35468   return jresult;
35469 }
35470
35471
35472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35473   unsigned long jresult ;
35474   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35475   size_t result;
35476
35477   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35478   {
35479     try {
35480       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35481     } CALL_CATCH_EXCEPTION(0);
35482   }
35483
35484   jresult = (unsigned long)result;
35485   return jresult;
35486 }
35487
35488
35489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35490   void * jresult ;
35491   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35492   size_t arg2 ;
35493   Dali::Property::Map result;
35494
35495   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35496   arg2 = (size_t)jarg2;
35497   {
35498     try {
35499       result = (arg1)->GetAnimatorAt(arg2);
35500     } CALL_CATCH_EXCEPTION(0);
35501   }
35502
35503   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35504   return jresult;
35505 }
35506
35507
35508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35509   int jresult ;
35510   int result;
35511
35512   {
35513     try {
35514       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35515     } CALL_CATCH_EXCEPTION(0);
35516   }
35517
35518   jresult = (int)result;
35519   return jresult;
35520 }
35521
35522
35523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35524   int jresult ;
35525   int result;
35526
35527   {
35528     try {
35529       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35530     } CALL_CATCH_EXCEPTION(0);
35531   }
35532
35533   jresult = (int)result;
35534   return jresult;
35535 }
35536
35537
35538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35539   int jresult ;
35540   int result;
35541
35542   {
35543     try {
35544       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35545     } CALL_CATCH_EXCEPTION(0);
35546   }
35547
35548   jresult = (int)result;
35549   return jresult;
35550 }
35551
35552
35553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35554   int jresult ;
35555   int result;
35556
35557   {
35558     try {
35559       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35560     } CALL_CATCH_EXCEPTION(0);
35561   }
35562
35563   jresult = (int)result;
35564   return jresult;
35565 }
35566
35567
35568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35569   int jresult ;
35570   int result;
35571
35572   {
35573     try {
35574       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35575     } CALL_CATCH_EXCEPTION(0);
35576   }
35577
35578   jresult = (int)result;
35579   return jresult;
35580 }
35581
35582
35583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35584   int jresult ;
35585   int result;
35586
35587   {
35588     try {
35589       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35590     } CALL_CATCH_EXCEPTION(0);
35591   }
35592
35593   jresult = (int)result;
35594   return jresult;
35595 }
35596
35597
35598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35599   int jresult ;
35600   int result;
35601
35602   {
35603     try {
35604       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35605     } CALL_CATCH_EXCEPTION(0);
35606   }
35607
35608   jresult = (int)result;
35609   return jresult;
35610 }
35611
35612
35613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35614   int jresult ;
35615   int result;
35616
35617   {
35618     try {
35619       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35620     } CALL_CATCH_EXCEPTION(0);
35621   }
35622
35623   jresult = (int)result;
35624   return jresult;
35625 }
35626
35627
35628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35629   int jresult ;
35630   int result;
35631
35632   {
35633     try {
35634       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35635     } CALL_CATCH_EXCEPTION(0);
35636   }
35637
35638   jresult = (int)result;
35639   return jresult;
35640 }
35641
35642
35643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35644   int jresult ;
35645   int result;
35646
35647   {
35648     try {
35649       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35650     } CALL_CATCH_EXCEPTION(0);
35651   }
35652
35653   jresult = (int)result;
35654   return jresult;
35655 }
35656
35657
35658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35659   int jresult ;
35660   int result;
35661
35662   {
35663     try {
35664       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35665     } CALL_CATCH_EXCEPTION(0);
35666   }
35667
35668   jresult = (int)result;
35669   return jresult;
35670 }
35671
35672
35673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35674   int jresult ;
35675   int result;
35676
35677   {
35678     try {
35679       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35680     } CALL_CATCH_EXCEPTION(0);
35681   }
35682
35683   jresult = (int)result;
35684   return jresult;
35685 }
35686
35687
35688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35689   int jresult ;
35690   int result;
35691
35692   {
35693     try {
35694       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35695     } CALL_CATCH_EXCEPTION(0);
35696   }
35697
35698   jresult = (int)result;
35699   return jresult;
35700 }
35701
35702
35703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35704   int jresult ;
35705   int result;
35706
35707   {
35708     try {
35709       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35710     } CALL_CATCH_EXCEPTION(0);
35711   }
35712
35713   jresult = (int)result;
35714   return jresult;
35715 }
35716
35717
35718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35719   void * jresult ;
35720   Dali::Toolkit::Control result;
35721
35722   {
35723     try {
35724       result = Dali::Toolkit::Internal::Control::New();
35725     } CALL_CATCH_EXCEPTION(0);
35726   }
35727
35728   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35729   return jresult;
35730 }
35731
35732
35733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35734   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35735   std::string *arg2 = 0 ;
35736
35737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35738   if (!jarg2) {
35739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35740     return ;
35741   }
35742   std::string arg2_str(jarg2);
35743   arg2 = &arg2_str;
35744   {
35745     try {
35746       (arg1)->SetStyleName((std::string const &)*arg2);
35747     } CALL_CATCH_EXCEPTION();
35748   }
35749
35750
35751   //argout typemap for const std::string&
35752
35753 }
35754
35755
35756 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35757   char * jresult ;
35758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35759   std::string *result = 0 ;
35760
35761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35762   {
35763     try {
35764       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35765     } CALL_CATCH_EXCEPTION(0);
35766   }
35767
35768   jresult = SWIG_csharp_string_callback(result->c_str());
35769   return jresult;
35770 }
35771
35772
35773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35775   Dali::Vector4 *arg2 = 0 ;
35776
35777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35778   arg2 = (Dali::Vector4 *)jarg2;
35779   if (!arg2) {
35780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35781     return ;
35782   }
35783   {
35784     try {
35785       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35786     } CALL_CATCH_EXCEPTION();
35787   }
35788
35789 }
35790
35791
35792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35793   void * jresult ;
35794   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35795   Dali::Vector4 result;
35796
35797   arg1 = (Dali::Handle *)jarg1;
35798   {
35799     try {
35800       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35801       if (resultMap)
35802       {
35803         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35804         if(type && type->Get<int>() == Visual::COLOR )
35805         {
35806           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35807           if (value)
35808           {
35809             result = value->Get<Vector4>();
35810           }
35811         }
35812       }
35813     } CALL_CATCH_EXCEPTION(0);
35814   }
35815
35816   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35817   return jresult;
35818 }
35819
35820
35821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35823   Dali::Property::Map *arg2 = 0 ;
35824
35825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35826   arg2 = (Dali::Property::Map *)jarg2;
35827   if (!arg2) {
35828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35829     return ;
35830   }
35831   {
35832     try {
35833       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35834     } CALL_CATCH_EXCEPTION();
35835   }
35836
35837 }
35838
35839
35840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35842
35843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35844   {
35845     try {
35846       (arg1)->ClearBackground();
35847     } CALL_CATCH_EXCEPTION();
35848   }
35849
35850 }
35851
35852
35853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35855   Dali::Gesture::Type arg2 ;
35856
35857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35858   arg2 = (Dali::Gesture::Type)jarg2;
35859   {
35860     try {
35861       (arg1)->EnableGestureDetection(arg2);
35862     } CALL_CATCH_EXCEPTION();
35863   }
35864
35865 }
35866
35867
35868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35870   Dali::Gesture::Type arg2 ;
35871
35872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35873   arg2 = (Dali::Gesture::Type)jarg2;
35874   {
35875     try {
35876       (arg1)->DisableGestureDetection(arg2);
35877     } CALL_CATCH_EXCEPTION();
35878   }
35879
35880 }
35881
35882
35883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35884   void * jresult ;
35885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35886   Dali::PinchGestureDetector result;
35887
35888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35889   {
35890     try {
35891       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35892     } CALL_CATCH_EXCEPTION(0);
35893   }
35894
35895   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35896   return jresult;
35897 }
35898
35899
35900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35901   void * jresult ;
35902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35903   Dali::PanGestureDetector result;
35904
35905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35906   {
35907     try {
35908       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35909     } CALL_CATCH_EXCEPTION(0);
35910   }
35911
35912   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35913   return jresult;
35914 }
35915
35916
35917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35918   void * jresult ;
35919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35920   Dali::TapGestureDetector result;
35921
35922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35923   {
35924     try {
35925       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35926     } CALL_CATCH_EXCEPTION(0);
35927   }
35928
35929   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35930   return jresult;
35931 }
35932
35933
35934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35935   void * jresult ;
35936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35937   Dali::LongPressGestureDetector result;
35938
35939   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35940   {
35941     try {
35942       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35943     } CALL_CATCH_EXCEPTION(0);
35944   }
35945
35946   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35947   return jresult;
35948 }
35949
35950
35951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
35952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35953   bool arg2 ;
35954
35955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35956   arg2 = jarg2 ? true : false;
35957   {
35958     try {
35959       (arg1)->SetKeyboardNavigationSupport(arg2);
35960     } CALL_CATCH_EXCEPTION();
35961   }
35962
35963 }
35964
35965
35966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
35967   unsigned int jresult ;
35968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35969   bool result;
35970
35971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35972   {
35973     try {
35974       result = (bool)(arg1)->IsKeyboardNavigationSupported();
35975     } CALL_CATCH_EXCEPTION(0);
35976   }
35977
35978   jresult = result;
35979   return jresult;
35980 }
35981
35982
35983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
35984   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35985
35986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35987   {
35988     try {
35989       (arg1)->SetKeyInputFocus();
35990     } CALL_CATCH_EXCEPTION();
35991   }
35992
35993 }
35994
35995
35996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
35997   unsigned int jresult ;
35998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35999   bool result;
36000
36001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36002   {
36003     try {
36004       result = (bool)(arg1)->HasKeyInputFocus();
36005     } CALL_CATCH_EXCEPTION(0);
36006   }
36007
36008   jresult = result;
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
36014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36015
36016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36017   {
36018     try {
36019       (arg1)->ClearKeyInputFocus();
36020     } CALL_CATCH_EXCEPTION();
36021   }
36022
36023 }
36024
36025
36026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
36027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36028   bool arg2 ;
36029
36030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36031   arg2 = jarg2 ? true : false;
36032   {
36033     try {
36034       (arg1)->SetAsKeyboardFocusGroup(arg2);
36035     } CALL_CATCH_EXCEPTION();
36036   }
36037
36038 }
36039
36040
36041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
36042   unsigned int jresult ;
36043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36044   bool result;
36045
36046   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36047   {
36048     try {
36049       result = (bool)(arg1)->IsKeyboardFocusGroup();
36050     } CALL_CATCH_EXCEPTION(0);
36051   }
36052
36053   jresult = result;
36054   return jresult;
36055 }
36056
36057
36058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
36059   void * jresult ;
36060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36061   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
36062
36063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36064   {
36065     try {
36066       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36067     } CALL_CATCH_EXCEPTION(0);
36068   }
36069
36070   jresult = (void *)result;
36071   return jresult;
36072 }
36073
36074
36075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36076   void * jresult ;
36077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36078   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36079
36080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36081   {
36082     try {
36083       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36084     } CALL_CATCH_EXCEPTION(0);
36085   }
36086
36087   jresult = (void *)result;
36088   return jresult;
36089 }
36090
36091
36092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
36093   void * jresult ;
36094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36095   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36096
36097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36098   {
36099     try {
36100       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36101     } CALL_CATCH_EXCEPTION(0);
36102   }
36103
36104   jresult = (void *)result;
36105   return jresult;
36106 }
36107
36108
36109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36111   int arg2 ;
36112   SwigDirector_ViewImpl *darg = 0;
36113
36114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36115   arg2 = (int)jarg2;
36116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36117   if(!darg) {
36118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36119     return;
36120   }
36121   {
36122     try {
36123       if(darg) {
36124         (darg)->OnSceneConnection(arg2);
36125       }
36126     } CALL_CATCH_EXCEPTION();
36127   }
36128
36129 }
36130
36131
36132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36134   int arg2 ;
36135   SwigDirector_ViewImpl *darg = 0;
36136
36137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36138   arg2 = (int)jarg2;
36139   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36140   if(!darg) {
36141     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36142     return;
36143   }
36144   {
36145     try {
36146       if(darg) {
36147         (darg)->OnSceneConnectionSwigPublic(arg2);
36148       }
36149     } CALL_CATCH_EXCEPTION();
36150   }
36151
36152 }
36153
36154
36155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36157   SwigDirector_ViewImpl *darg = 0;
36158
36159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36160   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36161   if(!darg) {
36162     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36163     return;
36164   }
36165   {
36166     try {
36167       if(darg) {
36168         (darg)->OnSceneDisconnection();
36169       }
36170     } CALL_CATCH_EXCEPTION();
36171   }
36172
36173 }
36174
36175
36176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36178   SwigDirector_ViewImpl *darg = 0;
36179
36180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36181   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36182   if(!darg) {
36183     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36184     return;
36185   }
36186   {
36187     try {
36188       if(darg) {
36189         (darg)->OnSceneDisconnectionSwigPublic();
36190       }
36191     } CALL_CATCH_EXCEPTION();
36192   }
36193
36194 }
36195
36196
36197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
36198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36199   Dali::Actor *arg2 = 0 ;
36200   SwigDirector_ViewImpl *darg = 0;
36201
36202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36203   arg2 = (Dali::Actor *)jarg2;
36204   if (!arg2) {
36205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36206     return ;
36207   }
36208   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36209   if(!darg) {
36210     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36211     return;
36212   }
36213   {
36214     try {
36215       if(darg) {
36216         (darg)->OnChildAdd(*arg2);
36217       }
36218     } CALL_CATCH_EXCEPTION();
36219   }
36220
36221 }
36222
36223
36224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36226   Dali::Actor *arg2 = 0 ;
36227   SwigDirector_ViewImpl *darg = 0;
36228
36229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36230   arg2 = (Dali::Actor *)jarg2;
36231   if (!arg2) {
36232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36233     return ;
36234   }
36235   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36236   if(!darg) {
36237     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36238     return;
36239   }
36240   {
36241     try {
36242       if(darg) {
36243           (darg)->OnChildAddSwigPublic(*arg2);
36244       }
36245     } CALL_CATCH_EXCEPTION();
36246   }
36247
36248 }
36249
36250
36251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36253   Dali::Actor *arg2 = 0 ;
36254   SwigDirector_ViewImpl *darg = 0;
36255
36256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36257   arg2 = (Dali::Actor *)jarg2;
36258   if (!arg2) {
36259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36260     return ;
36261   }
36262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36263   if(!darg) {
36264     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36265     return;
36266   }
36267   {
36268     try {
36269       if(darg) {
36270         (darg)->OnChildRemove(*arg2);
36271       }
36272     } CALL_CATCH_EXCEPTION();
36273   }
36274
36275 }
36276
36277
36278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36280   Dali::Actor *arg2 = 0 ;
36281   SwigDirector_ViewImpl *darg = 0;
36282
36283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36284   arg2 = (Dali::Actor *)jarg2;
36285   if (!arg2) {
36286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36287     return ;
36288   }
36289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36290   if(!darg) {
36291     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36292     return;
36293   }
36294   {
36295     try {
36296       if(darg) {
36297         (darg)->OnChildRemoveSwigPublic(*arg2);
36298       }
36299     } CALL_CATCH_EXCEPTION();
36300   }
36301
36302 }
36303
36304
36305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36307   Dali::Property::Index arg2 ;
36308   Dali::Property::Value arg3 ;
36309   Dali::Property::Value *argp3 ;
36310   SwigDirector_ViewImpl *darg = 0;
36311
36312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36313   arg2 = (Dali::Property::Index)jarg2;
36314   argp3 = (Dali::Property::Value *)jarg3;
36315   if (!argp3) {
36316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36317     return ;
36318   }
36319   arg3 = *argp3;
36320   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36321   if (!darg) {
36322     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36323     return;
36324   }
36325   {
36326     try {
36327       (darg)->OnPropertySet(arg2,arg3);
36328     } CALL_CATCH_EXCEPTION();
36329   }
36330
36331 }
36332
36333
36334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36336   Dali::Vector3 *arg2 = 0 ;
36337   SwigDirector_ViewImpl *darg = 0;
36338
36339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36340   arg2 = (Dali::Vector3 *)jarg2;
36341   if (!arg2) {
36342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36343     return ;
36344   }
36345   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36346   if (!darg) {
36347     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36348     return;
36349   }
36350   {
36351     try {
36352       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36353     } CALL_CATCH_EXCEPTION();
36354   }
36355
36356 }
36357
36358
36359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36361   Dali::Vector3 *arg2 = 0 ;
36362   SwigDirector_ViewImpl *darg = 0;
36363
36364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36365   arg2 = (Dali::Vector3 *)jarg2;
36366   if (!arg2) {
36367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36368     return ;
36369   }
36370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36371   if (!darg) {
36372     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36373     return;
36374   }
36375   {
36376     try {
36377       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36378     } CALL_CATCH_EXCEPTION();
36379   }
36380
36381 }
36382
36383
36384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36386   Dali::Animation *arg2 = 0 ;
36387   Dali::Vector3 *arg3 = 0 ;
36388   SwigDirector_ViewImpl *darg = 0;
36389
36390   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36391   arg2 = (Dali::Animation *)jarg2;
36392   if (!arg2) {
36393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36394     return ;
36395   }
36396   arg3 = (Dali::Vector3 *)jarg3;
36397   if (!arg3) {
36398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36399     return ;
36400   }
36401   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36402   if (!darg) {
36403     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36404     return;
36405   }
36406   {
36407     try {
36408       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36409     } CALL_CATCH_EXCEPTION();
36410   }
36411
36412 }
36413
36414
36415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36417   Dali::Animation *arg2 = 0 ;
36418   Dali::Vector3 *arg3 = 0 ;
36419   SwigDirector_ViewImpl *darg = 0;
36420
36421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36422   arg2 = (Dali::Animation *)jarg2;
36423   if (!arg2) {
36424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36425     return ;
36426   }
36427   arg3 = (Dali::Vector3 *)jarg3;
36428   if (!arg3) {
36429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36430     return ;
36431   }
36432   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36433   if (!darg) {
36434     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36435     return;
36436   }
36437   {
36438     try {
36439       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36440     } CALL_CATCH_EXCEPTION();
36441   }
36442 }
36443
36444
36445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
36446   unsigned int jresult ;
36447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36448   Dali::HoverEvent *arg2 = 0 ;
36449   SwigDirector_ViewImpl *darg = 0;
36450   bool result;
36451
36452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36453   arg2 = (Dali::HoverEvent *)jarg2;
36454   if (!arg2) {
36455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36456     return 0;
36457   }
36458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36459   if (!darg) {
36460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36461     return 0;
36462   }
36463   {
36464     try {
36465       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
36466     } CALL_CATCH_EXCEPTION(0);
36467   }
36468
36469   jresult = result;
36470   return jresult;
36471 }
36472
36473
36474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36475   unsigned int jresult ;
36476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36477   Dali::HoverEvent *arg2 = 0 ;
36478   SwigDirector_ViewImpl *darg = 0;
36479   bool result;
36480
36481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36482   arg2 = (Dali::HoverEvent *)jarg2;
36483   if (!arg2) {
36484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36485     return 0;
36486   }
36487   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36488   if (!darg) {
36489     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36490     return 0;
36491   }
36492   {
36493     try {
36494       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
36495     } CALL_CATCH_EXCEPTION(0);
36496   }
36497
36498   jresult = result;
36499   return jresult;
36500 }
36501
36502
36503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36504   unsigned int jresult ;
36505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36506   Dali::KeyEvent *arg2 = 0 ;
36507   SwigDirector_ViewImpl *darg = 0;
36508   bool result;
36509
36510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36511   arg2 = (Dali::KeyEvent *)jarg2;
36512   if (!arg2) {
36513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36514     return 0;
36515   }
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 = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36524     } CALL_CATCH_EXCEPTION(0);
36525   }
36526
36527   jresult = result;
36528   return jresult;
36529 }
36530
36531
36532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36533   unsigned int jresult ;
36534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36535   Dali::KeyEvent *arg2 = 0 ;
36536   SwigDirector_ViewImpl *darg = 0;
36537   bool result;
36538
36539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36540   arg2 = (Dali::KeyEvent *)jarg2;
36541   if (!arg2) {
36542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36543     return 0;
36544   }
36545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36546   if (!darg) {
36547     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36548     return 0;
36549   }
36550   {
36551     try {
36552       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36553     } CALL_CATCH_EXCEPTION(0);
36554   }
36555
36556   jresult = result;
36557   return jresult;
36558 }
36559
36560
36561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
36562   unsigned int jresult ;
36563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36564   Dali::WheelEvent *arg2 = 0 ;
36565   SwigDirector_ViewImpl *darg = 0;
36566   bool result;
36567
36568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36569   arg2 = (Dali::WheelEvent *)jarg2;
36570   if (!arg2) {
36571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36572     return 0;
36573   }
36574   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36575   if (!darg) {
36576     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36577     return 0;
36578   }
36579   {
36580     try {
36581       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
36582     } CALL_CATCH_EXCEPTION(0);
36583   }
36584
36585   jresult = result;
36586   return jresult;
36587 }
36588
36589
36590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36591   unsigned int jresult ;
36592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36593   Dali::WheelEvent *arg2 = 0 ;
36594   SwigDirector_ViewImpl *darg = 0;
36595   bool result;
36596
36597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36598   arg2 = (Dali::WheelEvent *)jarg2;
36599   if (!arg2) {
36600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36601     return 0;
36602   }
36603   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36604   if (!darg) {
36605     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36606     return 0;
36607   }
36608   {
36609     try {
36610       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
36611     } CALL_CATCH_EXCEPTION(0);
36612   }
36613
36614   jresult = result;
36615   return jresult;
36616 }
36617
36618
36619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36621   Dali::Vector2 *arg2 = 0 ;
36622   Dali::RelayoutContainer *arg3 = 0 ;
36623   SwigDirector_ViewImpl *darg = 0;
36624
36625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36626   arg2 = (Dali::Vector2 *)jarg2;
36627   if (!arg2) {
36628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36629     return ;
36630   }
36631   arg3 = (Dali::RelayoutContainer *)jarg3;
36632   if (!arg3) {
36633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36634     return ;
36635   }
36636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36637   if (!darg) {
36638     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36639     return;
36640   }
36641   {
36642     try {
36643       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36644     } CALL_CATCH_EXCEPTION();
36645   }
36646
36647 }
36648
36649
36650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36652   Dali::Vector2 *arg2 = 0 ;
36653   Dali::RelayoutContainer *arg3 = 0 ;
36654   SwigDirector_ViewImpl *darg = 0;
36655
36656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36657   arg2 = (Dali::Vector2 *)jarg2;
36658   if (!arg2) {
36659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36660     return ;
36661   }
36662   arg3 = (Dali::RelayoutContainer *)jarg3;
36663   if (!arg3) {
36664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36665     return ;
36666   }
36667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36668   if (!darg) {
36669     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36670     return;
36671   }
36672   {
36673     try {
36674       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36675     } CALL_CATCH_EXCEPTION();
36676   }
36677
36678 }
36679
36680
36681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36683   Dali::ResizePolicy::Type arg2 ;
36684   Dali::Dimension::Type arg3 ;
36685   SwigDirector_ViewImpl *darg = 0;
36686
36687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36688   arg2 = (Dali::ResizePolicy::Type)jarg2;
36689   arg3 = (Dali::Dimension::Type)jarg3;
36690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36691   if (!darg) {
36692     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36693     return;
36694   }
36695   {
36696     try {
36697       (darg)->OnSetResizePolicy(arg2,arg3);
36698     } CALL_CATCH_EXCEPTION();
36699   }
36700
36701 }
36702
36703
36704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36706   Dali::ResizePolicy::Type arg2 ;
36707   Dali::Dimension::Type arg3 ;
36708   SwigDirector_ViewImpl *darg = 0;
36709
36710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36711   arg2 = (Dali::ResizePolicy::Type)jarg2;
36712   arg3 = (Dali::Dimension::Type)jarg3;
36713   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36714   if (!darg) {
36715     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36716     return;
36717   }
36718   {
36719     try {
36720       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36721     } CALL_CATCH_EXCEPTION();
36722   }
36723
36724 }
36725
36726
36727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36728   void * jresult ;
36729   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36730   SwigDirector_ViewImpl *darg = 0;
36731   Dali::Vector3 result;
36732
36733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36734   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36735   if (!darg) {
36736     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36737     return 0;
36738   }
36739   {
36740     try {
36741       result = (darg)->GetNaturalSize();
36742     } CALL_CATCH_EXCEPTION(0);
36743   }
36744
36745   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36746   return jresult;
36747 }
36748
36749
36750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36751   void * jresult ;
36752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36753   SwigDirector_ViewImpl *darg = 0;
36754   Dali::Vector3 result;
36755
36756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36757   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36758   if (!darg) {
36759     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36760     return 0;
36761   }
36762   {
36763     try {
36764       result = (darg)->GetNaturalSizeSwigPublic();
36765     } CALL_CATCH_EXCEPTION(0);
36766   }
36767
36768   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36769   return jresult;
36770 }
36771
36772
36773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36774   float jresult ;
36775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36776   Dali::Actor *arg2 = 0 ;
36777   Dali::Dimension::Type arg3 ;
36778   SwigDirector_ViewImpl *darg = 0;
36779   float result;
36780
36781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36782   arg2 = (Dali::Actor *)jarg2;
36783   if (!arg2) {
36784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36785     return 0;
36786   }
36787   arg3 = (Dali::Dimension::Type)jarg3;
36788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36789   if (!darg) {
36790     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36791     return 0;
36792   }
36793   {
36794     try {
36795       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36796     } CALL_CATCH_EXCEPTION(0);
36797   }
36798
36799   jresult = result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36805   float jresult ;
36806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36807   Dali::Actor *arg2 = 0 ;
36808   Dali::Dimension::Type arg3 ;
36809   SwigDirector_ViewImpl *darg = 0;
36810   float result;
36811
36812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36813   arg2 = (Dali::Actor *)jarg2;
36814   if (!arg2) {
36815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36816     return 0;
36817   }
36818   arg3 = (Dali::Dimension::Type)jarg3;
36819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36820   if (!darg) {
36821     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36822     return 0;
36823   }
36824   {
36825     try {
36826       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36827     } CALL_CATCH_EXCEPTION(0);
36828   }
36829
36830   jresult = result;
36831   return jresult;
36832 }
36833
36834
36835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36836   float jresult ;
36837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36838   float arg2 ;
36839   SwigDirector_ViewImpl *darg = 0;
36840   float result;
36841
36842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36843   arg2 = (float)jarg2;
36844   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36845   if (!darg) {
36846     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36847     return 0;
36848   }
36849   {
36850     try {
36851       result = (float)(darg)->GetHeightForWidth(arg2);
36852     } CALL_CATCH_EXCEPTION(0);
36853   }
36854
36855   jresult = result;
36856   return jresult;
36857 }
36858
36859
36860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36861   float jresult ;
36862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36863   float arg2 ;
36864   SwigDirector_ViewImpl *darg = 0;
36865   float result;
36866
36867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36868   arg2 = (float)jarg2;
36869   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36870   if (!darg) {
36871     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36872     return 0;
36873   }
36874   {
36875     try {
36876       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36877     } CALL_CATCH_EXCEPTION(0);
36878   }
36879
36880   jresult = result;
36881   return jresult;
36882 }
36883
36884
36885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36886   float jresult ;
36887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36888   float arg2 ;
36889   SwigDirector_ViewImpl *darg = 0;
36890   float result;
36891
36892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36893   arg2 = (float)jarg2;
36894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36895   if (!darg) {
36896     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36897     return 0;
36898   }
36899   {
36900     try {
36901       result = (float)(darg)->GetWidthForHeight(arg2);
36902     } CALL_CATCH_EXCEPTION(0);
36903   }
36904
36905   jresult = result;
36906   return jresult;
36907 }
36908
36909
36910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36911   float jresult ;
36912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36913   float arg2 ;
36914   SwigDirector_ViewImpl *darg = 0;
36915   float result;
36916
36917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36918   arg2 = (float)jarg2;
36919   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36920   if (!darg) {
36921     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36922     return 0;
36923   }
36924   {
36925     try {
36926       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36927     } CALL_CATCH_EXCEPTION(0);
36928   }
36929
36930   jresult = result;
36931   return jresult;
36932 }
36933
36934
36935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36936   unsigned int jresult ;
36937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36938   Dali::Dimension::Type arg2 ;
36939   SwigDirector_ViewImpl *darg = 0;
36940   bool result;
36941
36942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36943   arg2 = (Dali::Dimension::Type)jarg2;
36944   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36945   if (!darg) {
36946     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36947     return 0;
36948   }
36949   {
36950     try {
36951       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
36952     } CALL_CATCH_EXCEPTION(0);
36953   }
36954
36955   jresult = result;
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
36961   unsigned int jresult ;
36962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36963   Dali::Dimension::Type arg2 ;
36964   SwigDirector_ViewImpl *darg = 0;
36965   bool result;
36966
36967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36968   arg2 = (Dali::Dimension::Type)jarg2;
36969   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36970   if (!darg) {
36971     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36972     return 0;
36973   }
36974   {
36975     try {
36976       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
36977     } CALL_CATCH_EXCEPTION(0);
36978   }
36979
36980   jresult = result;
36981   return jresult;
36982 }
36983
36984
36985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
36986   unsigned int jresult ;
36987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36988   SwigDirector_ViewImpl *darg = 0;
36989   bool result;
36990
36991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36993   if (!darg) {
36994     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36995     return 0;
36996   }
36997   {
36998     try {
36999       result = (bool)(darg)->RelayoutDependentOnChildren();
37000     } CALL_CATCH_EXCEPTION(0);
37001   }
37002
37003   jresult = result;
37004   return jresult;
37005 }
37006
37007
37008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
37009   unsigned int jresult ;
37010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37011   SwigDirector_ViewImpl *darg = 0;
37012   bool result;
37013
37014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37015   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37016   if (!darg) {
37017     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37018     return 0;
37019   }
37020   {
37021     try {
37022       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
37023     } CALL_CATCH_EXCEPTION(0);
37024   }
37025
37026   jresult = result;
37027   return jresult;
37028 }
37029
37030
37031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
37032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37033   Dali::Dimension::Type arg2 ;
37034   SwigDirector_ViewImpl *darg = 0;
37035
37036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37037   arg2 = (Dali::Dimension::Type)jarg2;
37038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37039   if (!darg) {
37040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37041     return;
37042   }
37043   {
37044     try {
37045       (darg)->OnCalculateRelayoutSize(arg2);
37046     } CALL_CATCH_EXCEPTION();
37047   }
37048
37049 }
37050
37051
37052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
37053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37054   Dali::Dimension::Type arg2 ;
37055   SwigDirector_ViewImpl *darg = 0;
37056
37057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37058   arg2 = (Dali::Dimension::Type)jarg2;
37059   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37060   if (!darg) {
37061     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37062     return;
37063   }
37064   {
37065     try {
37066       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
37067     } CALL_CATCH_EXCEPTION();
37068   }
37069
37070 }
37071
37072
37073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
37074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37075   float arg2 ;
37076   Dali::Dimension::Type arg3 ;
37077   SwigDirector_ViewImpl *darg = 0;
37078
37079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37080   arg2 = (float)jarg2;
37081   arg3 = (Dali::Dimension::Type)jarg3;
37082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37083   if (!darg) {
37084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37085     return;
37086   }
37087   {
37088     try {
37089       (darg)->OnLayoutNegotiated(arg2,arg3);
37090     } CALL_CATCH_EXCEPTION();
37091   }
37092
37093 }
37094
37095
37096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
37097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37098   float arg2 ;
37099   Dali::Dimension::Type arg3 ;
37100   SwigDirector_ViewImpl *darg = 0;
37101
37102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37103   arg2 = (float)jarg2;
37104   arg3 = (Dali::Dimension::Type)jarg3;
37105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37106   if (!darg) {
37107     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37108     return;
37109   }
37110   {
37111     try {
37112       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
37113     } CALL_CATCH_EXCEPTION();
37114   }
37115
37116 }
37117
37118
37119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
37120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37121
37122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37123   {
37124     try {
37125       (arg1)->OnInitialize();
37126     } CALL_CATCH_EXCEPTION();
37127   }
37128
37129 }
37130
37131
37132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
37133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37134
37135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37136   {
37137     try {
37138       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
37139     } CALL_CATCH_EXCEPTION();
37140   }
37141
37142 }
37143
37144
37145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
37146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37147   Dali::Toolkit::StyleManager arg2 ;
37148   Dali::StyleChange::Type arg3 ;
37149   Dali::Toolkit::StyleManager *argp2 ;
37150
37151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37152   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37153   if (!argp2) {
37154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37155     return ;
37156   }
37157   arg2 = *argp2;
37158   arg3 = (Dali::StyleChange::Type)jarg3;
37159   {
37160     try {
37161       (arg1)->OnStyleChange(arg2,arg3);
37162     } CALL_CATCH_EXCEPTION();
37163   }
37164
37165 }
37166
37167
37168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37170   Dali::Toolkit::StyleManager arg2 ;
37171   Dali::StyleChange::Type arg3 ;
37172   Dali::Toolkit::StyleManager *argp2 ;
37173
37174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37175   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37176   if (!argp2) {
37177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37178     return ;
37179   }
37180   arg2 = *argp2;
37181   arg3 = (Dali::StyleChange::Type)jarg3;
37182   {
37183     try {
37184       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37185     } CALL_CATCH_EXCEPTION();
37186   }
37187
37188 }
37189
37190
37191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37192   unsigned int jresult ;
37193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37194   bool result;
37195
37196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37197   {
37198     try {
37199       result = (bool)(arg1)->OnAccessibilityActivated();
37200     } CALL_CATCH_EXCEPTION(0);
37201   }
37202
37203   jresult = result;
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
37209   unsigned int jresult ;
37210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37211   bool result;
37212
37213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37214   {
37215     try {
37216       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
37217     } CALL_CATCH_EXCEPTION(0);
37218   }
37219
37220   jresult = result;
37221   return jresult;
37222 }
37223
37224
37225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37226   unsigned int jresult ;
37227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37228   Dali::PanGesture arg2 ;
37229   Dali::PanGesture *argp2 ;
37230   bool result;
37231
37232   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37233   argp2 = (Dali::PanGesture *)jarg2;
37234   if (!argp2) {
37235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37236     return 0;
37237   }
37238   arg2 = *argp2;
37239   {
37240     try {
37241       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37242     } CALL_CATCH_EXCEPTION(0);
37243   }
37244
37245   jresult = result;
37246   return jresult;
37247 }
37248
37249
37250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37251   unsigned int jresult ;
37252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37253   Dali::PanGesture arg2 ;
37254   Dali::PanGesture *argp2 ;
37255   bool result;
37256
37257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37258   argp2 = (Dali::PanGesture *)jarg2;
37259   if (!argp2) {
37260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37261     return 0;
37262   }
37263   arg2 = *argp2;
37264   {
37265     try {
37266       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37267     } CALL_CATCH_EXCEPTION(0);
37268   }
37269
37270   jresult = result;
37271   return jresult;
37272 }
37273
37274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37275   unsigned int jresult ;
37276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37277   bool arg2 ;
37278   bool result;
37279
37280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37281   arg2 = jarg2 ? true : false;
37282   {
37283     try {
37284       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37285     } CALL_CATCH_EXCEPTION(0);
37286   }
37287
37288   jresult = result;
37289   return jresult;
37290 }
37291
37292
37293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37294   unsigned int jresult ;
37295   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37296   bool arg2 ;
37297   bool result;
37298
37299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37300   arg2 = jarg2 ? true : false;
37301   {
37302     try {
37303       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37304     } CALL_CATCH_EXCEPTION(0);
37305   }
37306
37307   jresult = result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37313   unsigned int jresult ;
37314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37315   bool result;
37316
37317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37318   {
37319     try {
37320       result = (bool)(arg1)->OnAccessibilityZoom();
37321     } CALL_CATCH_EXCEPTION(0);
37322   }
37323
37324   jresult = result;
37325   return jresult;
37326 }
37327
37328
37329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
37330   unsigned int jresult ;
37331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37332   bool result;
37333
37334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37335   {
37336     try {
37337       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37338     } CALL_CATCH_EXCEPTION(0);
37339   }
37340
37341   jresult = result;
37342   return jresult;
37343 }
37344
37345
37346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37348
37349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37350   {
37351     try {
37352       (arg1)->OnKeyInputFocusGained();
37353     } CALL_CATCH_EXCEPTION();
37354   }
37355
37356 }
37357
37358
37359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37361
37362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37363   {
37364     try {
37365       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37366     } CALL_CATCH_EXCEPTION();
37367   }
37368
37369 }
37370
37371
37372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37374
37375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37376   {
37377     try {
37378       (arg1)->OnKeyInputFocusLost();
37379     } CALL_CATCH_EXCEPTION();
37380   }
37381
37382 }
37383
37384
37385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37387
37388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37389   {
37390     try {
37391       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37392     } CALL_CATCH_EXCEPTION();
37393   }
37394
37395 }
37396
37397
37398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37399   void * jresult ;
37400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37401   Dali::Actor arg2 ;
37402   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37403   bool arg4 ;
37404   Dali::Actor *argp2 ;
37405   Dali::Actor result;
37406
37407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37408   argp2 = (Dali::Actor *)jarg2;
37409   if (!argp2) {
37410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37411     return 0;
37412   }
37413   arg2 = *argp2;
37414   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37415   arg4 = jarg4 ? true : false;
37416   {
37417     try {
37418       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37419     } CALL_CATCH_EXCEPTION(0);
37420   }
37421
37422   jresult = new Dali::Actor((const Dali::Actor &)result);
37423   return jresult;
37424 }
37425
37426
37427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37428   void * jresult ;
37429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37430   Dali::Actor arg2 ;
37431   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37432   bool arg4 ;
37433   Dali::Actor *argp2 ;
37434   Dali::Actor result;
37435
37436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37437   argp2 = (Dali::Actor *)jarg2;
37438   if (!argp2) {
37439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37440     return 0;
37441   }
37442   arg2 = *argp2;
37443   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37444   arg4 = jarg4 ? true : false;
37445   {
37446     try {
37447       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37448     } CALL_CATCH_EXCEPTION(0);
37449   }
37450
37451   jresult = new Dali::Actor((const Dali::Actor &)result);
37452   return jresult;
37453 }
37454
37455
37456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37458   Dali::Actor arg2 ;
37459   Dali::Actor *argp2 ;
37460
37461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37462   argp2 = (Dali::Actor *)jarg2;
37463   if (!argp2) {
37464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37465     return ;
37466   }
37467   arg2 = *argp2;
37468   {
37469     try {
37470       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37471     } CALL_CATCH_EXCEPTION();
37472   }
37473
37474 }
37475
37476
37477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37479   Dali::Actor arg2 ;
37480   Dali::Actor *argp2 ;
37481
37482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37483   argp2 = (Dali::Actor *)jarg2;
37484   if (!argp2) {
37485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37486     return ;
37487   }
37488   arg2 = *argp2;
37489   {
37490     try {
37491       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37492     } CALL_CATCH_EXCEPTION();
37493   }
37494
37495 }
37496
37497
37498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37499   unsigned int jresult ;
37500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37501   bool result;
37502
37503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37504   {
37505     try {
37506       result = (bool)(arg1)->OnKeyboardEnter();
37507     } CALL_CATCH_EXCEPTION(0);
37508   }
37509
37510   jresult = result;
37511   return jresult;
37512 }
37513
37514
37515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
37516   unsigned int jresult ;
37517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37518   bool result;
37519
37520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37521   {
37522     try {
37523       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37524     } CALL_CATCH_EXCEPTION(0);
37525   }
37526
37527   jresult = result;
37528   return jresult;
37529 }
37530
37531
37532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37534   Dali::PinchGesture *arg2 = 0 ;
37535
37536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37537   arg2 = (Dali::PinchGesture *)jarg2;
37538   if (!arg2) {
37539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37540     return ;
37541   }
37542   {
37543     try {
37544       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37545     } CALL_CATCH_EXCEPTION();
37546   }
37547
37548 }
37549
37550
37551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37553   Dali::PinchGesture *arg2 = 0 ;
37554
37555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37556   arg2 = (Dali::PinchGesture *)jarg2;
37557   if (!arg2) {
37558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37559     return ;
37560   }
37561   {
37562     try {
37563       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37564     } CALL_CATCH_EXCEPTION();
37565   }
37566
37567 }
37568
37569
37570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37572   Dali::PanGesture *arg2 = 0 ;
37573
37574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37575   arg2 = (Dali::PanGesture *)jarg2;
37576   if (!arg2) {
37577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37578     return ;
37579   }
37580   {
37581     try {
37582       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37583     } CALL_CATCH_EXCEPTION();
37584   }
37585
37586 }
37587
37588
37589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37591   Dali::PanGesture *arg2 = 0 ;
37592
37593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37594   arg2 = (Dali::PanGesture *)jarg2;
37595   if (!arg2) {
37596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37597     return ;
37598   }
37599   {
37600     try {
37601       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37602     } CALL_CATCH_EXCEPTION();
37603   }
37604
37605 }
37606
37607
37608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37610   Dali::TapGesture *arg2 = 0 ;
37611
37612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37613   arg2 = (Dali::TapGesture *)jarg2;
37614   if (!arg2) {
37615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37616     return ;
37617   }
37618   {
37619     try {
37620       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37621     } CALL_CATCH_EXCEPTION();
37622   }
37623
37624 }
37625
37626
37627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37629   Dali::TapGesture *arg2 = 0 ;
37630
37631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37632   arg2 = (Dali::TapGesture *)jarg2;
37633   if (!arg2) {
37634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37635     return ;
37636   }
37637   {
37638     try {
37639       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37640     } CALL_CATCH_EXCEPTION();
37641   }
37642
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37648   Dali::LongPressGesture *arg2 = 0 ;
37649
37650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37651   arg2 = (Dali::LongPressGesture *)jarg2;
37652   if (!arg2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37654     return ;
37655   }
37656   {
37657     try {
37658       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37659     } CALL_CATCH_EXCEPTION();
37660   }
37661
37662 }
37663
37664
37665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37667   Dali::LongPressGesture *arg2 = 0 ;
37668
37669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37670   arg2 = (Dali::LongPressGesture *)jarg2;
37671   if (!arg2) {
37672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37673     return ;
37674   }
37675   {
37676     try {
37677       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37678     } CALL_CATCH_EXCEPTION();
37679   }
37680
37681 }
37682
37683
37684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37686   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37687   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37688
37689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37690   arg2 = (Dali::SlotObserver *)jarg2;
37691   arg3 = (Dali::CallbackBase *)jarg3;
37692   {
37693     try {
37694       (arg1)->SignalConnected(arg2,arg3);
37695     } CALL_CATCH_EXCEPTION();
37696   }
37697
37698 }
37699
37700
37701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37703   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37704   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37705
37706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37707   arg2 = (Dali::SlotObserver *)jarg2;
37708   arg3 = (Dali::CallbackBase *)jarg3;
37709   {
37710     try {
37711       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37712     } CALL_CATCH_EXCEPTION();
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
37719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37720   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37721   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37722
37723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37724   arg2 = (Dali::SlotObserver *)jarg2;
37725   arg3 = (Dali::CallbackBase *)jarg3;
37726   {
37727     try {
37728       (arg1)->SignalDisconnected(arg2,arg3);
37729     } CALL_CATCH_EXCEPTION();
37730   }
37731
37732 }
37733
37734
37735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37737   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37738   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37739
37740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37741   arg2 = (Dali::SlotObserver *)jarg2;
37742   arg3 = (Dali::CallbackBase *)jarg3;
37743   {
37744     try {
37745       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37746     } CALL_CATCH_EXCEPTION();
37747   }
37748
37749 }
37750
37751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
37752   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37753   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37754   if (director) {
37755     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
37756   }
37757 }
37758
37759
37760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37761   void * jresult ;
37762   Dali::Toolkit::Control *arg1 = 0 ;
37763   Dali::Toolkit::Internal::Control *result = 0 ;
37764
37765   arg1 = (Dali::Toolkit::Control *)jarg1;
37766   if (!arg1) {
37767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37768     return 0;
37769   }
37770   {
37771     try {
37772       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37773     } CALL_CATCH_EXCEPTION(0);
37774   }
37775
37776   jresult = (void *)result;
37777   return jresult;
37778 }
37779
37780
37781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37782   int jresult ;
37783   int result;
37784
37785   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37786   jresult = (int)result;
37787   return jresult;
37788 }
37789
37790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37791   int jresult ;
37792   int result;
37793
37794   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37795   jresult = (int)result;
37796   return jresult;
37797 }
37798
37799
37800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37801   int jresult ;
37802   int result;
37803
37804   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37805   jresult = (int)result;
37806   return jresult;
37807 }
37808
37809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37810   int jresult ;
37811   int result;
37812
37813   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37814   jresult = (int)result;
37815   return jresult;
37816 }
37817
37818
37819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37820   int jresult ;
37821   int result;
37822
37823   result = (int)Dali::Toolkit::Control::Property::PADDING;
37824   jresult = (int)result;
37825   return jresult;
37826 }
37827
37828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37829   int jresult ;
37830   int result;
37831
37832   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37833   jresult = (int)result;
37834   return jresult;
37835 }
37836
37837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37838   void * jresult ;
37839   Dali::Toolkit::Control::Property *result = 0 ;
37840
37841   {
37842     try {
37843       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37844     } CALL_CATCH_EXCEPTION(0);
37845   }
37846
37847   jresult = (void *)result;
37848   return jresult;
37849 }
37850
37851
37852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37853   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37854
37855   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37856   {
37857     try {
37858       delete arg1;
37859     } CALL_CATCH_EXCEPTION();
37860   }
37861
37862 }
37863
37864
37865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37866   void * jresult ;
37867   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37868
37869   {
37870     try {
37871       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37872     } CALL_CATCH_EXCEPTION(0);
37873   }
37874
37875   jresult = (void *)result;
37876   return jresult;
37877 }
37878
37879
37880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37881   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37882
37883   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37884   {
37885     try {
37886       delete arg1;
37887     } CALL_CATCH_EXCEPTION();
37888   }
37889
37890 }
37891
37892
37893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37894   void * jresult ;
37895   Dali::Toolkit::Control result;
37896
37897   {
37898     try {
37899       result = Dali::Toolkit::Control::New();
37900     } CALL_CATCH_EXCEPTION(0);
37901   }
37902
37903   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37904   return jresult;
37905 }
37906
37907
37908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37909   void * jresult ;
37910   Dali::Toolkit::Control *result = 0 ;
37911
37912   {
37913     try {
37914       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37915     } CALL_CATCH_EXCEPTION(0);
37916   }
37917
37918   jresult = (void *)result;
37919   return jresult;
37920 }
37921
37922
37923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37924   void * jresult ;
37925   Dali::Toolkit::Control *arg1 = 0 ;
37926   Dali::Toolkit::Control *result = 0 ;
37927
37928   arg1 = (Dali::Toolkit::Control *)jarg1;
37929   if (!arg1) {
37930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37931     return 0;
37932   }
37933   {
37934     try {
37935       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37936     } CALL_CATCH_EXCEPTION(0);
37937   }
37938
37939   jresult = (void *)result;
37940   return jresult;
37941 }
37942
37943
37944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
37945   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37946
37947   arg1 = (Dali::Toolkit::Control *)jarg1;
37948   {
37949     try {
37950       delete arg1;
37951     } CALL_CATCH_EXCEPTION();
37952   }
37953
37954 }
37955
37956
37957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
37958   void * jresult ;
37959   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37960   Dali::Toolkit::Control *arg2 = 0 ;
37961   Dali::Toolkit::Control *result = 0 ;
37962
37963   arg1 = (Dali::Toolkit::Control *)jarg1;
37964   arg2 = (Dali::Toolkit::Control *)jarg2;
37965   if (!arg2) {
37966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37967     return 0;
37968   }
37969   {
37970     try {
37971       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
37972     } CALL_CATCH_EXCEPTION(0);
37973   }
37974
37975   jresult = (void *)result;
37976   return jresult;
37977 }
37978
37979
37980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
37981   void * jresult ;
37982   Dali::BaseHandle arg1 ;
37983   Dali::BaseHandle *argp1 ;
37984   Dali::Toolkit::Control result;
37985
37986   argp1 = (Dali::BaseHandle *)jarg1;
37987   if (!argp1) {
37988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37989     return 0;
37990   }
37991   arg1 = *argp1;
37992   {
37993     try {
37994       result = Dali::Toolkit::Control::DownCast(arg1);
37995     } CALL_CATCH_EXCEPTION(0);
37996   }
37997
37998   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
38004   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38005
38006   arg1 = (Dali::Toolkit::Control *)jarg1;
38007   {
38008     try {
38009       (arg1)->SetKeyInputFocus();
38010     } CALL_CATCH_EXCEPTION();
38011   }
38012
38013 }
38014
38015
38016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
38017   unsigned int jresult ;
38018   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38019   bool result;
38020
38021   arg1 = (Dali::Toolkit::Control *)jarg1;
38022   {
38023     try {
38024       result = (bool)(arg1)->HasKeyInputFocus();
38025     } CALL_CATCH_EXCEPTION(0);
38026   }
38027
38028   jresult = result;
38029   return jresult;
38030 }
38031
38032
38033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
38034   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38035
38036   arg1 = (Dali::Toolkit::Control *)jarg1;
38037   {
38038     try {
38039       (arg1)->ClearKeyInputFocus();
38040     } CALL_CATCH_EXCEPTION();
38041   }
38042
38043 }
38044
38045
38046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
38047   void * jresult ;
38048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38049   Dali::PinchGestureDetector result;
38050
38051   arg1 = (Dali::Toolkit::Control *)jarg1;
38052   {
38053     try {
38054       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
38055     } CALL_CATCH_EXCEPTION(0);
38056   }
38057
38058   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38059   return jresult;
38060 }
38061
38062
38063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
38064   void * jresult ;
38065   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38066   Dali::PanGestureDetector result;
38067
38068   arg1 = (Dali::Toolkit::Control *)jarg1;
38069   {
38070     try {
38071       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
38072     } CALL_CATCH_EXCEPTION(0);
38073   }
38074
38075   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38076   return jresult;
38077 }
38078
38079
38080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
38081   void * jresult ;
38082   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38083   Dali::TapGestureDetector result;
38084
38085   arg1 = (Dali::Toolkit::Control *)jarg1;
38086   {
38087     try {
38088       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
38089     } CALL_CATCH_EXCEPTION(0);
38090   }
38091
38092   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38093   return jresult;
38094 }
38095
38096
38097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
38098   void * jresult ;
38099   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38100   Dali::LongPressGestureDetector result;
38101
38102   arg1 = (Dali::Toolkit::Control *)jarg1;
38103   {
38104     try {
38105       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
38106     } CALL_CATCH_EXCEPTION(0);
38107   }
38108
38109   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38110   return jresult;
38111 }
38112
38113
38114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
38115   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38116   std::string *arg2 = 0 ;
38117
38118   arg1 = (Dali::Toolkit::Control *)jarg1;
38119   if (!jarg2) {
38120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38121     return ;
38122   }
38123   std::string arg2_str(jarg2);
38124   arg2 = &arg2_str;
38125   {
38126     try {
38127       (arg1)->SetStyleName((std::string const &)*arg2);
38128     } CALL_CATCH_EXCEPTION();
38129   }
38130
38131
38132   //argout typemap for const std::string&
38133
38134 }
38135
38136
38137 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
38138   char * jresult ;
38139   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38140   std::string *result = 0 ;
38141
38142   arg1 = (Dali::Toolkit::Control *)jarg1;
38143   {
38144     try {
38145       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
38146     } CALL_CATCH_EXCEPTION(0);
38147   }
38148
38149   jresult = SWIG_csharp_string_callback(result->c_str());
38150   return jresult;
38151 }
38152
38153
38154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
38155   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38156   Dali::Vector4 *arg2 = 0 ;
38157
38158   arg1 = (Dali::Toolkit::Control *)jarg1;
38159   arg2 = (Dali::Vector4 *)jarg2;
38160   if (!arg2) {
38161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38162     return ;
38163   }
38164   {
38165     try {
38166       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38167     } CALL_CATCH_EXCEPTION();
38168   }
38169
38170 }
38171
38172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
38173   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38174
38175   arg1 = (Dali::Toolkit::Control *)jarg1;
38176   {
38177     try {
38178       (arg1)->ClearBackground();
38179     } CALL_CATCH_EXCEPTION();
38180   }
38181
38182 }
38183
38184
38185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38186   void * jresult ;
38187   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38188   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38189
38190   arg1 = (Dali::Toolkit::Control *)jarg1;
38191   {
38192     try {
38193       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38194     } CALL_CATCH_EXCEPTION(0);
38195   }
38196
38197   jresult = (void *)result;
38198   return jresult;
38199 }
38200
38201
38202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38203   void * jresult ;
38204   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38205   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38206
38207   arg1 = (Dali::Toolkit::Control *)jarg1;
38208   {
38209     try {
38210       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38211     } CALL_CATCH_EXCEPTION(0);
38212   }
38213
38214   jresult = (void *)result;
38215   return jresult;
38216 }
38217
38218
38219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
38220   void * jresult ;
38221   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38222   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38223
38224   arg1 = (Dali::Toolkit::Control *)jarg1;
38225   {
38226     try {
38227       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38228     } CALL_CATCH_EXCEPTION(0);
38229   }
38230
38231   jresult = (void *)result;
38232   return jresult;
38233 }
38234
38235
38236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38237   void * jresult ;
38238   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38239   Dali::Toolkit::Control *result = 0 ;
38240
38241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38242   if (!arg1) {
38243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38244     return 0;
38245   }
38246   {
38247     try {
38248       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38249     } CALL_CATCH_EXCEPTION(0);
38250   }
38251
38252   jresult = (void *)result;
38253   return jresult;
38254 }
38255
38256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38257 {
38258   int jresult;
38259   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38260   arg1 = (Dali::Toolkit::Control *)jarg1;
38261
38262   if (!arg1) {
38263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38264     return 0;
38265   }
38266
38267   Dali::Property::Index arg2 = 0 ;
38268   arg2 = (Dali::Property::Index)jarg2;
38269
38270   Toolkit::Visual::ResourceStatus result;
38271   {
38272     try {
38273       result = arg1->GetVisualResourceStatus(arg2);
38274     } CALL_CATCH_EXCEPTION(0);
38275   }
38276
38277   jresult = (int)result;
38278   return jresult;
38279 }
38280
38281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38282 {
38283   void * jresult;
38284   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38285   arg1 = (Dali::Toolkit::Control *)jarg1;
38286
38287   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38288
38289   Dali::Toolkit::TransitionData *arg2 = 0 ;
38290   Dali::Animation result;
38291
38292   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38293   if (!arg2) {
38294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38295     return 0;
38296   }
38297   {
38298     try {
38299       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38300     } CALL_CATCH_EXCEPTION(0);
38301   }
38302
38303   jresult = new Dali::Animation((const Dali::Animation &)result);
38304   return jresult;
38305 }
38306
38307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38308 {
38309   Dali::Toolkit::Control arg1;
38310   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38311
38312   if (!argp1) {
38313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38314   }
38315   arg1 = *argp1;
38316
38317   Dali::Property::Index arg2 = 0 ;
38318   arg2 = (Dali::Property::Index)jarg2;
38319
38320   Dali::Property::Index arg3 = 0 ;
38321   arg3 = (Dali::Property::Index)jarg3;
38322
38323   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38324
38325   {
38326     try {
38327       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38328     } CALL_CATCH_EXCEPTION();
38329   }
38330 }
38331
38332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38333   void * jresult ;
38334   Dali::Toolkit::Control *arg1 = 0 ;
38335   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38336
38337   arg1 = (Dali::Toolkit::Control *)jarg1;
38338   if (!arg1) {
38339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38340     return 0;
38341   }
38342   {
38343     try {
38344       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38345     } CALL_CATCH_EXCEPTION(0);
38346   }
38347
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38354   unsigned int jresult ;
38355   Dali::Toolkit::Control *arg1 = 0 ;
38356   bool result;
38357
38358   arg1 = (Dali::Toolkit::Control *)jarg1;
38359   if (!arg1) {
38360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38361     return 0;
38362   }
38363   {
38364     try {
38365       result = (bool)arg1->IsResourceReady();
38366     } CALL_CATCH_EXCEPTION(0);
38367   }
38368
38369   jresult = result;
38370   return jresult;
38371 }
38372
38373
38374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38375   void * jresult ;
38376   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38377
38378   {
38379     try {
38380       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38381     } CALL_CATCH_EXCEPTION(0);
38382   }
38383
38384   jresult = (void *)result;
38385   return jresult;
38386 }
38387
38388
38389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38390   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38391
38392   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38393   {
38394     try {
38395       delete arg1;
38396     } CALL_CATCH_EXCEPTION();
38397   }
38398
38399 }
38400
38401
38402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38403   void * jresult ;
38404   Dali::Toolkit::KeyInputFocusManager result;
38405
38406   {
38407     try {
38408       result = Dali::Toolkit::KeyInputFocusManager::Get();
38409     } CALL_CATCH_EXCEPTION(0);
38410   }
38411
38412   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38413   return jresult;
38414 }
38415
38416
38417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38418   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38419   Dali::Toolkit::Control arg2 ;
38420   Dali::Toolkit::Control *argp2 ;
38421
38422   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38423   argp2 = (Dali::Toolkit::Control *)jarg2;
38424   if (!argp2) {
38425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38426     return ;
38427   }
38428   arg2 = *argp2;
38429   {
38430     try {
38431       (arg1)->SetFocus(arg2);
38432     } CALL_CATCH_EXCEPTION();
38433   }
38434
38435 }
38436
38437
38438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38439   void * jresult ;
38440   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38441   Dali::Toolkit::Control result;
38442
38443   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38444   {
38445     try {
38446       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38447     } CALL_CATCH_EXCEPTION(0);
38448   }
38449
38450   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38451   return jresult;
38452 }
38453
38454
38455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38456   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38457   Dali::Toolkit::Control arg2 ;
38458   Dali::Toolkit::Control *argp2 ;
38459
38460   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38461   argp2 = (Dali::Toolkit::Control *)jarg2;
38462   if (!argp2) {
38463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38464     return ;
38465   }
38466   arg2 = *argp2;
38467   {
38468     try {
38469       (arg1)->RemoveFocus(arg2);
38470     } CALL_CATCH_EXCEPTION();
38471   }
38472
38473 }
38474
38475
38476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38477   void * jresult ;
38478   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38479   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38480
38481   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38482   {
38483     try {
38484       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38485     } CALL_CATCH_EXCEPTION(0);
38486   }
38487
38488   jresult = (void *)result;
38489   return jresult;
38490 }
38491
38492
38493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38494   void * jresult ;
38495   Dali::Toolkit::Alignment::Padding *result = 0 ;
38496
38497   {
38498     try {
38499       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38500     } CALL_CATCH_EXCEPTION(0);
38501   }
38502
38503   jresult = (void *)result;
38504   return jresult;
38505 }
38506
38507
38508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38509   void * jresult ;
38510   float arg1 ;
38511   float arg2 ;
38512   float arg3 ;
38513   float arg4 ;
38514   Dali::Toolkit::Alignment::Padding *result = 0 ;
38515
38516   arg1 = (float)jarg1;
38517   arg2 = (float)jarg2;
38518   arg3 = (float)jarg3;
38519   arg4 = (float)jarg4;
38520   {
38521     try {
38522       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38523     } CALL_CATCH_EXCEPTION(0);
38524   }
38525
38526   jresult = (void *)result;
38527   return jresult;
38528 }
38529
38530
38531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38532   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38533   float arg2 ;
38534
38535   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38536   arg2 = (float)jarg2;
38537   if (arg1) (arg1)->left = arg2;
38538 }
38539
38540
38541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38542   float jresult ;
38543   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38544   float result;
38545
38546   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38547   result = (float) ((arg1)->left);
38548   jresult = result;
38549   return jresult;
38550 }
38551
38552
38553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38554   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38555   float arg2 ;
38556
38557   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38558   arg2 = (float)jarg2;
38559   if (arg1) (arg1)->right = arg2;
38560 }
38561
38562
38563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38564   float jresult ;
38565   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38566   float result;
38567
38568   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38569   result = (float) ((arg1)->right);
38570   jresult = result;
38571   return jresult;
38572 }
38573
38574
38575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38576   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38577   float arg2 ;
38578
38579   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38580   arg2 = (float)jarg2;
38581   if (arg1) (arg1)->top = arg2;
38582 }
38583
38584
38585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38586   float jresult ;
38587   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38588   float result;
38589
38590   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38591   result = (float) ((arg1)->top);
38592   jresult = result;
38593   return jresult;
38594 }
38595
38596
38597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38598   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38599   float arg2 ;
38600
38601   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38602   arg2 = (float)jarg2;
38603   if (arg1) (arg1)->bottom = arg2;
38604 }
38605
38606
38607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38608   float jresult ;
38609   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38610   float result;
38611
38612   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38613   result = (float) ((arg1)->bottom);
38614   jresult = result;
38615   return jresult;
38616 }
38617
38618
38619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38620   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38621
38622   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38623   {
38624     try {
38625       delete arg1;
38626     } CALL_CATCH_EXCEPTION();
38627   }
38628
38629 }
38630
38631
38632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38633   void * jresult ;
38634   Dali::Toolkit::Alignment *result = 0 ;
38635
38636   {
38637     try {
38638       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38639     } CALL_CATCH_EXCEPTION(0);
38640   }
38641
38642   jresult = (void *)result;
38643   return jresult;
38644 }
38645
38646
38647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38648   void * jresult ;
38649   Dali::Toolkit::Alignment::Type arg1 ;
38650   Dali::Toolkit::Alignment::Type arg2 ;
38651   Dali::Toolkit::Alignment result;
38652
38653   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38654   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38655   {
38656     try {
38657       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38658     } CALL_CATCH_EXCEPTION(0);
38659   }
38660
38661   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38662   return jresult;
38663 }
38664
38665
38666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38667   void * jresult ;
38668   Dali::Toolkit::Alignment::Type arg1 ;
38669   Dali::Toolkit::Alignment result;
38670
38671   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38672   {
38673     try {
38674       result = Dali::Toolkit::Alignment::New(arg1);
38675     } CALL_CATCH_EXCEPTION(0);
38676   }
38677
38678   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38679   return jresult;
38680 }
38681
38682
38683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
38684   void * jresult ;
38685   Dali::Toolkit::Alignment result;
38686
38687   {
38688     try {
38689       result = Dali::Toolkit::Alignment::New();
38690     } CALL_CATCH_EXCEPTION(0);
38691   }
38692
38693   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38694   return jresult;
38695 }
38696
38697
38698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38699   void * jresult ;
38700   Dali::Toolkit::Alignment *arg1 = 0 ;
38701   Dali::Toolkit::Alignment *result = 0 ;
38702
38703   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38704   if (!arg1) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38706     return 0;
38707   }
38708   {
38709     try {
38710       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38711     } CALL_CATCH_EXCEPTION(0);
38712   }
38713
38714   jresult = (void *)result;
38715   return jresult;
38716 }
38717
38718
38719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38720   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38721
38722   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38723   {
38724     try {
38725       delete arg1;
38726     } CALL_CATCH_EXCEPTION();
38727   }
38728
38729 }
38730
38731
38732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38733   void * jresult ;
38734   Dali::BaseHandle arg1 ;
38735   Dali::BaseHandle *argp1 ;
38736   Dali::Toolkit::Alignment result;
38737
38738   argp1 = (Dali::BaseHandle *)jarg1;
38739   if (!argp1) {
38740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38741     return 0;
38742   }
38743   arg1 = *argp1;
38744   {
38745     try {
38746       result = Dali::Toolkit::Alignment::DownCast(arg1);
38747     } CALL_CATCH_EXCEPTION(0);
38748   }
38749
38750   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38751   return jresult;
38752 }
38753
38754
38755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38756   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38757   Dali::Toolkit::Alignment::Type arg2 ;
38758
38759   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38760   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38761   {
38762     try {
38763       (arg1)->SetAlignmentType(arg2);
38764     } CALL_CATCH_EXCEPTION();
38765   }
38766
38767 }
38768
38769
38770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38771   int jresult ;
38772   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38773   Dali::Toolkit::Alignment::Type result;
38774
38775   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38776   {
38777     try {
38778       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38779     } CALL_CATCH_EXCEPTION(0);
38780   }
38781
38782   jresult = (int)result;
38783   return jresult;
38784 }
38785
38786
38787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38788   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38789   Dali::Toolkit::Alignment::Scaling arg2 ;
38790
38791   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38792   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38793   {
38794     try {
38795       (arg1)->SetScaling(arg2);
38796     } CALL_CATCH_EXCEPTION();
38797   }
38798
38799 }
38800
38801
38802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38803   int jresult ;
38804   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38805   Dali::Toolkit::Alignment::Scaling result;
38806
38807   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38808   {
38809     try {
38810       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38811     } CALL_CATCH_EXCEPTION(0);
38812   }
38813
38814   jresult = (int)result;
38815   return jresult;
38816 }
38817
38818
38819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38820   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38821   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38822
38823   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38824   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38825   if (!arg2) {
38826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38827     return ;
38828   }
38829   {
38830     try {
38831       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38832     } CALL_CATCH_EXCEPTION();
38833   }
38834
38835 }
38836
38837
38838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38839   void * jresult ;
38840   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38841   Dali::Toolkit::Alignment::Padding *result = 0 ;
38842
38843   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38844   {
38845     try {
38846       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38847     } CALL_CATCH_EXCEPTION(0);
38848   }
38849
38850   jresult = (void *)result;
38851   return jresult;
38852 }
38853
38854
38855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38856   void * jresult ;
38857   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38858   Dali::Toolkit::Alignment *arg2 = 0 ;
38859   Dali::Toolkit::Alignment *result = 0 ;
38860
38861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38862   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38863   if (!arg2) {
38864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38865     return 0;
38866   }
38867   {
38868     try {
38869       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38870     } CALL_CATCH_EXCEPTION(0);
38871   }
38872
38873   jresult = (void *)result;
38874   return jresult;
38875 }
38876
38877
38878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38879   int jresult ;
38880   int result;
38881
38882   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38883   jresult = (int)result;
38884   return jresult;
38885 }
38886
38887
38888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38889   int jresult ;
38890   int result;
38891
38892   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38893   jresult = (int)result;
38894   return jresult;
38895 }
38896
38897
38898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38899   int jresult ;
38900   int result;
38901
38902   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38903   jresult = (int)result;
38904   return jresult;
38905 }
38906
38907
38908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38909   int jresult ;
38910   int result;
38911
38912   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38913   jresult = (int)result;
38914   return jresult;
38915 }
38916
38917
38918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38919   int jresult ;
38920   int result;
38921
38922   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38923   jresult = (int)result;
38924   return jresult;
38925 }
38926
38927
38928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38929   int jresult ;
38930   int result;
38931
38932   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38933   jresult = (int)result;
38934   return jresult;
38935 }
38936
38937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38938   int jresult ;
38939   int result;
38940
38941   result = (int)Dali::Toolkit::Button::Property::LABEL;
38942   jresult = (int)result;
38943   return jresult;
38944 }
38945
38946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
38947   void * jresult ;
38948   Dali::Toolkit::Button::Property *result = 0 ;
38949
38950   {
38951     try {
38952       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
38953     } CALL_CATCH_EXCEPTION(0);
38954   }
38955
38956   jresult = (void *)result;
38957   return jresult;
38958 }
38959
38960
38961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
38962   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
38963
38964   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
38965   {
38966     try {
38967       delete arg1;
38968     } CALL_CATCH_EXCEPTION();
38969   }
38970
38971 }
38972
38973
38974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
38975   void * jresult ;
38976   Dali::Toolkit::Button *result = 0 ;
38977
38978   {
38979     try {
38980       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
38981     } CALL_CATCH_EXCEPTION(0);
38982   }
38983
38984   jresult = (void *)result;
38985   return jresult;
38986 }
38987
38988
38989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
38990   void * jresult ;
38991   Dali::Toolkit::Button *arg1 = 0 ;
38992   Dali::Toolkit::Button *result = 0 ;
38993
38994   arg1 = (Dali::Toolkit::Button *)jarg1;
38995   if (!arg1) {
38996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38997     return 0;
38998   }
38999   {
39000     try {
39001       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
39002     } CALL_CATCH_EXCEPTION(0);
39003   }
39004
39005   jresult = (void *)result;
39006   return jresult;
39007 }
39008
39009
39010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
39011   void * jresult ;
39012   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39013   Dali::Toolkit::Button *arg2 = 0 ;
39014   Dali::Toolkit::Button *result = 0 ;
39015
39016   arg1 = (Dali::Toolkit::Button *)jarg1;
39017   arg2 = (Dali::Toolkit::Button *)jarg2;
39018   if (!arg2) {
39019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39020     return 0;
39021   }
39022   {
39023     try {
39024       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
39025     } CALL_CATCH_EXCEPTION(0);
39026   }
39027
39028   jresult = (void *)result;
39029   return jresult;
39030 }
39031
39032
39033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
39034   void * jresult ;
39035   Dali::BaseHandle arg1 ;
39036   Dali::BaseHandle *argp1 ;
39037   Dali::Toolkit::Button result;
39038
39039   argp1 = (Dali::BaseHandle *)jarg1;
39040   if (!argp1) {
39041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39042     return 0;
39043   }
39044   arg1 = *argp1;
39045   {
39046     try {
39047       result = Dali::Toolkit::Button::DownCast(arg1);
39048     } CALL_CATCH_EXCEPTION(0);
39049   }
39050
39051   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
39052   return jresult;
39053 }
39054
39055
39056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
39057   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39058
39059   arg1 = (Dali::Toolkit::Button *)jarg1;
39060   {
39061     try {
39062       delete arg1;
39063     } CALL_CATCH_EXCEPTION();
39064   }
39065
39066 }
39067
39068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
39069   void * jresult ;
39070   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39071   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39072
39073   arg1 = (Dali::Toolkit::Button *)jarg1;
39074   {
39075     try {
39076       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
39077     } CALL_CATCH_EXCEPTION(0);
39078   }
39079
39080   jresult = (void *)result;
39081   return jresult;
39082 }
39083
39084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
39085   void * jresult ;
39086   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39087   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39088
39089   arg1 = (Dali::Toolkit::Button *)jarg1;
39090   {
39091     try {
39092       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
39093     } CALL_CATCH_EXCEPTION(0);
39094   }
39095
39096   jresult = (void *)result;
39097   return jresult;
39098 }
39099
39100
39101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
39102   void * jresult ;
39103   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39104   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39105
39106   arg1 = (Dali::Toolkit::Button *)jarg1;
39107   {
39108     try {
39109       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
39110     } CALL_CATCH_EXCEPTION(0);
39111   }
39112
39113   jresult = (void *)result;
39114   return jresult;
39115 }
39116
39117
39118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
39119   void * jresult ;
39120   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39121   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39122
39123   arg1 = (Dali::Toolkit::Button *)jarg1;
39124   {
39125     try {
39126       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
39127     } CALL_CATCH_EXCEPTION(0);
39128   }
39129
39130   jresult = (void *)result;
39131   return jresult;
39132 }
39133
39134
39135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
39136   void * jresult ;
39137   Dali::Toolkit::CheckBoxButton *result = 0 ;
39138
39139   {
39140     try {
39141       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
39142     } CALL_CATCH_EXCEPTION(0);
39143   }
39144
39145   jresult = (void *)result;
39146   return jresult;
39147 }
39148
39149
39150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
39151   void * jresult ;
39152   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
39153   Dali::Toolkit::CheckBoxButton *result = 0 ;
39154
39155   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39156   if (!arg1) {
39157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39158     return 0;
39159   }
39160   {
39161     try {
39162       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
39163     } CALL_CATCH_EXCEPTION(0);
39164   }
39165
39166   jresult = (void *)result;
39167   return jresult;
39168 }
39169
39170
39171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
39172   void * jresult ;
39173   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39174   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
39175   Dali::Toolkit::CheckBoxButton *result = 0 ;
39176
39177   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39178   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
39179   if (!arg2) {
39180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39181     return 0;
39182   }
39183   {
39184     try {
39185       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39186     } CALL_CATCH_EXCEPTION(0);
39187   }
39188
39189   jresult = (void *)result;
39190   return jresult;
39191 }
39192
39193
39194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
39195   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39196
39197   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39198   {
39199     try {
39200       delete arg1;
39201     } CALL_CATCH_EXCEPTION();
39202   }
39203
39204 }
39205
39206
39207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
39208   void * jresult ;
39209   Dali::Toolkit::CheckBoxButton result;
39210
39211   {
39212     try {
39213       result = Dali::Toolkit::CheckBoxButton::New();
39214     } CALL_CATCH_EXCEPTION(0);
39215   }
39216
39217   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39218   return jresult;
39219 }
39220
39221
39222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39223   void * jresult ;
39224   Dali::BaseHandle arg1 ;
39225   Dali::BaseHandle *argp1 ;
39226   Dali::Toolkit::CheckBoxButton result;
39227
39228   argp1 = (Dali::BaseHandle *)jarg1;
39229   if (!argp1) {
39230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39231     return 0;
39232   }
39233   arg1 = *argp1;
39234   {
39235     try {
39236       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39237     } CALL_CATCH_EXCEPTION(0);
39238   }
39239
39240   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39241   return jresult;
39242 }
39243
39244
39245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39246   int jresult ;
39247   int result;
39248
39249   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39250   jresult = (int)result;
39251   return jresult;
39252 }
39253
39254
39255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39256   int jresult ;
39257   int result;
39258
39259   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39260   jresult = (int)result;
39261   return jresult;
39262 }
39263
39264
39265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39266   void * jresult ;
39267   Dali::Toolkit::PushButton::Property *result = 0 ;
39268
39269   {
39270     try {
39271       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39272     } CALL_CATCH_EXCEPTION(0);
39273   }
39274
39275   jresult = (void *)result;
39276   return jresult;
39277 }
39278
39279
39280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39281   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39282
39283   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39284   {
39285     try {
39286       delete arg1;
39287     } CALL_CATCH_EXCEPTION();
39288   }
39289
39290 }
39291
39292
39293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39294   void * jresult ;
39295   Dali::Toolkit::PushButton *result = 0 ;
39296
39297   {
39298     try {
39299       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39300     } CALL_CATCH_EXCEPTION(0);
39301   }
39302
39303   jresult = (void *)result;
39304   return jresult;
39305 }
39306
39307
39308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39309   void * jresult ;
39310   Dali::Toolkit::PushButton *arg1 = 0 ;
39311   Dali::Toolkit::PushButton *result = 0 ;
39312
39313   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39314   if (!arg1) {
39315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39316     return 0;
39317   }
39318   {
39319     try {
39320       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39321     } CALL_CATCH_EXCEPTION(0);
39322   }
39323
39324   jresult = (void *)result;
39325   return jresult;
39326 }
39327
39328
39329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39330   void * jresult ;
39331   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39332   Dali::Toolkit::PushButton *arg2 = 0 ;
39333   Dali::Toolkit::PushButton *result = 0 ;
39334
39335   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39336   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39337   if (!arg2) {
39338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39339     return 0;
39340   }
39341   {
39342     try {
39343       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39344     } CALL_CATCH_EXCEPTION(0);
39345   }
39346
39347   jresult = (void *)result;
39348   return jresult;
39349 }
39350
39351
39352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39353   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39354
39355   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39356   {
39357     try {
39358       delete arg1;
39359     } CALL_CATCH_EXCEPTION();
39360   }
39361
39362 }
39363
39364
39365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39366   void * jresult ;
39367   Dali::Toolkit::PushButton result;
39368
39369   {
39370     try {
39371       result = Dali::Toolkit::PushButton::New();
39372     } CALL_CATCH_EXCEPTION(0);
39373   }
39374
39375   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39376   return jresult;
39377 }
39378
39379
39380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39381   void * jresult ;
39382   Dali::BaseHandle arg1 ;
39383   Dali::BaseHandle *argp1 ;
39384   Dali::Toolkit::PushButton result;
39385
39386   argp1 = (Dali::BaseHandle *)jarg1;
39387   if (!argp1) {
39388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39389     return 0;
39390   }
39391   arg1 = *argp1;
39392   {
39393     try {
39394       result = Dali::Toolkit::PushButton::DownCast(arg1);
39395     } CALL_CATCH_EXCEPTION(0);
39396   }
39397
39398   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39399   return jresult;
39400 }
39401
39402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39403   void * jresult ;
39404   Dali::Toolkit::RadioButton *result = 0 ;
39405
39406   {
39407     try {
39408       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39409     } CALL_CATCH_EXCEPTION(0);
39410   }
39411
39412   jresult = (void *)result;
39413   return jresult;
39414 }
39415
39416
39417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39418   void * jresult ;
39419   Dali::Toolkit::RadioButton *arg1 = 0 ;
39420   Dali::Toolkit::RadioButton *result = 0 ;
39421
39422   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39423   if (!arg1) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39425     return 0;
39426   }
39427   {
39428     try {
39429       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39430     } CALL_CATCH_EXCEPTION(0);
39431   }
39432
39433   jresult = (void *)result;
39434   return jresult;
39435 }
39436
39437
39438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39439   void * jresult ;
39440   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39441   Dali::Toolkit::RadioButton *arg2 = 0 ;
39442   Dali::Toolkit::RadioButton *result = 0 ;
39443
39444   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39445   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39446   if (!arg2) {
39447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39448     return 0;
39449   }
39450   {
39451     try {
39452       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39453     } CALL_CATCH_EXCEPTION(0);
39454   }
39455
39456   jresult = (void *)result;
39457   return jresult;
39458 }
39459
39460
39461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39462   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39463
39464   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39465   {
39466     try {
39467       delete arg1;
39468     } CALL_CATCH_EXCEPTION();
39469   }
39470
39471 }
39472
39473
39474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39475   void * jresult ;
39476   Dali::Toolkit::RadioButton result;
39477
39478   {
39479     try {
39480       result = Dali::Toolkit::RadioButton::New();
39481     } CALL_CATCH_EXCEPTION(0);
39482   }
39483
39484   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39485   return jresult;
39486 }
39487
39488
39489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39490   void * jresult ;
39491   std::string *arg1 = 0 ;
39492   Dali::Toolkit::RadioButton result;
39493
39494   if (!jarg1) {
39495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39496     return 0;
39497   }
39498   std::string arg1_str(jarg1);
39499   arg1 = &arg1_str;
39500   {
39501     try {
39502       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39503     } CALL_CATCH_EXCEPTION(0);
39504   }
39505
39506   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39507
39508   //argout typemap for const std::string&
39509
39510   return jresult;
39511 }
39512
39513
39514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39515   void * jresult ;
39516   Dali::BaseHandle arg1 ;
39517   Dali::BaseHandle *argp1 ;
39518   Dali::Toolkit::RadioButton result;
39519
39520   argp1 = (Dali::BaseHandle *)jarg1;
39521   if (!argp1) {
39522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39523     return 0;
39524   }
39525   arg1 = *argp1;
39526   {
39527     try {
39528       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39529     } CALL_CATCH_EXCEPTION(0);
39530   }
39531
39532   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39533   return jresult;
39534 }
39535
39536
39537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39538   int jresult ;
39539   int result;
39540
39541   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39542   jresult = (int)result;
39543   return jresult;
39544 }
39545
39546
39547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39548   int jresult ;
39549   int result;
39550
39551   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39552   jresult = (int)result;
39553   return jresult;
39554 }
39555
39556
39557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39558   int jresult ;
39559   int result;
39560
39561   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39562   jresult = (int)result;
39563   return jresult;
39564 }
39565
39566
39567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39568   int jresult ;
39569   int result;
39570
39571   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39572   jresult = (int)result;
39573   return jresult;
39574 }
39575
39576
39577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39578   int jresult ;
39579   int result;
39580
39581   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39582   jresult = (int)result;
39583   return jresult;
39584 }
39585
39586
39587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39588   int jresult ;
39589   int result;
39590
39591   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39592   jresult = (int)result;
39593   return jresult;
39594 }
39595
39596
39597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39598   void * jresult ;
39599   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39600
39601   {
39602     try {
39603       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39604     } CALL_CATCH_EXCEPTION(0);
39605   }
39606
39607   jresult = (void *)result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39613   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39614
39615   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39616   {
39617     try {
39618       delete arg1;
39619     } CALL_CATCH_EXCEPTION();
39620   }
39621
39622 }
39623
39624
39625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39626   int jresult ;
39627   int result;
39628
39629   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39630   jresult = (int)result;
39631   return jresult;
39632 }
39633
39634
39635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39636   int jresult ;
39637   int result;
39638
39639   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39640   jresult = (int)result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39646   int jresult ;
39647   int result;
39648
39649   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39650   jresult = (int)result;
39651   return jresult;
39652 }
39653
39654
39655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39656   void * jresult ;
39657   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39658
39659   {
39660     try {
39661       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39662     } CALL_CATCH_EXCEPTION(0);
39663   }
39664
39665   jresult = (void *)result;
39666   return jresult;
39667 }
39668
39669
39670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39671   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39672
39673   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39674   {
39675     try {
39676       delete arg1;
39677     } CALL_CATCH_EXCEPTION();
39678   }
39679
39680 }
39681
39682
39683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39684   void * jresult ;
39685   Dali::Toolkit::FlexContainer *result = 0 ;
39686
39687   {
39688     try {
39689       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39690     } CALL_CATCH_EXCEPTION(0);
39691   }
39692
39693   jresult = (void *)result;
39694   return jresult;
39695 }
39696
39697
39698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39699   void * jresult ;
39700   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39701   Dali::Toolkit::FlexContainer *result = 0 ;
39702
39703   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39704   if (!arg1) {
39705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39706     return 0;
39707   }
39708   {
39709     try {
39710       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39711     } CALL_CATCH_EXCEPTION(0);
39712   }
39713
39714   jresult = (void *)result;
39715   return jresult;
39716 }
39717
39718
39719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39720   void * jresult ;
39721   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39722   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39723   Dali::Toolkit::FlexContainer *result = 0 ;
39724
39725   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39726   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39727   if (!arg2) {
39728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39729     return 0;
39730   }
39731   {
39732     try {
39733       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39734     } CALL_CATCH_EXCEPTION(0);
39735   }
39736
39737   jresult = (void *)result;
39738   return jresult;
39739 }
39740
39741
39742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39743   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39744
39745   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39746   {
39747     try {
39748       delete arg1;
39749     } CALL_CATCH_EXCEPTION();
39750   }
39751
39752 }
39753
39754
39755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39756   void * jresult ;
39757   Dali::Toolkit::FlexContainer result;
39758
39759   {
39760     try {
39761       result = Dali::Toolkit::FlexContainer::New();
39762     } CALL_CATCH_EXCEPTION(0);
39763   }
39764
39765   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39766   return jresult;
39767 }
39768
39769
39770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39771   void * jresult ;
39772   Dali::BaseHandle arg1 ;
39773   Dali::BaseHandle *argp1 ;
39774   Dali::Toolkit::FlexContainer result;
39775
39776   argp1 = (Dali::BaseHandle *)jarg1;
39777   if (!argp1) {
39778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39779     return 0;
39780   }
39781   arg1 = *argp1;
39782   {
39783     try {
39784       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39785     } CALL_CATCH_EXCEPTION(0);
39786   }
39787
39788   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39789   return jresult;
39790 }
39791
39792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39793   int jresult ;
39794   int result;
39795
39796   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39797   jresult = (int)result;
39798   return jresult;
39799 }
39800
39801
39802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39803   int jresult ;
39804   int result;
39805
39806   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39807   jresult = (int)result;
39808   return jresult;
39809 }
39810
39811
39812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39813   int jresult ;
39814   int result;
39815
39816   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39817   jresult = (int)result;
39818   return jresult;
39819 }
39820
39821
39822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39823   void * jresult ;
39824   Dali::Toolkit::ImageView::Property *result = 0 ;
39825
39826   {
39827     try {
39828       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39829     } CALL_CATCH_EXCEPTION(0);
39830   }
39831
39832   jresult = (void *)result;
39833   return jresult;
39834 }
39835
39836
39837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39838   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39839
39840   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39841   {
39842     try {
39843       delete arg1;
39844     } CALL_CATCH_EXCEPTION();
39845   }
39846
39847 }
39848
39849
39850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39851   void * jresult ;
39852   Dali::Toolkit::ImageView *result = 0 ;
39853
39854   {
39855     try {
39856       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39857     } CALL_CATCH_EXCEPTION(0);
39858   }
39859
39860   jresult = (void *)result;
39861   return jresult;
39862 }
39863
39864
39865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39866   void * jresult ;
39867   Dali::Toolkit::ImageView result;
39868
39869   {
39870     try {
39871       result = Dali::Toolkit::ImageView::New();
39872     } CALL_CATCH_EXCEPTION(0);
39873   }
39874
39875   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39876   return jresult;
39877 }
39878
39879
39880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39881   void * jresult ;
39882   std::string *arg1 = 0 ;
39883   Dali::Toolkit::ImageView result;
39884
39885   if (!jarg1) {
39886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39887     return 0;
39888   }
39889   std::string arg1_str(jarg1);
39890   arg1 = &arg1_str;
39891   {
39892     try {
39893       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39894     } CALL_CATCH_EXCEPTION(0);
39895   }
39896
39897   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39898
39899   //argout typemap for const std::string&
39900
39901   return jresult;
39902 }
39903
39904
39905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39906   void * jresult ;
39907   std::string *arg1 = 0 ;
39908   Dali::ImageDimensions arg2 ;
39909   Dali::ImageDimensions *argp2 ;
39910   Dali::Toolkit::ImageView result;
39911
39912   if (!jarg1) {
39913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39914     return 0;
39915   }
39916   std::string arg1_str(jarg1);
39917   arg1 = &arg1_str;
39918   argp2 = (Dali::ImageDimensions *)jarg2;
39919   if (!argp2) {
39920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39921     return 0;
39922   }
39923   arg2 = *argp2;
39924   {
39925     try {
39926       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39927     } CALL_CATCH_EXCEPTION(0);
39928   }
39929
39930   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39931
39932   //argout typemap for const std::string&
39933
39934   return jresult;
39935 }
39936
39937
39938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39939   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39940
39941   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39942   {
39943     try {
39944       delete arg1;
39945     } CALL_CATCH_EXCEPTION();
39946   }
39947
39948 }
39949
39950
39951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
39952   void * jresult ;
39953   Dali::Toolkit::ImageView *arg1 = 0 ;
39954   Dali::Toolkit::ImageView *result = 0 ;
39955
39956   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39957   if (!arg1) {
39958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39959     return 0;
39960   }
39961   {
39962     try {
39963       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
39964     } CALL_CATCH_EXCEPTION(0);
39965   }
39966
39967   jresult = (void *)result;
39968   return jresult;
39969 }
39970
39971
39972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
39973   void * jresult ;
39974   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39975   Dali::Toolkit::ImageView *arg2 = 0 ;
39976   Dali::Toolkit::ImageView *result = 0 ;
39977
39978   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39979   arg2 = (Dali::Toolkit::ImageView *)jarg2;
39980   if (!arg2) {
39981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39982     return 0;
39983   }
39984   {
39985     try {
39986       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
39987     } CALL_CATCH_EXCEPTION(0);
39988   }
39989
39990   jresult = (void *)result;
39991   return jresult;
39992 }
39993
39994
39995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
39996   void * jresult ;
39997   Dali::BaseHandle arg1 ;
39998   Dali::BaseHandle *argp1 ;
39999   Dali::Toolkit::ImageView result;
40000
40001   argp1 = (Dali::BaseHandle *)jarg1;
40002   if (!argp1) {
40003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40004     return 0;
40005   }
40006   arg1 = *argp1;
40007   {
40008     try {
40009       result = Dali::Toolkit::ImageView::DownCast(arg1);
40010     } CALL_CATCH_EXCEPTION(0);
40011   }
40012
40013   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
40019   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40020   std::string *arg2 = 0 ;
40021
40022   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40023   if (!jarg2) {
40024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40025     return ;
40026   }
40027   std::string arg2_str(jarg2);
40028   arg2 = &arg2_str;
40029   {
40030     try {
40031       (arg1)->SetImage((std::string const &)*arg2);
40032     } CALL_CATCH_EXCEPTION();
40033   }
40034
40035
40036   //argout typemap for const std::string&
40037
40038 }
40039
40040
40041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
40042   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40043   std::string *arg2 = 0 ;
40044   Dali::ImageDimensions arg3 ;
40045   Dali::ImageDimensions *argp3 ;
40046
40047   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40048   if (!jarg2) {
40049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40050     return ;
40051   }
40052   std::string arg2_str(jarg2);
40053   arg2 = &arg2_str;
40054   argp3 = (Dali::ImageDimensions *)jarg3;
40055   if (!argp3) {
40056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40057     return ;
40058   }
40059   arg3 = *argp3;
40060   {
40061     try {
40062       (arg1)->SetImage((std::string const &)*arg2,arg3);
40063     } CALL_CATCH_EXCEPTION();
40064   }
40065
40066
40067   //argout typemap for const std::string&
40068
40069 }
40070
40071
40072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
40073   int jresult ;
40074   int result;
40075
40076   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
40077   jresult = (int)result;
40078   return jresult;
40079 }
40080
40081
40082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
40083   int jresult ;
40084   int result;
40085
40086   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
40087   jresult = (int)result;
40088   return jresult;
40089 }
40090
40091
40092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
40093   int jresult ;
40094   int result;
40095
40096   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
40097   jresult = (int)result;
40098   return jresult;
40099 }
40100
40101
40102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
40103   int jresult ;
40104   int result;
40105
40106   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
40107   jresult = (int)result;
40108   return jresult;
40109 }
40110
40111
40112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
40113   int jresult ;
40114   int result;
40115
40116   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
40117   jresult = (int)result;
40118   return jresult;
40119 }
40120
40121
40122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
40123   int jresult ;
40124   int result;
40125
40126   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
40127   jresult = (int)result;
40128   return jresult;
40129 }
40130
40131
40132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
40133   int jresult ;
40134   int result;
40135
40136   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
40137   jresult = (int)result;
40138   return jresult;
40139 }
40140
40141
40142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
40143   int jresult ;
40144   int result;
40145
40146   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
40147   jresult = (int)result;
40148   return jresult;
40149 }
40150
40151
40152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
40153   void * jresult ;
40154   Dali::Toolkit::Model3dView::Property *result = 0 ;
40155
40156   {
40157     try {
40158       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
40159     } CALL_CATCH_EXCEPTION(0);
40160   }
40161
40162   jresult = (void *)result;
40163   return jresult;
40164 }
40165
40166
40167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
40168   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
40169
40170   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
40171   {
40172     try {
40173       delete arg1;
40174     } CALL_CATCH_EXCEPTION();
40175   }
40176
40177 }
40178
40179
40180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
40181   void * jresult ;
40182   Dali::Toolkit::Model3dView result;
40183
40184   {
40185     try {
40186       result = Dali::Toolkit::Model3dView::New();
40187     } CALL_CATCH_EXCEPTION(0);
40188   }
40189
40190   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40191   return jresult;
40192 }
40193
40194
40195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
40196   void * jresult ;
40197   std::string *arg1 = 0 ;
40198   std::string *arg2 = 0 ;
40199   std::string *arg3 = 0 ;
40200   Dali::Toolkit::Model3dView result;
40201
40202   if (!jarg1) {
40203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40204     return 0;
40205   }
40206   std::string arg1_str(jarg1);
40207   arg1 = &arg1_str;
40208   if (!jarg2) {
40209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40210     return 0;
40211   }
40212   std::string arg2_str(jarg2);
40213   arg2 = &arg2_str;
40214   if (!jarg3) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40216     return 0;
40217   }
40218   std::string arg3_str(jarg3);
40219   arg3 = &arg3_str;
40220   {
40221     try {
40222       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40223     } CALL_CATCH_EXCEPTION(0);
40224   }
40225
40226   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40227
40228   //argout typemap for const std::string&
40229
40230
40231   //argout typemap for const std::string&
40232
40233
40234   //argout typemap for const std::string&
40235
40236   return jresult;
40237 }
40238
40239
40240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40241   void * jresult ;
40242   Dali::Toolkit::Model3dView *result = 0 ;
40243
40244   {
40245     try {
40246       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40247     } CALL_CATCH_EXCEPTION(0);
40248   }
40249
40250   jresult = (void *)result;
40251   return jresult;
40252 }
40253
40254
40255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40256   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40257
40258   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40259   {
40260     try {
40261       delete arg1;
40262     } CALL_CATCH_EXCEPTION();
40263   }
40264
40265 }
40266
40267
40268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40269   void * jresult ;
40270   Dali::Toolkit::Model3dView *arg1 = 0 ;
40271   Dali::Toolkit::Model3dView *result = 0 ;
40272
40273   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40274   if (!arg1) {
40275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40276     return 0;
40277   }
40278   {
40279     try {
40280       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40281     } CALL_CATCH_EXCEPTION(0);
40282   }
40283
40284   jresult = (void *)result;
40285   return jresult;
40286 }
40287
40288
40289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40290   void * jresult ;
40291   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40292   Dali::Toolkit::Model3dView *arg2 = 0 ;
40293   Dali::Toolkit::Model3dView *result = 0 ;
40294
40295   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40296   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40297   if (!arg2) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40299     return 0;
40300   }
40301   {
40302     try {
40303       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40304     } CALL_CATCH_EXCEPTION(0);
40305   }
40306
40307   jresult = (void *)result;
40308   return jresult;
40309 }
40310
40311
40312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40313   void * jresult ;
40314   Dali::BaseHandle arg1 ;
40315   Dali::BaseHandle *argp1 ;
40316   Dali::Toolkit::Model3dView result;
40317
40318   argp1 = (Dali::BaseHandle *)jarg1;
40319   if (!argp1) {
40320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40321     return 0;
40322   }
40323   arg1 = *argp1;
40324   {
40325     try {
40326       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40327     } CALL_CATCH_EXCEPTION(0);
40328   }
40329
40330   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40336   int jresult ;
40337   int result;
40338
40339   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40340   jresult = (int)result;
40341   return jresult;
40342 }
40343
40344
40345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40346   int jresult ;
40347   int result;
40348
40349   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40350   jresult = (int)result;
40351   return jresult;
40352 }
40353
40354
40355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40356   int jresult ;
40357   int result;
40358
40359   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40360   jresult = (int)result;
40361   return jresult;
40362 }
40363
40364
40365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40366   int jresult ;
40367   int result;
40368
40369   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40370   jresult = (int)result;
40371   return jresult;
40372 }
40373
40374
40375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40376   int jresult ;
40377   int result;
40378
40379   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40380   jresult = (int)result;
40381   return jresult;
40382 }
40383
40384
40385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40386   int jresult ;
40387   int result;
40388
40389   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40390   jresult = (int)result;
40391   return jresult;
40392 }
40393
40394
40395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40396   int jresult ;
40397   int result;
40398
40399   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40400   jresult = (int)result;
40401   return jresult;
40402 }
40403
40404
40405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40406   int jresult ;
40407   int result;
40408
40409   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40410   jresult = (int)result;
40411   return jresult;
40412 }
40413
40414
40415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40416   int jresult ;
40417   int result;
40418
40419   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40420   jresult = (int)result;
40421   return jresult;
40422 }
40423
40424
40425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40426   void * jresult ;
40427   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40428
40429   {
40430     try {
40431       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40432     } CALL_CATCH_EXCEPTION(0);
40433   }
40434
40435   jresult = (void *)result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40441   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40442
40443   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40444   {
40445     try {
40446       delete arg1;
40447     } CALL_CATCH_EXCEPTION();
40448   }
40449
40450 }
40451
40452
40453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40454   void * jresult ;
40455   Dali::Toolkit::ScrollBar *result = 0 ;
40456
40457   {
40458     try {
40459       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40460     } CALL_CATCH_EXCEPTION(0);
40461   }
40462
40463   jresult = (void *)result;
40464   return jresult;
40465 }
40466
40467
40468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40469   void * jresult ;
40470   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40471   Dali::Toolkit::ScrollBar *result = 0 ;
40472
40473   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40474   if (!arg1) {
40475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40476     return 0;
40477   }
40478   {
40479     try {
40480       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40481     } CALL_CATCH_EXCEPTION(0);
40482   }
40483
40484   jresult = (void *)result;
40485   return jresult;
40486 }
40487
40488
40489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40490   void * jresult ;
40491   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40492   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40493   Dali::Toolkit::ScrollBar *result = 0 ;
40494
40495   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40496   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40497   if (!arg2) {
40498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40499     return 0;
40500   }
40501   {
40502     try {
40503       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40504     } CALL_CATCH_EXCEPTION(0);
40505   }
40506
40507   jresult = (void *)result;
40508   return jresult;
40509 }
40510
40511
40512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40513   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40514
40515   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40516   {
40517     try {
40518       delete arg1;
40519     } CALL_CATCH_EXCEPTION();
40520   }
40521
40522 }
40523
40524
40525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40526   void * jresult ;
40527   Dali::Toolkit::ScrollBar::Direction arg1 ;
40528   Dali::Toolkit::ScrollBar result;
40529
40530   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40531   {
40532     try {
40533       result = Dali::Toolkit::ScrollBar::New(arg1);
40534     } CALL_CATCH_EXCEPTION(0);
40535   }
40536
40537   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40538   return jresult;
40539 }
40540
40541
40542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40543   void * jresult ;
40544   Dali::Toolkit::ScrollBar result;
40545
40546   {
40547     try {
40548       result = Dali::Toolkit::ScrollBar::New();
40549     } CALL_CATCH_EXCEPTION(0);
40550   }
40551
40552   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40553   return jresult;
40554 }
40555
40556
40557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40558   void * jresult ;
40559   Dali::BaseHandle arg1 ;
40560   Dali::BaseHandle *argp1 ;
40561   Dali::Toolkit::ScrollBar result;
40562
40563   argp1 = (Dali::BaseHandle *)jarg1;
40564   if (!argp1) {
40565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40566     return 0;
40567   }
40568   arg1 = *argp1;
40569   {
40570     try {
40571       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40572     } CALL_CATCH_EXCEPTION(0);
40573   }
40574
40575   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40576   return jresult;
40577 }
40578
40579
40580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40581   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40582   Dali::Handle arg2 ;
40583   Dali::Property::Index arg3 ;
40584   Dali::Property::Index arg4 ;
40585   Dali::Property::Index arg5 ;
40586   Dali::Property::Index arg6 ;
40587   Dali::Handle *argp2 ;
40588
40589   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40590   argp2 = (Dali::Handle *)jarg2;
40591   if (!argp2) {
40592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40593     return ;
40594   }
40595   arg2 = *argp2;
40596   arg3 = (Dali::Property::Index)jarg3;
40597   arg4 = (Dali::Property::Index)jarg4;
40598   arg5 = (Dali::Property::Index)jarg5;
40599   arg6 = (Dali::Property::Index)jarg6;
40600   {
40601     try {
40602       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40603     } CALL_CATCH_EXCEPTION();
40604   }
40605
40606 }
40607
40608
40609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40610   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40611   Dali::Actor arg2 ;
40612   Dali::Actor *argp2 ;
40613
40614   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40615   argp2 = (Dali::Actor *)jarg2;
40616   if (!argp2) {
40617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40618     return ;
40619   }
40620   arg2 = *argp2;
40621   {
40622     try {
40623       (arg1)->SetScrollIndicator(arg2);
40624     } CALL_CATCH_EXCEPTION();
40625   }
40626
40627 }
40628
40629
40630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40631   void * jresult ;
40632   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40633   Dali::Actor result;
40634
40635   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40636   {
40637     try {
40638       result = (arg1)->GetScrollIndicator();
40639     } CALL_CATCH_EXCEPTION(0);
40640   }
40641
40642   jresult = new Dali::Actor((const Dali::Actor &)result);
40643   return jresult;
40644 }
40645
40646
40647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40648   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40649   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40650
40651   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40652   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40653   if (!arg2) {
40654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40655     return ;
40656   }
40657   {
40658     try {
40659       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40660     } CALL_CATCH_EXCEPTION();
40661   }
40662
40663 }
40664
40665
40666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40667   void * jresult ;
40668   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40669
40670   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40671   {
40672     try {
40673       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()));
40674     } CALL_CATCH_EXCEPTION(0);
40675   }
40676   return jresult;
40677 }
40678
40679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40680   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40681   Dali::Toolkit::ScrollBar::Direction arg2 ;
40682
40683   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40684   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40685   {
40686     try {
40687       (arg1)->SetScrollDirection(arg2);
40688     } CALL_CATCH_EXCEPTION();
40689   }
40690
40691 }
40692
40693
40694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40695   int jresult ;
40696   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40697   Dali::Toolkit::ScrollBar::Direction result;
40698
40699   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40700   {
40701     try {
40702       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40703     } CALL_CATCH_EXCEPTION(0);
40704   }
40705
40706   jresult = (int)result;
40707   return jresult;
40708 }
40709
40710
40711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40712   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40713   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40714
40715   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40716   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40717   {
40718     try {
40719       (arg1)->SetIndicatorHeightPolicy(arg2);
40720     } CALL_CATCH_EXCEPTION();
40721   }
40722
40723 }
40724
40725
40726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40727   int jresult ;
40728   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40729   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40730
40731   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40732   {
40733     try {
40734       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40735     } CALL_CATCH_EXCEPTION(0);
40736   }
40737
40738   jresult = (int)result;
40739   return jresult;
40740 }
40741
40742
40743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40744   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40745   float arg2 ;
40746
40747   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40748   arg2 = (float)jarg2;
40749   {
40750     try {
40751       (arg1)->SetIndicatorFixedHeight(arg2);
40752     } CALL_CATCH_EXCEPTION();
40753   }
40754
40755 }
40756
40757
40758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40759   float jresult ;
40760   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40761   float result;
40762
40763   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40764   {
40765     try {
40766       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40767     } CALL_CATCH_EXCEPTION(0);
40768   }
40769
40770   jresult = result;
40771   return jresult;
40772 }
40773
40774
40775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40776   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40777   float arg2 ;
40778
40779   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40780   arg2 = (float)jarg2;
40781   {
40782     try {
40783       (arg1)->SetIndicatorShowDuration(arg2);
40784     } CALL_CATCH_EXCEPTION();
40785   }
40786
40787 }
40788
40789
40790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40791   float jresult ;
40792   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40793   float result;
40794
40795   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40796   {
40797     try {
40798       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40799     } CALL_CATCH_EXCEPTION(0);
40800   }
40801
40802   jresult = result;
40803   return jresult;
40804 }
40805
40806
40807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40808   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40809   float arg2 ;
40810
40811   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40812   arg2 = (float)jarg2;
40813   {
40814     try {
40815       (arg1)->SetIndicatorHideDuration(arg2);
40816     } CALL_CATCH_EXCEPTION();
40817   }
40818
40819 }
40820
40821
40822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40823   float jresult ;
40824   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40825   float result;
40826
40827   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40828   {
40829     try {
40830       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40831     } CALL_CATCH_EXCEPTION(0);
40832   }
40833
40834   jresult = result;
40835   return jresult;
40836 }
40837
40838
40839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40840   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40841
40842   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40843   {
40844     try {
40845       (arg1)->ShowIndicator();
40846     } CALL_CATCH_EXCEPTION();
40847   }
40848
40849 }
40850
40851
40852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40853   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40854
40855   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40856   {
40857     try {
40858       (arg1)->HideIndicator();
40859     } CALL_CATCH_EXCEPTION();
40860   }
40861
40862 }
40863
40864
40865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40866   void * jresult ;
40867   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40868   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40869
40870   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40871   {
40872     try {
40873       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40874     } CALL_CATCH_EXCEPTION(0);
40875   }
40876
40877   jresult = (void *)result;
40878   return jresult;
40879 }
40880
40881
40882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40883   void * jresult ;
40884   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40885   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40886
40887   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40888   {
40889     try {
40890       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40891     } CALL_CATCH_EXCEPTION(0);
40892   }
40893
40894   jresult = (void *)result;
40895   return jresult;
40896 }
40897
40898
40899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40900   int jresult ;
40901   int result;
40902
40903   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40904   jresult = (int)result;
40905   return jresult;
40906 }
40907
40908
40909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40910   int jresult ;
40911   int result;
40912
40913   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40914   jresult = (int)result;
40915   return jresult;
40916 }
40917
40918
40919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40920   int jresult ;
40921   int result;
40922
40923   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40924   jresult = (int)result;
40925   return jresult;
40926 }
40927
40928
40929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40930   int jresult ;
40931   int result;
40932
40933   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40934   jresult = (int)result;
40935   return jresult;
40936 }
40937
40938
40939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40940   int jresult ;
40941   int result;
40942
40943   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40944   jresult = (int)result;
40945   return jresult;
40946 }
40947
40948
40949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
40950   int jresult ;
40951   int result;
40952
40953   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
40954   jresult = (int)result;
40955   return jresult;
40956 }
40957
40958
40959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
40960   int jresult ;
40961   int result;
40962
40963   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
40964   jresult = (int)result;
40965   return jresult;
40966 }
40967
40968
40969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
40970   int jresult ;
40971   int result;
40972
40973   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
40974   jresult = (int)result;
40975   return jresult;
40976 }
40977
40978
40979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
40980   int jresult ;
40981   int result;
40982
40983   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
40984   jresult = (int)result;
40985   return jresult;
40986 }
40987
40988
40989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
40990   int jresult ;
40991   int result;
40992
40993   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
40994   jresult = (int)result;
40995   return jresult;
40996 }
40997
40998
40999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
41000   int jresult ;
41001   int result;
41002
41003   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
41004   jresult = (int)result;
41005   return jresult;
41006 }
41007
41008
41009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
41010   int jresult ;
41011   int result;
41012
41013   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
41014   jresult = (int)result;
41015   return jresult;
41016 }
41017
41018
41019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
41020   int jresult ;
41021   int result;
41022
41023   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
41024   jresult = (int)result;
41025   return jresult;
41026 }
41027
41028
41029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
41030   int jresult ;
41031   int result;
41032
41033   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
41034   jresult = (int)result;
41035   return jresult;
41036 }
41037
41038
41039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
41040   void * jresult ;
41041   Dali::Toolkit::Scrollable::Property *result = 0 ;
41042
41043   {
41044     try {
41045       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
41046     } CALL_CATCH_EXCEPTION(0);
41047   }
41048
41049   jresult = (void *)result;
41050   return jresult;
41051 }
41052
41053
41054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
41055   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
41056
41057   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
41058   {
41059     try {
41060       delete arg1;
41061     } CALL_CATCH_EXCEPTION();
41062   }
41063
41064 }
41065
41066
41067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
41068   void * jresult ;
41069   Dali::Toolkit::Scrollable *result = 0 ;
41070
41071   {
41072     try {
41073       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
41074     } CALL_CATCH_EXCEPTION(0);
41075   }
41076
41077   jresult = (void *)result;
41078   return jresult;
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
41083   void * jresult ;
41084   Dali::Toolkit::Scrollable *arg1 = 0 ;
41085   Dali::Toolkit::Scrollable *result = 0 ;
41086
41087   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41088   if (!arg1) {
41089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41090     return 0;
41091   }
41092   {
41093     try {
41094       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
41095     } CALL_CATCH_EXCEPTION(0);
41096   }
41097
41098   jresult = (void *)result;
41099   return jresult;
41100 }
41101
41102
41103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
41104   void * jresult ;
41105   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41106   Dali::Toolkit::Scrollable *arg2 = 0 ;
41107   Dali::Toolkit::Scrollable *result = 0 ;
41108
41109   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41110   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
41111   if (!arg2) {
41112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41113     return 0;
41114   }
41115   {
41116     try {
41117       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
41118     } CALL_CATCH_EXCEPTION(0);
41119   }
41120
41121   jresult = (void *)result;
41122   return jresult;
41123 }
41124
41125
41126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
41127   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41128
41129   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41130   {
41131     try {
41132       delete arg1;
41133     } CALL_CATCH_EXCEPTION();
41134   }
41135
41136 }
41137
41138
41139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
41140   void * jresult ;
41141   Dali::BaseHandle arg1 ;
41142   Dali::BaseHandle *argp1 ;
41143   Dali::Toolkit::Scrollable result;
41144
41145   argp1 = (Dali::BaseHandle *)jarg1;
41146   if (!argp1) {
41147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41148     return 0;
41149   }
41150   arg1 = *argp1;
41151   {
41152     try {
41153       result = Dali::Toolkit::Scrollable::DownCast(arg1);
41154     } CALL_CATCH_EXCEPTION(0);
41155   }
41156
41157   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
41158   return jresult;
41159 }
41160
41161
41162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
41163   unsigned int jresult ;
41164   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41165   bool result;
41166
41167   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41168   {
41169     try {
41170       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
41171     } CALL_CATCH_EXCEPTION(0);
41172   }
41173
41174   jresult = result;
41175   return jresult;
41176 }
41177
41178
41179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
41180   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41181   bool arg2 ;
41182
41183   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41184   arg2 = jarg2 ? true : false;
41185   {
41186     try {
41187       (arg1)->SetOvershootEnabled(arg2);
41188     } CALL_CATCH_EXCEPTION();
41189   }
41190
41191 }
41192
41193
41194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41195   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41196   Dali::Vector4 *arg2 = 0 ;
41197
41198   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41199   arg2 = (Dali::Vector4 *)jarg2;
41200   if (!arg2) {
41201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41202     return ;
41203   }
41204   {
41205     try {
41206       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41207     } CALL_CATCH_EXCEPTION();
41208   }
41209
41210 }
41211
41212
41213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41214   void * jresult ;
41215   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41216   Dali::Vector4 result;
41217
41218   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41219   {
41220     try {
41221       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41222     } CALL_CATCH_EXCEPTION(0);
41223   }
41224
41225   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41231   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41232   float arg2 ;
41233
41234   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41235   arg2 = (float)jarg2;
41236   {
41237     try {
41238       (arg1)->SetOvershootAnimationSpeed(arg2);
41239     } CALL_CATCH_EXCEPTION();
41240   }
41241
41242 }
41243
41244
41245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41246   float jresult ;
41247   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41248   float result;
41249
41250   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41251   {
41252     try {
41253       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41254     } CALL_CATCH_EXCEPTION(0);
41255   }
41256
41257   jresult = result;
41258   return jresult;
41259 }
41260
41261
41262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41263   void * jresult ;
41264   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41265   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41266
41267   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41268   {
41269     try {
41270       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41271     } CALL_CATCH_EXCEPTION(0);
41272   }
41273
41274   jresult = (void *)result;
41275   return jresult;
41276 }
41277
41278
41279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41280   void * jresult ;
41281   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41282   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41283
41284   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41285   {
41286     try {
41287       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41288     } CALL_CATCH_EXCEPTION(0);
41289   }
41290
41291   jresult = (void *)result;
41292   return jresult;
41293 }
41294
41295
41296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41297   void * jresult ;
41298   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41299   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41300
41301   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41302   {
41303     try {
41304       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41305     } CALL_CATCH_EXCEPTION(0);
41306   }
41307
41308   jresult = (void *)result;
41309   return jresult;
41310 }
41311
41312
41313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41314   unsigned int jresult ;
41315   Dali::Toolkit::ControlOrientation::Type arg1 ;
41316   bool result;
41317
41318   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41319   {
41320     try {
41321       result = (bool)Dali::Toolkit::IsVertical(arg1);
41322     } CALL_CATCH_EXCEPTION(0);
41323   }
41324
41325   jresult = result;
41326   return jresult;
41327 }
41328
41329
41330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41331   unsigned int jresult ;
41332   Dali::Toolkit::ControlOrientation::Type arg1 ;
41333   bool result;
41334
41335   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41336   {
41337     try {
41338       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41339     } CALL_CATCH_EXCEPTION(0);
41340   }
41341
41342   jresult = result;
41343   return jresult;
41344 }
41345
41346
41347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41348   void * jresult ;
41349   unsigned int arg1 ;
41350   unsigned int arg2 ;
41351   Dali::Toolkit::ItemRange *result = 0 ;
41352
41353   arg1 = (unsigned int)jarg1;
41354   arg2 = (unsigned int)jarg2;
41355   {
41356     try {
41357       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41358     } CALL_CATCH_EXCEPTION(0);
41359   }
41360
41361   jresult = (void *)result;
41362   return jresult;
41363 }
41364
41365
41366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41367   void * jresult ;
41368   Dali::Toolkit::ItemRange *arg1 = 0 ;
41369   Dali::Toolkit::ItemRange *result = 0 ;
41370
41371   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41372   if (!arg1) {
41373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41374     return 0;
41375   }
41376   {
41377     try {
41378       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41379     } CALL_CATCH_EXCEPTION(0);
41380   }
41381
41382   jresult = (void *)result;
41383   return jresult;
41384 }
41385
41386
41387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41388   void * jresult ;
41389   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41390   Dali::Toolkit::ItemRange *arg2 = 0 ;
41391   Dali::Toolkit::ItemRange *result = 0 ;
41392
41393   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41394   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41395   if (!arg2) {
41396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41397     return 0;
41398   }
41399   {
41400     try {
41401       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41402     } CALL_CATCH_EXCEPTION(0);
41403   }
41404
41405   jresult = (void *)result;
41406   return jresult;
41407 }
41408
41409
41410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41411   unsigned int jresult ;
41412   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41413   unsigned int arg2 ;
41414   bool result;
41415
41416   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41417   arg2 = (unsigned int)jarg2;
41418   {
41419     try {
41420       result = (bool)(arg1)->Within(arg2);
41421     } CALL_CATCH_EXCEPTION(0);
41422   }
41423
41424   jresult = result;
41425   return jresult;
41426 }
41427
41428
41429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41430   void * jresult ;
41431   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41432   Dali::Toolkit::ItemRange *arg2 = 0 ;
41433   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41434
41435   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41436   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41437   if (!arg2) {
41438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41439     return 0;
41440   }
41441   {
41442     try {
41443       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41444     } CALL_CATCH_EXCEPTION(0);
41445   }
41446
41447   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41453   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41454   unsigned int arg2 ;
41455
41456   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41457   arg2 = (unsigned int)jarg2;
41458   if (arg1) (arg1)->begin = arg2;
41459 }
41460
41461
41462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41463   unsigned int jresult ;
41464   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41465   unsigned int result;
41466
41467   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41468   result = (unsigned int) ((arg1)->begin);
41469   jresult = result;
41470   return jresult;
41471 }
41472
41473
41474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41475   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41476   unsigned int arg2 ;
41477
41478   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41479   arg2 = (unsigned int)jarg2;
41480   if (arg1) (arg1)->end = arg2;
41481 }
41482
41483
41484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41485   unsigned int jresult ;
41486   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41487   unsigned int result;
41488
41489   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41490   result = (unsigned int) ((arg1)->end);
41491   jresult = result;
41492   return jresult;
41493 }
41494
41495
41496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41497   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41498
41499   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41500   {
41501     try {
41502       delete arg1;
41503     } CALL_CATCH_EXCEPTION();
41504   }
41505
41506 }
41507
41508
41509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41510   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41511
41512   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41513   {
41514     try {
41515       delete arg1;
41516     } CALL_CATCH_EXCEPTION();
41517   }
41518
41519 }
41520
41521
41522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41523   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41524   Dali::Toolkit::ControlOrientation::Type arg2 ;
41525
41526   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41527   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41528   {
41529     try {
41530       (arg1)->SetOrientation(arg2);
41531     } CALL_CATCH_EXCEPTION();
41532   }
41533
41534 }
41535
41536
41537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41538   int jresult ;
41539   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41540   Dali::Toolkit::ControlOrientation::Type result;
41541
41542   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41543   {
41544     try {
41545       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41546     } CALL_CATCH_EXCEPTION(0);
41547   }
41548
41549   jresult = (int)result;
41550   return jresult;
41551 }
41552
41553
41554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41555   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41556   Dali::Property::Map *arg2 = 0 ;
41557
41558   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41559   arg2 = (Dali::Property::Map *)jarg2;
41560   if (!arg2) {
41561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41562     return ;
41563   }
41564   {
41565     try {
41566       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41567     } CALL_CATCH_EXCEPTION();
41568   }
41569
41570 }
41571
41572
41573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41574   void * jresult ;
41575   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41576   Dali::Property::Map result;
41577
41578   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41579   {
41580     try {
41581       result = (arg1)->GetLayoutProperties();
41582     } CALL_CATCH_EXCEPTION(0);
41583   }
41584
41585   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41586   return jresult;
41587 }
41588
41589
41590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41591   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41592   unsigned int arg2 ;
41593   Dali::Vector3 *arg3 = 0 ;
41594   Dali::Vector3 *arg4 = 0 ;
41595
41596   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41597   arg2 = (unsigned int)jarg2;
41598   arg3 = (Dali::Vector3 *)jarg3;
41599   if (!arg3) {
41600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41601     return ;
41602   }
41603   arg4 = (Dali::Vector3 *)jarg4;
41604   if (!arg4) {
41605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41606     return ;
41607   }
41608   {
41609     try {
41610       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41611     } CALL_CATCH_EXCEPTION();
41612   }
41613
41614 }
41615
41616
41617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41618   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41619   Dali::Vector3 *arg2 = 0 ;
41620
41621   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41622   arg2 = (Dali::Vector3 *)jarg2;
41623   if (!arg2) {
41624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41625     return ;
41626   }
41627   {
41628     try {
41629       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41630     } CALL_CATCH_EXCEPTION();
41631   }
41632
41633 }
41634
41635
41636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41637   float jresult ;
41638   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41639   unsigned int arg2 ;
41640   Dali::Vector3 arg3 ;
41641   Dali::Vector3 *argp3 ;
41642   float result;
41643
41644   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41645   arg2 = (unsigned int)jarg2;
41646   argp3 = (Dali::Vector3 *)jarg3;
41647   if (!argp3) {
41648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41649     return 0;
41650   }
41651   arg3 = *argp3;
41652   {
41653     try {
41654       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41655     } CALL_CATCH_EXCEPTION(0);
41656   }
41657
41658   jresult = result;
41659   return jresult;
41660 }
41661
41662
41663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41664   float jresult ;
41665   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41666   float arg2 ;
41667   float result;
41668
41669   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41670   arg2 = (float)jarg2;
41671   {
41672     try {
41673       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41674     } CALL_CATCH_EXCEPTION(0);
41675   }
41676
41677   jresult = result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41683   float jresult ;
41684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41685   unsigned int arg2 ;
41686   float result;
41687
41688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41689   arg2 = (unsigned int)jarg2;
41690   {
41691     try {
41692       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41693     } CALL_CATCH_EXCEPTION(0);
41694   }
41695
41696   jresult = result;
41697   return jresult;
41698 }
41699
41700
41701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41702   void * jresult ;
41703   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41704   float arg2 ;
41705   Dali::Vector3 arg3 ;
41706   Dali::Vector3 *argp3 ;
41707   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41708
41709   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41710   arg2 = (float)jarg2;
41711   argp3 = (Dali::Vector3 *)jarg3;
41712   if (!argp3) {
41713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41714     return 0;
41715   }
41716   arg3 = *argp3;
41717   {
41718     try {
41719       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41720     } CALL_CATCH_EXCEPTION(0);
41721   }
41722
41723   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41724   return jresult;
41725 }
41726
41727
41728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41729   float jresult ;
41730   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41731   int arg2 ;
41732   float arg3 ;
41733   Dali::Vector3 *arg4 = 0 ;
41734   float result;
41735
41736   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41737   arg2 = (int)jarg2;
41738   arg3 = (float)jarg3;
41739   arg4 = (Dali::Vector3 *)jarg4;
41740   if (!arg4) {
41741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41742     return 0;
41743   }
41744   {
41745     try {
41746       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41747     } CALL_CATCH_EXCEPTION(0);
41748   }
41749
41750   jresult = result;
41751   return jresult;
41752 }
41753
41754
41755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41756   unsigned int jresult ;
41757   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41758   Dali::Vector3 arg2 ;
41759   Dali::Vector3 *argp2 ;
41760   unsigned int result;
41761
41762   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41763   argp2 = (Dali::Vector3 *)jarg2;
41764   if (!argp2) {
41765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41766     return 0;
41767   }
41768   arg2 = *argp2;
41769   {
41770     try {
41771       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41772     } CALL_CATCH_EXCEPTION(0);
41773   }
41774
41775   jresult = result;
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41781   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41782   unsigned int arg2 ;
41783   Dali::Vector3 *arg3 = 0 ;
41784   Dali::Vector3 *arg4 = 0 ;
41785
41786   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41787   arg2 = (unsigned int)jarg2;
41788   arg3 = (Dali::Vector3 *)jarg3;
41789   if (!arg3) {
41790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41791     return ;
41792   }
41793   arg4 = (Dali::Vector3 *)jarg4;
41794   if (!arg4) {
41795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41796     return ;
41797   }
41798   {
41799     try {
41800       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41801     } CALL_CATCH_EXCEPTION();
41802   }
41803
41804 }
41805
41806
41807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41808   void * jresult ;
41809   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41810   Dali::Degree result;
41811
41812   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41813   {
41814     try {
41815       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41816     } CALL_CATCH_EXCEPTION(0);
41817   }
41818
41819   jresult = new Dali::Degree((const Dali::Degree &)result);
41820   return jresult;
41821 }
41822
41823
41824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41825   float jresult ;
41826   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41827   float result;
41828
41829   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41830   {
41831     try {
41832       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41833     } CALL_CATCH_EXCEPTION(0);
41834   }
41835
41836   jresult = result;
41837   return jresult;
41838 }
41839
41840
41841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
41842   float jresult ;
41843   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41844   float result;
41845
41846   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41847   {
41848     try {
41849       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
41850     } CALL_CATCH_EXCEPTION(0);
41851   }
41852
41853   jresult = result;
41854   return jresult;
41855 }
41856
41857
41858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
41859   float jresult ;
41860   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41861   float result;
41862
41863   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41864   {
41865     try {
41866       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
41867     } CALL_CATCH_EXCEPTION(0);
41868   }
41869
41870   jresult = result;
41871   return jresult;
41872 }
41873
41874
41875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41876   int jresult ;
41877   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41878   int arg2 ;
41879   int arg3 ;
41880   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41881   bool arg5 ;
41882   int result;
41883
41884   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41885   arg2 = (int)jarg2;
41886   arg3 = (int)jarg3;
41887   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41888   arg5 = jarg5 ? true : false;
41889   {
41890     try {
41891       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41892     } CALL_CATCH_EXCEPTION(0);
41893   }
41894
41895   jresult = result;
41896   return jresult;
41897 }
41898
41899
41900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41901   float jresult ;
41902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41903   float result;
41904
41905   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41906   {
41907     try {
41908       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41909     } CALL_CATCH_EXCEPTION(0);
41910   }
41911
41912   jresult = result;
41913   return jresult;
41914 }
41915
41916
41917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41918   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41919   Dali::Actor *arg2 = 0 ;
41920   int arg3 ;
41921   Dali::Vector3 *arg4 = 0 ;
41922   Dali::Actor *arg5 = 0 ;
41923
41924   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41925   arg2 = (Dali::Actor *)jarg2;
41926   if (!arg2) {
41927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41928     return ;
41929   }
41930   arg3 = (int)jarg3;
41931   arg4 = (Dali::Vector3 *)jarg4;
41932   if (!arg4) {
41933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41934     return ;
41935   }
41936   arg5 = (Dali::Actor *)jarg5;
41937   if (!arg5) {
41938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41939     return ;
41940   }
41941   {
41942     try {
41943       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41944     } CALL_CATCH_EXCEPTION();
41945   }
41946
41947 }
41948
41949
41950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41951   void * jresult ;
41952   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41953   int arg2 ;
41954   float arg3 ;
41955   Dali::Vector3 *arg4 = 0 ;
41956   Dali::Vector3 result;
41957
41958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41959   arg2 = (int)jarg2;
41960   arg3 = (float)jarg3;
41961   arg4 = (Dali::Vector3 *)jarg4;
41962   if (!arg4) {
41963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41964     return 0;
41965   }
41966   {
41967     try {
41968       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41969     } CALL_CATCH_EXCEPTION(0);
41970   }
41971
41972   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
41973   return jresult;
41974 }
41975
41976
41977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
41978   void * jresult ;
41979   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
41980   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
41981
41982   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
41983   {
41984     try {
41985       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
41986     } CALL_CATCH_EXCEPTION(0);
41987   }
41988
41989   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
41990   return jresult;
41991 }
41992
41993
41994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
41995   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41996
41997   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41998   {
41999     try {
42000       delete arg1;
42001     } CALL_CATCH_EXCEPTION();
42002   }
42003
42004 }
42005
42006
42007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
42008   unsigned int jresult ;
42009   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42010   unsigned int result;
42011
42012   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42013   {
42014     try {
42015       result = (unsigned int)(arg1)->GetNumberOfItems();
42016     } CALL_CATCH_EXCEPTION(0);
42017   }
42018
42019   jresult = result;
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
42025   void * jresult ;
42026   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42027   unsigned int arg2 ;
42028   Dali::Actor result;
42029
42030   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42031   arg2 = (unsigned int)jarg2;
42032   {
42033     try {
42034       result = (arg1)->NewItem(arg2);
42035     } CALL_CATCH_EXCEPTION(0);
42036   }
42037
42038   jresult = new Dali::Actor((const Dali::Actor &)result);
42039   return jresult;
42040 }
42041
42042
42043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
42044   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42045   unsigned int arg2 ;
42046   Dali::Actor arg3 ;
42047   Dali::Actor *argp3 ;
42048
42049   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42050   arg2 = (unsigned int)jarg2;
42051   argp3 = (Dali::Actor *)jarg3;
42052   if (!argp3) {
42053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42054     return ;
42055   }
42056   arg3 = *argp3;
42057   {
42058     try {
42059       (arg1)->ItemReleased(arg2,arg3);
42060     } CALL_CATCH_EXCEPTION();
42061   }
42062
42063 }
42064
42065
42066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
42067   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42068   unsigned int arg2 ;
42069   Dali::Actor arg3 ;
42070   Dali::Actor *argp3 ;
42071
42072   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42073   arg2 = (unsigned int)jarg2;
42074   argp3 = (Dali::Actor *)jarg3;
42075   if (!argp3) {
42076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42077     return ;
42078   }
42079   arg3 = *argp3;
42080   {
42081     try {
42082       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
42083     } CALL_CATCH_EXCEPTION();
42084   }
42085
42086 }
42087
42088
42089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
42090   void * jresult ;
42091   Dali::Toolkit::ItemFactory *result = 0 ;
42092
42093   {
42094     try {
42095       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
42096     } CALL_CATCH_EXCEPTION(0);
42097   }
42098
42099   jresult = (void *)result;
42100   return jresult;
42101 }
42102
42103
42104 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) {
42105   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
42106   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
42107   if (director) {
42108     director->swig_connect_director(callback0, callback1, callback2);
42109   }
42110 }
42111
42112
42113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
42114   int jresult ;
42115   int result;
42116
42117   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
42118   jresult = (int)result;
42119   return jresult;
42120 }
42121
42122
42123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
42124   int jresult ;
42125   int result;
42126
42127   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
42128   jresult = (int)result;
42129   return jresult;
42130 }
42131
42132
42133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
42134   int jresult ;
42135   int result;
42136
42137   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
42138   jresult = (int)result;
42139   return jresult;
42140 }
42141
42142
42143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
42144   int jresult ;
42145   int result;
42146
42147   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
42148   jresult = (int)result;
42149   return jresult;
42150 }
42151
42152
42153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
42154   int jresult ;
42155   int result;
42156
42157   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
42158   jresult = (int)result;
42159   return jresult;
42160 }
42161
42162
42163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
42164   int jresult ;
42165   int result;
42166
42167   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
42168   jresult = (int)result;
42169   return jresult;
42170 }
42171
42172
42173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
42174   int jresult ;
42175   int result;
42176
42177   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
42178   jresult = (int)result;
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42184   int jresult ;
42185   int result;
42186
42187   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42188   jresult = (int)result;
42189   return jresult;
42190 }
42191
42192
42193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42194   int jresult ;
42195   int result;
42196
42197   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42198   jresult = (int)result;
42199   return jresult;
42200 }
42201
42202
42203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42204   int jresult ;
42205   int result;
42206
42207   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42208   jresult = (int)result;
42209   return jresult;
42210 }
42211
42212
42213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42214   int jresult ;
42215   int result;
42216
42217   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42218   jresult = (int)result;
42219   return jresult;
42220 }
42221
42222
42223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42224   void * jresult ;
42225   Dali::Toolkit::ItemView::Property *result = 0 ;
42226
42227   {
42228     try {
42229       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42230     } CALL_CATCH_EXCEPTION(0);
42231   }
42232
42233   jresult = (void *)result;
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42239   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42240
42241   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42242   {
42243     try {
42244       delete arg1;
42245     } CALL_CATCH_EXCEPTION();
42246   }
42247
42248 }
42249
42250
42251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42252   void * jresult ;
42253   Dali::Toolkit::ItemView *result = 0 ;
42254
42255   {
42256     try {
42257       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42258     } CALL_CATCH_EXCEPTION(0);
42259   }
42260
42261   jresult = (void *)result;
42262   return jresult;
42263 }
42264
42265
42266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42267   void * jresult ;
42268   Dali::Toolkit::ItemView *arg1 = 0 ;
42269   Dali::Toolkit::ItemView *result = 0 ;
42270
42271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42272   if (!arg1) {
42273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42274     return 0;
42275   }
42276   {
42277     try {
42278       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42279     } CALL_CATCH_EXCEPTION(0);
42280   }
42281
42282   jresult = (void *)result;
42283   return jresult;
42284 }
42285
42286
42287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42288   void * jresult ;
42289   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42290   Dali::Toolkit::ItemView *arg2 = 0 ;
42291   Dali::Toolkit::ItemView *result = 0 ;
42292
42293   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42294   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42295   if (!arg2) {
42296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42297     return 0;
42298   }
42299   {
42300     try {
42301       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42302     } CALL_CATCH_EXCEPTION(0);
42303   }
42304
42305   jresult = (void *)result;
42306   return jresult;
42307 }
42308
42309
42310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42311   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42312
42313   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42314   {
42315     try {
42316       delete arg1;
42317     } CALL_CATCH_EXCEPTION();
42318   }
42319
42320 }
42321
42322
42323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42324   void * jresult ;
42325   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42326   Dali::Toolkit::ItemView result;
42327
42328   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42329   if (!arg1) {
42330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42331     return 0;
42332   }
42333   {
42334     try {
42335       result = Dali::Toolkit::ItemView::New(*arg1);
42336     } CALL_CATCH_EXCEPTION(0);
42337   }
42338
42339   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42340   return jresult;
42341 }
42342
42343
42344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42345   void * jresult ;
42346   Dali::BaseHandle arg1 ;
42347   Dali::BaseHandle *argp1 ;
42348   Dali::Toolkit::ItemView result;
42349
42350   argp1 = (Dali::BaseHandle *)jarg1;
42351   if (!argp1) {
42352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42353     return 0;
42354   }
42355   arg1 = *argp1;
42356   {
42357     try {
42358       result = Dali::Toolkit::ItemView::DownCast(arg1);
42359     } CALL_CATCH_EXCEPTION(0);
42360   }
42361
42362   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42368   unsigned int jresult ;
42369   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42370   unsigned int result;
42371
42372   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42373   {
42374     try {
42375       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42376     } CALL_CATCH_EXCEPTION(0);
42377   }
42378
42379   jresult = result;
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42385   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42386   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42387
42388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42389   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42390   if (!arg2) {
42391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42392     return ;
42393   }
42394   {
42395     try {
42396       (arg1)->AddLayout(*arg2);
42397     } CALL_CATCH_EXCEPTION();
42398   }
42399
42400 }
42401
42402
42403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42404   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42405   unsigned int arg2 ;
42406
42407   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42408   arg2 = (unsigned int)jarg2;
42409   {
42410     try {
42411       (arg1)->RemoveLayout(arg2);
42412     } CALL_CATCH_EXCEPTION();
42413   }
42414
42415 }
42416
42417
42418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42419   void * jresult ;
42420   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42421   unsigned int arg2 ;
42422   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42423
42424   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42425   arg2 = (unsigned int)jarg2;
42426   {
42427     try {
42428       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42429     } CALL_CATCH_EXCEPTION(0);
42430   }
42431
42432   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42433   return jresult;
42434 }
42435
42436
42437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42438   void * jresult ;
42439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42440   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42441
42442   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42443   {
42444     try {
42445       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42446     } CALL_CATCH_EXCEPTION(0);
42447   }
42448
42449   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42450   return jresult;
42451 }
42452
42453
42454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42455   float jresult ;
42456   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42457   Dali::Toolkit::ItemId arg2 ;
42458   float result;
42459
42460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42461   arg2 = (Dali::Toolkit::ItemId)jarg2;
42462   {
42463     try {
42464       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42465     } CALL_CATCH_EXCEPTION(0);
42466   }
42467
42468   jresult = result;
42469   return jresult;
42470 }
42471
42472
42473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42474   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42475   unsigned int arg2 ;
42476   Dali::Vector3 arg3 ;
42477   float arg4 ;
42478   Dali::Vector3 *argp3 ;
42479
42480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42481   arg2 = (unsigned int)jarg2;
42482   argp3 = (Dali::Vector3 *)jarg3;
42483   if (!argp3) {
42484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42485     return ;
42486   }
42487   arg3 = *argp3;
42488   arg4 = (float)jarg4;
42489   {
42490     try {
42491       (arg1)->ActivateLayout(arg2,arg3,arg4);
42492     } CALL_CATCH_EXCEPTION();
42493   }
42494
42495 }
42496
42497
42498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42499   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42500
42501   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42502   {
42503     try {
42504       (arg1)->DeactivateCurrentLayout();
42505     } CALL_CATCH_EXCEPTION();
42506   }
42507
42508 }
42509
42510
42511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42512   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42513   float arg2 ;
42514
42515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42516   arg2 = (float)jarg2;
42517   {
42518     try {
42519       (arg1)->SetMinimumSwipeSpeed(arg2);
42520     } CALL_CATCH_EXCEPTION();
42521   }
42522
42523 }
42524
42525
42526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42527   float jresult ;
42528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42529   float result;
42530
42531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42532   {
42533     try {
42534       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42535     } CALL_CATCH_EXCEPTION(0);
42536   }
42537
42538   jresult = result;
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42544   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42545   float arg2 ;
42546
42547   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42548   arg2 = (float)jarg2;
42549   {
42550     try {
42551       (arg1)->SetMinimumSwipeDistance(arg2);
42552     } CALL_CATCH_EXCEPTION();
42553   }
42554
42555 }
42556
42557
42558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42559   float jresult ;
42560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42561   float result;
42562
42563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42564   {
42565     try {
42566       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42567     } CALL_CATCH_EXCEPTION(0);
42568   }
42569
42570   jresult = result;
42571   return jresult;
42572 }
42573
42574
42575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42576   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42577   float arg2 ;
42578
42579   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42580   arg2 = (float)jarg2;
42581   {
42582     try {
42583       (arg1)->SetWheelScrollDistanceStep(arg2);
42584     } CALL_CATCH_EXCEPTION();
42585   }
42586
42587 }
42588
42589
42590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42591   float jresult ;
42592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42593   float result;
42594
42595   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42596   {
42597     try {
42598       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42599     } CALL_CATCH_EXCEPTION(0);
42600   }
42601
42602   jresult = result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42608   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42609   bool arg2 ;
42610
42611   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42612   arg2 = jarg2 ? true : false;
42613   {
42614     try {
42615       (arg1)->SetAnchoring(arg2);
42616     } CALL_CATCH_EXCEPTION();
42617   }
42618
42619 }
42620
42621 //// ========================= end of part 3 =============================
42622
42623 //// ========================== start part 4 ===============================
42624
42625
42626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42627   unsigned int jresult ;
42628   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42629   bool result;
42630
42631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42632   {
42633     try {
42634       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42635     } CALL_CATCH_EXCEPTION(0);
42636   }
42637
42638   jresult = result;
42639   return jresult;
42640 }
42641
42642
42643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42644   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42645   float arg2 ;
42646
42647   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42648   arg2 = (float)jarg2;
42649   {
42650     try {
42651       (arg1)->SetAnchoringDuration(arg2);
42652     } CALL_CATCH_EXCEPTION();
42653   }
42654
42655 }
42656
42657
42658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42659   float jresult ;
42660   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42661   float result;
42662
42663   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42664   {
42665     try {
42666       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42667     } CALL_CATCH_EXCEPTION(0);
42668   }
42669
42670   jresult = result;
42671   return jresult;
42672 }
42673
42674
42675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42676   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42677   Dali::Toolkit::ItemId arg2 ;
42678   float arg3 ;
42679
42680   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42681   arg2 = (Dali::Toolkit::ItemId)jarg2;
42682   arg3 = (float)jarg3;
42683   {
42684     try {
42685       (arg1)->ScrollToItem(arg2,arg3);
42686     } CALL_CATCH_EXCEPTION();
42687   }
42688
42689 }
42690
42691
42692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42693   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42694   float arg2 ;
42695
42696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42697   arg2 = (float)jarg2;
42698   {
42699     try {
42700       (arg1)->SetRefreshInterval(arg2);
42701     } CALL_CATCH_EXCEPTION();
42702   }
42703
42704 }
42705
42706
42707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42708   float jresult ;
42709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42710   float result;
42711
42712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42713   {
42714     try {
42715       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42716     } CALL_CATCH_EXCEPTION(0);
42717   }
42718
42719   jresult = result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42726
42727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42728   {
42729     try {
42730       (arg1)->Refresh();
42731     } CALL_CATCH_EXCEPTION();
42732   }
42733
42734 }
42735
42736
42737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42738   void * jresult ;
42739   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42740   Dali::Toolkit::ItemId arg2 ;
42741   Dali::Actor result;
42742
42743   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42744   arg2 = (Dali::Toolkit::ItemId)jarg2;
42745   {
42746     try {
42747       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42748     } CALL_CATCH_EXCEPTION(0);
42749   }
42750
42751   jresult = new Dali::Actor((const Dali::Actor &)result);
42752   return jresult;
42753 }
42754
42755
42756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42757   unsigned int jresult ;
42758   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42759   Dali::Actor arg2 ;
42760   Dali::Actor *argp2 ;
42761   Dali::Toolkit::ItemId result;
42762
42763   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42764   argp2 = (Dali::Actor *)jarg2;
42765   if (!argp2) {
42766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42767     return 0;
42768   }
42769   arg2 = *argp2;
42770   {
42771     try {
42772       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42773     } CALL_CATCH_EXCEPTION(0);
42774   }
42775
42776   jresult = result;
42777   return jresult;
42778 }
42779
42780
42781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42782   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42783   Dali::Toolkit::Item arg2 ;
42784   float arg3 ;
42785   Dali::Toolkit::Item *argp2 ;
42786
42787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42788   argp2 = (Dali::Toolkit::Item *)jarg2;
42789   if (!argp2) {
42790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42791     return ;
42792   }
42793   arg2 = *argp2;
42794   arg3 = (float)jarg3;
42795   {
42796     try {
42797       (arg1)->InsertItem(arg2,arg3);
42798     } CALL_CATCH_EXCEPTION();
42799   }
42800
42801 }
42802
42803
42804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42805   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42806   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42807   float arg3 ;
42808
42809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42810   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42811   if (!arg2) {
42812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42813     return ;
42814   }
42815   arg3 = (float)jarg3;
42816   {
42817     try {
42818       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42819     } CALL_CATCH_EXCEPTION();
42820   }
42821
42822 }
42823
42824
42825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42827   Dali::Toolkit::ItemId arg2 ;
42828   float arg3 ;
42829
42830   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42831   arg2 = (Dali::Toolkit::ItemId)jarg2;
42832   arg3 = (float)jarg3;
42833   {
42834     try {
42835       (arg1)->RemoveItem(arg2,arg3);
42836     } CALL_CATCH_EXCEPTION();
42837   }
42838
42839 }
42840
42841
42842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42844   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42845   float arg3 ;
42846
42847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42848   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42849   if (!arg2) {
42850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42851     return ;
42852   }
42853   arg3 = (float)jarg3;
42854   {
42855     try {
42856       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42857     } CALL_CATCH_EXCEPTION();
42858   }
42859
42860 }
42861
42862
42863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42865   Dali::Toolkit::Item arg2 ;
42866   float arg3 ;
42867   Dali::Toolkit::Item *argp2 ;
42868
42869   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42870   argp2 = (Dali::Toolkit::Item *)jarg2;
42871   if (!argp2) {
42872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42873     return ;
42874   }
42875   arg2 = *argp2;
42876   arg3 = (float)jarg3;
42877   {
42878     try {
42879       (arg1)->ReplaceItem(arg2,arg3);
42880     } CALL_CATCH_EXCEPTION();
42881   }
42882
42883 }
42884
42885
42886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42888   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42889   float arg3 ;
42890
42891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42892   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42893   if (!arg2) {
42894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42895     return ;
42896   }
42897   arg3 = (float)jarg3;
42898   {
42899     try {
42900       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42901     } CALL_CATCH_EXCEPTION();
42902   }
42903
42904 }
42905
42906
42907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42909   Dali::Vector3 *arg2 = 0 ;
42910
42911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42912   arg2 = (Dali::Vector3 *)jarg2;
42913   if (!arg2) {
42914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42915     return ;
42916   }
42917   {
42918     try {
42919       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42920     } CALL_CATCH_EXCEPTION();
42921   }
42922
42923 }
42924
42925
42926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42927   void * jresult ;
42928   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42929   Dali::Vector3 result;
42930
42931   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42932   {
42933     try {
42934       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42935     } CALL_CATCH_EXCEPTION(0);
42936   }
42937
42938   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42939   return jresult;
42940 }
42941
42942
42943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
42944   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42945   Dali::Vector3 *arg2 = 0 ;
42946
42947   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42948   arg2 = (Dali::Vector3 *)jarg2;
42949   if (!arg2) {
42950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42951     return ;
42952   }
42953   {
42954     try {
42955       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
42956     } CALL_CATCH_EXCEPTION();
42957   }
42958
42959 }
42960
42961
42962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
42963   void * jresult ;
42964   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42965   Dali::Vector3 result;
42966
42967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42968   {
42969     try {
42970       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
42971     } CALL_CATCH_EXCEPTION(0);
42972   }
42973
42974   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42975   return jresult;
42976 }
42977
42978
42979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
42980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42981   Dali::Toolkit::ItemRange *arg2 = 0 ;
42982
42983   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42984   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42985   if (!arg2) {
42986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
42987     return ;
42988   }
42989   {
42990     try {
42991       (arg1)->GetItemsRange(*arg2);
42992     } CALL_CATCH_EXCEPTION();
42993   }
42994
42995 }
42996
42997
42998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
42999   void * jresult ;
43000   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43001   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
43002
43003   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43004   {
43005     try {
43006       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
43007     } CALL_CATCH_EXCEPTION(0);
43008   }
43009
43010   jresult = (void *)result;
43011   return jresult;
43012 }
43013
43014
43015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
43016   Dali::Vector3 *arg1 = 0 ;
43017   PropertyInputContainer *arg2 = 0 ;
43018
43019   arg1 = (Dali::Vector3 *)jarg1;
43020   if (!arg1) {
43021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43022     return ;
43023   }
43024   arg2 = (PropertyInputContainer *)jarg2;
43025   if (!arg2) {
43026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43027     return ;
43028   }
43029   {
43030     try {
43031       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43032     } CALL_CATCH_EXCEPTION();
43033   }
43034
43035 }
43036
43037
43038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
43039   Dali::Vector3 *arg1 = 0 ;
43040   PropertyInputContainer *arg2 = 0 ;
43041
43042   arg1 = (Dali::Vector3 *)jarg1;
43043   if (!arg1) {
43044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43045     return ;
43046   }
43047   arg2 = (PropertyInputContainer *)jarg2;
43048   if (!arg2) {
43049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43050     return ;
43051   }
43052   {
43053     try {
43054       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43055     } CALL_CATCH_EXCEPTION();
43056   }
43057
43058 }
43059
43060
43061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
43062   void * jresult ;
43063   Dali::Toolkit::ScrollViewEffect *result = 0 ;
43064
43065   {
43066     try {
43067       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
43068     } CALL_CATCH_EXCEPTION(0);
43069   }
43070
43071   jresult = (void *)result;
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
43077   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
43078
43079   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
43080   {
43081     try {
43082       delete arg1;
43083     } CALL_CATCH_EXCEPTION();
43084   }
43085
43086 }
43087
43088
43089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
43090   void * jresult ;
43091   Dali::Path arg1 ;
43092   Dali::Vector3 *arg2 = 0 ;
43093   Dali::Property::Index arg3 ;
43094   Dali::Vector3 *arg4 = 0 ;
43095   unsigned int arg5 ;
43096   Dali::Path *argp1 ;
43097   Dali::Toolkit::ScrollViewPagePathEffect result;
43098
43099   argp1 = (Dali::Path *)jarg1;
43100   if (!argp1) {
43101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
43102     return 0;
43103   }
43104   arg1 = *argp1;
43105   arg2 = (Dali::Vector3 *)jarg2;
43106   if (!arg2) {
43107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43108     return 0;
43109   }
43110   arg3 = (Dali::Property::Index)jarg3;
43111   arg4 = (Dali::Vector3 *)jarg4;
43112   if (!arg4) {
43113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43114     return 0;
43115   }
43116   arg5 = (unsigned int)jarg5;
43117   {
43118     try {
43119       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
43120     } CALL_CATCH_EXCEPTION(0);
43121   }
43122
43123   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43124   return jresult;
43125 }
43126
43127
43128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
43129   void * jresult ;
43130   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
43131
43132   {
43133     try {
43134       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
43135     } CALL_CATCH_EXCEPTION(0);
43136   }
43137
43138   jresult = (void *)result;
43139   return jresult;
43140 }
43141
43142
43143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
43144   void * jresult ;
43145   Dali::BaseHandle arg1 ;
43146   Dali::BaseHandle *argp1 ;
43147   Dali::Toolkit::ScrollViewPagePathEffect result;
43148
43149   argp1 = (Dali::BaseHandle *)jarg1;
43150   if (!argp1) {
43151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43152     return 0;
43153   }
43154   arg1 = *argp1;
43155   {
43156     try {
43157       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
43158     } CALL_CATCH_EXCEPTION(0);
43159   }
43160
43161   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43162   return jresult;
43163 }
43164
43165
43166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
43167   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43168   Dali::Actor arg2 ;
43169   unsigned int arg3 ;
43170   Dali::Actor *argp2 ;
43171
43172   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43173   argp2 = (Dali::Actor *)jarg2;
43174   if (!argp2) {
43175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43176     return ;
43177   }
43178   arg2 = *argp2;
43179   arg3 = (unsigned int)jarg3;
43180   {
43181     try {
43182       (arg1)->ApplyToPage(arg2,arg3);
43183     } CALL_CATCH_EXCEPTION();
43184   }
43185
43186 }
43187
43188
43189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43190   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43191
43192   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43193   {
43194     try {
43195       delete arg1;
43196     } CALL_CATCH_EXCEPTION();
43197   }
43198
43199 }
43200
43201
43202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43203   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43204   Dali::Toolkit::ClampState arg2 ;
43205
43206   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43207   arg2 = (Dali::Toolkit::ClampState)jarg2;
43208   if (arg1) (arg1)->x = arg2;
43209 }
43210
43211
43212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43213   int jresult ;
43214   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43215   Dali::Toolkit::ClampState result;
43216
43217   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43218   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43219   jresult = (int)result;
43220   return jresult;
43221 }
43222
43223
43224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43225   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43226   Dali::Toolkit::ClampState arg2 ;
43227
43228   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43229   arg2 = (Dali::Toolkit::ClampState)jarg2;
43230   if (arg1) (arg1)->y = arg2;
43231 }
43232
43233
43234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43235   int jresult ;
43236   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43237   Dali::Toolkit::ClampState result;
43238
43239   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43240   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43241   jresult = (int)result;
43242   return jresult;
43243 }
43244
43245
43246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43247   void * jresult ;
43248   Dali::Toolkit::ClampState2D *result = 0 ;
43249
43250   {
43251     try {
43252       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43253     } CALL_CATCH_EXCEPTION(0);
43254   }
43255
43256   jresult = (void *)result;
43257   return jresult;
43258 }
43259
43260
43261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43262   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43263
43264   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43265   {
43266     try {
43267       delete arg1;
43268     } CALL_CATCH_EXCEPTION();
43269   }
43270
43271 }
43272
43273
43274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43275   void * jresult ;
43276   float arg1 ;
43277   float arg2 ;
43278   bool arg3 ;
43279   Dali::Toolkit::RulerDomain *result = 0 ;
43280
43281   arg1 = (float)jarg1;
43282   arg2 = (float)jarg2;
43283   arg3 = jarg3 ? true : false;
43284   {
43285     try {
43286       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43287     } CALL_CATCH_EXCEPTION(0);
43288   }
43289
43290   jresult = (void *)result;
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43296   void * jresult ;
43297   float arg1 ;
43298   float arg2 ;
43299   Dali::Toolkit::RulerDomain *result = 0 ;
43300
43301   arg1 = (float)jarg1;
43302   arg2 = (float)jarg2;
43303   {
43304     try {
43305       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43306     } CALL_CATCH_EXCEPTION(0);
43307   }
43308
43309   jresult = (void *)result;
43310   return jresult;
43311 }
43312
43313
43314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43315   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43316   float arg2 ;
43317
43318   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43319   arg2 = (float)jarg2;
43320   if (arg1) (arg1)->min = arg2;
43321 }
43322
43323
43324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43325   float jresult ;
43326   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43327   float result;
43328
43329   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43330   result = (float) ((arg1)->min);
43331   jresult = result;
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43337   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43338   float arg2 ;
43339
43340   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43341   arg2 = (float)jarg2;
43342   if (arg1) (arg1)->max = arg2;
43343 }
43344
43345
43346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43347   float jresult ;
43348   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43349   float result;
43350
43351   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43352   result = (float) ((arg1)->max);
43353   jresult = result;
43354   return jresult;
43355 }
43356
43357
43358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43359   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43360   bool arg2 ;
43361
43362   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43363   arg2 = jarg2 ? true : false;
43364   if (arg1) (arg1)->enabled = arg2;
43365 }
43366
43367
43368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43369   unsigned int jresult ;
43370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43371   bool result;
43372
43373   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43374   result = (bool) ((arg1)->enabled);
43375   jresult = result;
43376   return jresult;
43377 }
43378
43379
43380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43381   float jresult ;
43382   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43383   float arg2 ;
43384   float arg3 ;
43385   float arg4 ;
43386   float result;
43387
43388   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43389   arg2 = (float)jarg2;
43390   arg3 = (float)jarg3;
43391   arg4 = (float)jarg4;
43392   {
43393     try {
43394       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43395     } CALL_CATCH_EXCEPTION(0);
43396   }
43397
43398   jresult = result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43404   float jresult ;
43405   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43406   float arg2 ;
43407   float arg3 ;
43408   float result;
43409
43410   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43411   arg2 = (float)jarg2;
43412   arg3 = (float)jarg3;
43413   {
43414     try {
43415       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43416     } CALL_CATCH_EXCEPTION(0);
43417   }
43418
43419   jresult = result;
43420   return jresult;
43421 }
43422
43423
43424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43425   float jresult ;
43426   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43427   float arg2 ;
43428   float result;
43429
43430   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43431   arg2 = (float)jarg2;
43432   {
43433     try {
43434       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43435     } CALL_CATCH_EXCEPTION(0);
43436   }
43437
43438   jresult = result;
43439   return jresult;
43440 }
43441
43442
43443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43444   float jresult ;
43445   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43446   float arg2 ;
43447   float arg3 ;
43448   float arg4 ;
43449   Dali::Toolkit::ClampState *arg5 = 0 ;
43450   float result;
43451
43452   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43453   arg2 = (float)jarg2;
43454   arg3 = (float)jarg3;
43455   arg4 = (float)jarg4;
43456   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43457   if (!arg5) {
43458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43459     return 0;
43460   }
43461   {
43462     try {
43463       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43464     } CALL_CATCH_EXCEPTION(0);
43465   }
43466
43467   jresult = result;
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43473   float jresult ;
43474   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43475   float result;
43476
43477   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43478   {
43479     try {
43480       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43481     } CALL_CATCH_EXCEPTION(0);
43482   }
43483
43484   jresult = result;
43485   return jresult;
43486 }
43487
43488
43489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43490   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43491
43492   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43493   {
43494     try {
43495       delete arg1;
43496     } CALL_CATCH_EXCEPTION();
43497   }
43498
43499 }
43500
43501
43502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43503   float jresult ;
43504   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43505   float arg2 ;
43506   float arg3 ;
43507   float result;
43508
43509   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43510   arg2 = (float)jarg2;
43511   arg3 = (float)jarg3;
43512   {
43513     try {
43514       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43515     } CALL_CATCH_EXCEPTION(0);
43516   }
43517
43518   jresult = result;
43519   return jresult;
43520 }
43521
43522
43523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43524   float jresult ;
43525   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43526   float arg2 ;
43527   float result;
43528
43529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43530   arg2 = (float)jarg2;
43531   {
43532     try {
43533       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43534     } CALL_CATCH_EXCEPTION(0);
43535   }
43536
43537   jresult = result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43543   float jresult ;
43544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43545   unsigned int arg2 ;
43546   unsigned int *arg3 = 0 ;
43547   bool arg4 ;
43548   float result;
43549
43550   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43551   arg2 = (unsigned int)jarg2;
43552   arg3 = (unsigned int *)jarg3;
43553   arg4 = jarg4 ? true : false;
43554   {
43555     try {
43556       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43557     } CALL_CATCH_EXCEPTION(0);
43558   }
43559
43560   jresult = result;
43561   return jresult;
43562 }
43563
43564
43565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43566   unsigned int jresult ;
43567   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43568   float arg2 ;
43569   bool arg3 ;
43570   unsigned int result;
43571
43572   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43573   arg2 = (float)jarg2;
43574   arg3 = jarg3 ? true : false;
43575   {
43576     try {
43577       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43578     } CALL_CATCH_EXCEPTION(0);
43579   }
43580
43581   jresult = result;
43582   return jresult;
43583 }
43584
43585
43586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43587   unsigned int jresult ;
43588   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43589   unsigned int result;
43590
43591   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43592   {
43593     try {
43594       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43595     } CALL_CATCH_EXCEPTION(0);
43596   }
43597
43598   jresult = result;
43599   return jresult;
43600 }
43601
43602
43603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43604   int jresult ;
43605   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43606   Dali::Toolkit::Ruler::RulerType result;
43607
43608   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43609   {
43610     try {
43611       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43612     } CALL_CATCH_EXCEPTION(0);
43613   }
43614
43615   jresult = (int)result;
43616   return jresult;
43617 }
43618
43619
43620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43621   unsigned int jresult ;
43622   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43623   bool result;
43624
43625   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43626   {
43627     try {
43628       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43629     } CALL_CATCH_EXCEPTION(0);
43630   }
43631
43632   jresult = result;
43633   return jresult;
43634 }
43635
43636
43637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43638   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43639
43640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43641   {
43642     try {
43643       (arg1)->Enable();
43644     } CALL_CATCH_EXCEPTION();
43645   }
43646
43647 }
43648
43649
43650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43651   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43652
43653   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43654   {
43655     try {
43656       (arg1)->Disable();
43657     } CALL_CATCH_EXCEPTION();
43658   }
43659
43660 }
43661
43662
43663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43664   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43665   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43666   Dali::Toolkit::RulerDomain *argp2 ;
43667
43668   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43669   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43670   if (!argp2) {
43671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43672     return ;
43673   }
43674   arg2 = *argp2;
43675   {
43676     try {
43677       (arg1)->SetDomain(arg2);
43678     } CALL_CATCH_EXCEPTION();
43679   }
43680
43681 }
43682
43683
43684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43685   void * jresult ;
43686   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43687   Dali::Toolkit::RulerDomain *result = 0 ;
43688
43689   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43690   {
43691     try {
43692       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43693     } CALL_CATCH_EXCEPTION(0);
43694   }
43695
43696   jresult = (void *)result;
43697   return jresult;
43698 }
43699
43700
43701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43702   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43703
43704   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43705   {
43706     try {
43707       (arg1)->DisableDomain();
43708     } CALL_CATCH_EXCEPTION();
43709   }
43710
43711 }
43712
43713
43714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43715   float jresult ;
43716   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43717   float arg2 ;
43718   float arg3 ;
43719   float arg4 ;
43720   float result;
43721
43722   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43723   arg2 = (float)jarg2;
43724   arg3 = (float)jarg3;
43725   arg4 = (float)jarg4;
43726   {
43727     try {
43728       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43729     } CALL_CATCH_EXCEPTION(0);
43730   }
43731
43732   jresult = result;
43733   return jresult;
43734 }
43735
43736
43737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43738   float jresult ;
43739   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43740   float arg2 ;
43741   float arg3 ;
43742   float result;
43743
43744   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43745   arg2 = (float)jarg2;
43746   arg3 = (float)jarg3;
43747   {
43748     try {
43749       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43750     } CALL_CATCH_EXCEPTION(0);
43751   }
43752
43753   jresult = result;
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43759   float jresult ;
43760   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43761   float arg2 ;
43762   float result;
43763
43764   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43765   arg2 = (float)jarg2;
43766   {
43767     try {
43768       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43769     } CALL_CATCH_EXCEPTION(0);
43770   }
43771
43772   jresult = result;
43773   return jresult;
43774 }
43775
43776
43777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43778   float jresult ;
43779   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43780   float arg2 ;
43781   float arg3 ;
43782   float arg4 ;
43783   Dali::Toolkit::ClampState *arg5 = 0 ;
43784   float result;
43785
43786   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43787   arg2 = (float)jarg2;
43788   arg3 = (float)jarg3;
43789   arg4 = (float)jarg4;
43790   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43791   if (!arg5) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43793     return 0;
43794   }
43795   {
43796     try {
43797       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43798     } CALL_CATCH_EXCEPTION(0);
43799   }
43800
43801   jresult = result;
43802   return jresult;
43803 }
43804
43805
43806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43807   float jresult ;
43808   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43809   float arg2 ;
43810   float arg3 ;
43811   float arg4 ;
43812   float arg5 ;
43813   float result;
43814
43815   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43816   arg2 = (float)jarg2;
43817   arg3 = (float)jarg3;
43818   arg4 = (float)jarg4;
43819   arg5 = (float)jarg5;
43820   {
43821     try {
43822       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43823     } CALL_CATCH_EXCEPTION(0);
43824   }
43825
43826   jresult = result;
43827   return jresult;
43828 }
43829
43830
43831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43832   float jresult ;
43833   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43834   float arg2 ;
43835   float arg3 ;
43836   float arg4 ;
43837   float result;
43838
43839   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43840   arg2 = (float)jarg2;
43841   arg3 = (float)jarg3;
43842   arg4 = (float)jarg4;
43843   {
43844     try {
43845       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43846     } CALL_CATCH_EXCEPTION(0);
43847   }
43848
43849   jresult = result;
43850   return jresult;
43851 }
43852
43853
43854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43855   float jresult ;
43856   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43857   float arg2 ;
43858   float arg3 ;
43859   float result;
43860
43861   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43862   arg2 = (float)jarg2;
43863   arg3 = (float)jarg3;
43864   {
43865     try {
43866       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43867     } CALL_CATCH_EXCEPTION(0);
43868   }
43869
43870   jresult = result;
43871   return jresult;
43872 }
43873
43874
43875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43876   float jresult ;
43877   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43878   float arg2 ;
43879   float result;
43880
43881   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43882   arg2 = (float)jarg2;
43883   {
43884     try {
43885       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43886     } CALL_CATCH_EXCEPTION(0);
43887   }
43888
43889   jresult = result;
43890   return jresult;
43891 }
43892
43893
43894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43895   float jresult ;
43896   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43897   float arg2 ;
43898   float arg3 ;
43899   float arg4 ;
43900   float arg5 ;
43901   Dali::Toolkit::ClampState *arg6 = 0 ;
43902   float result;
43903
43904   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43905   arg2 = (float)jarg2;
43906   arg3 = (float)jarg3;
43907   arg4 = (float)jarg4;
43908   arg5 = (float)jarg5;
43909   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43910   if (!arg6) {
43911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43912     return 0;
43913   }
43914   {
43915     try {
43916       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43917     } CALL_CATCH_EXCEPTION(0);
43918   }
43919
43920   jresult = result;
43921   return jresult;
43922 }
43923
43924
43925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43926   void * jresult ;
43927   Dali::Toolkit::DefaultRuler *result = 0 ;
43928
43929   {
43930     try {
43931       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43932     } CALL_CATCH_EXCEPTION(0);
43933   }
43934
43935   jresult = (void *)result;
43936   return jresult;
43937 }
43938
43939
43940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43941   float jresult ;
43942   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43943   float arg2 ;
43944   float arg3 ;
43945   float result;
43946
43947   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43948   arg2 = (float)jarg2;
43949   arg3 = (float)jarg3;
43950   {
43951     try {
43952       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
43953     } CALL_CATCH_EXCEPTION(0);
43954   }
43955
43956   jresult = result;
43957   return jresult;
43958 }
43959
43960
43961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43962   float jresult ;
43963   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43964   unsigned int arg2 ;
43965   unsigned int *arg3 = 0 ;
43966   bool arg4 ;
43967   float result;
43968
43969   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43970   arg2 = (unsigned int)jarg2;
43971   arg3 = (unsigned int *)jarg3;
43972   arg4 = jarg4 ? true : false;
43973   {
43974     try {
43975       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43976     } CALL_CATCH_EXCEPTION(0);
43977   }
43978
43979   jresult = result;
43980   return jresult;
43981 }
43982
43983
43984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43985   unsigned int jresult ;
43986   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43987   float arg2 ;
43988   bool arg3 ;
43989   unsigned int result;
43990
43991   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43992   arg2 = (float)jarg2;
43993   arg3 = jarg3 ? true : false;
43994   {
43995     try {
43996       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43997     } CALL_CATCH_EXCEPTION(0);
43998   }
43999
44000   jresult = result;
44001   return jresult;
44002 }
44003
44004
44005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
44006   unsigned int jresult ;
44007   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44008   unsigned int result;
44009
44010   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44011   {
44012     try {
44013       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
44014     } CALL_CATCH_EXCEPTION(0);
44015   }
44016
44017   jresult = result;
44018   return jresult;
44019 }
44020
44021
44022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
44023   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44024
44025   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44026   {
44027     try {
44028       delete arg1;
44029     } CALL_CATCH_EXCEPTION();
44030   }
44031
44032 }
44033
44034
44035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
44036   void * jresult ;
44037   float arg1 ;
44038   Dali::Toolkit::FixedRuler *result = 0 ;
44039
44040   arg1 = (float)jarg1;
44041   {
44042     try {
44043       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
44044     } CALL_CATCH_EXCEPTION(0);
44045   }
44046
44047   jresult = (void *)result;
44048   return jresult;
44049 }
44050
44051
44052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
44053   void * jresult ;
44054   Dali::Toolkit::FixedRuler *result = 0 ;
44055
44056   {
44057     try {
44058       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
44059     } CALL_CATCH_EXCEPTION(0);
44060   }
44061
44062   jresult = (void *)result;
44063   return jresult;
44064 }
44065
44066
44067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44068   float jresult ;
44069   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44070   float arg2 ;
44071   float arg3 ;
44072   float result;
44073
44074   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44075   arg2 = (float)jarg2;
44076   arg3 = (float)jarg3;
44077   {
44078     try {
44079       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
44080     } CALL_CATCH_EXCEPTION(0);
44081   }
44082
44083   jresult = result;
44084   return jresult;
44085 }
44086
44087
44088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44089   float jresult ;
44090   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44091   unsigned int arg2 ;
44092   unsigned int *arg3 = 0 ;
44093   bool arg4 ;
44094   float result;
44095
44096   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44097   arg2 = (unsigned int)jarg2;
44098   arg3 = (unsigned int *)jarg3;
44099   arg4 = jarg4 ? true : false;
44100   {
44101     try {
44102       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44103     } CALL_CATCH_EXCEPTION(0);
44104   }
44105
44106   jresult = result;
44107   return jresult;
44108 }
44109
44110
44111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44112   unsigned int jresult ;
44113   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44114   float arg2 ;
44115   bool arg3 ;
44116   unsigned int result;
44117
44118   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44119   arg2 = (float)jarg2;
44120   arg3 = jarg3 ? true : false;
44121   {
44122     try {
44123       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44124     } CALL_CATCH_EXCEPTION(0);
44125   }
44126
44127   jresult = result;
44128   return jresult;
44129 }
44130
44131
44132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
44133   unsigned int jresult ;
44134   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44135   unsigned int result;
44136
44137   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44138   {
44139     try {
44140       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
44141     } CALL_CATCH_EXCEPTION(0);
44142   }
44143
44144   jresult = result;
44145   return jresult;
44146 }
44147
44148
44149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
44150   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44151
44152   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44153   {
44154     try {
44155       delete arg1;
44156     } CALL_CATCH_EXCEPTION();
44157   }
44158
44159 }
44160
44161
44162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
44163   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44164   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44165
44166   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44167   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44168   if (arg1) (arg1)->scale = *arg2;
44169 }
44170
44171
44172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
44173   void * jresult ;
44174   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44175   Dali::Toolkit::ClampState2D *result = 0 ;
44176
44177   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44178   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
44179   jresult = (void *)result;
44180   return jresult;
44181 }
44182
44183
44184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44185   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44186   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44187
44188   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44189   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44190   if (arg1) (arg1)->position = *arg2;
44191 }
44192
44193
44194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44195   void * jresult ;
44196   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44197   Dali::Toolkit::ClampState2D *result = 0 ;
44198
44199   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44200   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44201   jresult = (void *)result;
44202   return jresult;
44203 }
44204
44205
44206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44207   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44208   Dali::Toolkit::ClampState arg2 ;
44209
44210   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44211   arg2 = (Dali::Toolkit::ClampState)jarg2;
44212   if (arg1) (arg1)->rotation = arg2;
44213 }
44214
44215
44216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44217   int jresult ;
44218   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44219   Dali::Toolkit::ClampState result;
44220
44221   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44222   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44223   jresult = (int)result;
44224   return jresult;
44225 }
44226
44227
44228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44229   void * jresult ;
44230   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44231
44232   {
44233     try {
44234       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44235     } CALL_CATCH_EXCEPTION(0);
44236   }
44237
44238   jresult = (void *)result;
44239   return jresult;
44240 }
44241
44242
44243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44244   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44245
44246   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44247   {
44248     try {
44249       delete arg1;
44250     } CALL_CATCH_EXCEPTION();
44251   }
44252
44253 }
44254
44255
44256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44257   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44258   Dali::Toolkit::SnapType arg2 ;
44259
44260   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44261   arg2 = (Dali::Toolkit::SnapType)jarg2;
44262   if (arg1) (arg1)->type = arg2;
44263 }
44264
44265
44266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44267   int jresult ;
44268   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44269   Dali::Toolkit::SnapType result;
44270
44271   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44272   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44273   jresult = (int)result;
44274   return jresult;
44275 }
44276
44277
44278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44279   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44280   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44281
44282   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44283   arg2 = (Dali::Vector2 *)jarg2;
44284   if (arg1) (arg1)->position = *arg2;
44285 }
44286
44287
44288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44289   void * jresult ;
44290   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44291   Dali::Vector2 *result = 0 ;
44292
44293   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44294   result = (Dali::Vector2 *)& ((arg1)->position);
44295   jresult = (void *)result;
44296   return jresult;
44297 }
44298
44299
44300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44301   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44302   float arg2 ;
44303
44304   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44305   arg2 = (float)jarg2;
44306   if (arg1) (arg1)->duration = arg2;
44307 }
44308
44309
44310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44311   float jresult ;
44312   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44313   float result;
44314
44315   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44316   result = (float) ((arg1)->duration);
44317   jresult = result;
44318   return jresult;
44319 }
44320
44321
44322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44323   void * jresult ;
44324   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44325
44326   {
44327     try {
44328       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44329     } CALL_CATCH_EXCEPTION(0);
44330   }
44331
44332   jresult = (void *)result;
44333   return jresult;
44334 }
44335
44336
44337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44338   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44339
44340   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44341   {
44342     try {
44343       delete arg1;
44344     } CALL_CATCH_EXCEPTION();
44345   }
44346
44347 }
44348
44349
44350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44351   int jresult ;
44352   int result;
44353
44354   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44355   jresult = (int)result;
44356   return jresult;
44357 }
44358
44359
44360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44361   int jresult ;
44362   int result;
44363
44364   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44365   jresult = (int)result;
44366   return jresult;
44367 }
44368
44369
44370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44371   int jresult ;
44372   int result;
44373
44374   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44375   jresult = (int)result;
44376   return jresult;
44377 }
44378
44379
44380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44381   int jresult ;
44382   int result;
44383
44384   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44385   jresult = (int)result;
44386   return jresult;
44387 }
44388
44389
44390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44391   int jresult ;
44392   int result;
44393
44394   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44395   jresult = (int)result;
44396   return jresult;
44397 }
44398
44399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44400   int jresult ;
44401   int result;
44402
44403   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44404   jresult = (int)result;
44405   return jresult;
44406 }
44407
44408
44409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44410   int jresult ;
44411   int result;
44412
44413   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44414   jresult = (int)result;
44415   return jresult;
44416 }
44417
44418
44419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44420   int jresult ;
44421   int result;
44422
44423   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44424   jresult = (int)result;
44425   return jresult;
44426 }
44427
44428
44429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44430   int jresult ;
44431   int result;
44432
44433   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44434   jresult = (int)result;
44435   return jresult;
44436 }
44437
44438
44439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44440   int jresult ;
44441   int result;
44442
44443   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44444   jresult = (int)result;
44445   return jresult;
44446 }
44447
44448
44449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44450   int jresult ;
44451   int result;
44452
44453   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44454   jresult = (int)result;
44455   return jresult;
44456 }
44457
44458
44459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44460   int jresult ;
44461   int result;
44462
44463   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44464   jresult = (int)result;
44465   return jresult;
44466 }
44467
44468
44469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44470   int jresult ;
44471   int result;
44472
44473   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44474   jresult = (int)result;
44475   return jresult;
44476 }
44477
44478
44479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44480   int jresult ;
44481   int result;
44482
44483   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44484   jresult = (int)result;
44485   return jresult;
44486 }
44487
44488
44489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44490   int jresult ;
44491   int result;
44492
44493   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44494   jresult = (int)result;
44495   return jresult;
44496 }
44497
44498
44499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44500   int jresult ;
44501   int result;
44502
44503   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44504   jresult = (int)result;
44505   return jresult;
44506 }
44507
44508
44509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44510   int jresult ;
44511   int result;
44512
44513   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44514   jresult = (int)result;
44515   return jresult;
44516 }
44517
44518
44519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44520   int jresult ;
44521   int result;
44522
44523   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44524   jresult = (int)result;
44525   return jresult;
44526 }
44527
44528
44529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44530   int jresult ;
44531   int result;
44532
44533   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44534   jresult = (int)result;
44535   return jresult;
44536 }
44537
44538
44539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44540   int jresult ;
44541   int result;
44542
44543   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44544   jresult = (int)result;
44545   return jresult;
44546 }
44547
44548
44549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44550   int jresult ;
44551   int result;
44552
44553   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44554   jresult = (int)result;
44555   return jresult;
44556 }
44557
44558
44559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44560   int jresult ;
44561   int result;
44562
44563   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44564   jresult = (int)result;
44565   return jresult;
44566 }
44567
44568
44569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44570   int jresult ;
44571   int result;
44572
44573   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44574   jresult = (int)result;
44575   return jresult;
44576 }
44577
44578
44579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44580   int jresult ;
44581   int result;
44582
44583   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44584   jresult = (int)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44590   int jresult ;
44591   int result;
44592
44593   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44594   jresult = (int)result;
44595   return jresult;
44596 }
44597
44598
44599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44600   int jresult ;
44601   int result;
44602
44603   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44604   jresult = (int)result;
44605   return jresult;
44606 }
44607
44608
44609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44610   void * jresult ;
44611   Dali::Toolkit::ScrollView::Property *result = 0 ;
44612
44613   {
44614     try {
44615       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44616     } CALL_CATCH_EXCEPTION(0);
44617   }
44618
44619   jresult = (void *)result;
44620   return jresult;
44621 }
44622
44623
44624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44625   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44626
44627   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44628   {
44629     try {
44630       delete arg1;
44631     } CALL_CATCH_EXCEPTION();
44632   }
44633
44634 }
44635
44636
44637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44638   void * jresult ;
44639   Dali::Toolkit::ScrollView *result = 0 ;
44640
44641   {
44642     try {
44643       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44644     } CALL_CATCH_EXCEPTION(0);
44645   }
44646
44647   jresult = (void *)result;
44648   return jresult;
44649 }
44650
44651
44652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44653   void * jresult ;
44654   Dali::Toolkit::ScrollView *arg1 = 0 ;
44655   Dali::Toolkit::ScrollView *result = 0 ;
44656
44657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44658   if (!arg1) {
44659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44660     return 0;
44661   }
44662   {
44663     try {
44664       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44665     } CALL_CATCH_EXCEPTION(0);
44666   }
44667
44668   jresult = (void *)result;
44669   return jresult;
44670 }
44671
44672
44673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44674   void * jresult ;
44675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44676   Dali::Toolkit::ScrollView *arg2 = 0 ;
44677   Dali::Toolkit::ScrollView *result = 0 ;
44678
44679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44680   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44681   if (!arg2) {
44682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44683     return 0;
44684   }
44685   {
44686     try {
44687       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44688     } CALL_CATCH_EXCEPTION(0);
44689   }
44690
44691   jresult = (void *)result;
44692   return jresult;
44693 }
44694
44695
44696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44697   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44698
44699   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44700   {
44701     try {
44702       delete arg1;
44703     } CALL_CATCH_EXCEPTION();
44704   }
44705
44706 }
44707
44708
44709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44710   void * jresult ;
44711   Dali::Toolkit::ScrollView result;
44712
44713   {
44714     try {
44715       result = Dali::Toolkit::ScrollView::New();
44716     } CALL_CATCH_EXCEPTION(0);
44717   }
44718
44719   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44720   return jresult;
44721 }
44722
44723
44724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44725   void * jresult ;
44726   Dali::BaseHandle arg1 ;
44727   Dali::BaseHandle *argp1 ;
44728   Dali::Toolkit::ScrollView result;
44729
44730   argp1 = (Dali::BaseHandle *)jarg1;
44731   if (!argp1) {
44732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44733     return 0;
44734   }
44735   arg1 = *argp1;
44736   {
44737     try {
44738       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44739     } CALL_CATCH_EXCEPTION(0);
44740   }
44741
44742   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44743   return jresult;
44744 }
44745
44746
44747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44748   void * jresult ;
44749   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44750   Dali::AlphaFunction result;
44751
44752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44753   {
44754     try {
44755       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44756     } CALL_CATCH_EXCEPTION(0);
44757   }
44758
44759   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44760   return jresult;
44761 }
44762
44763
44764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44766   Dali::AlphaFunction arg2 ;
44767   Dali::AlphaFunction *argp2 ;
44768
44769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44770   argp2 = (Dali::AlphaFunction *)jarg2;
44771   if (!argp2) {
44772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44773     return ;
44774   }
44775   arg2 = *argp2;
44776   {
44777     try {
44778       (arg1)->SetScrollSnapAlphaFunction(arg2);
44779     } CALL_CATCH_EXCEPTION();
44780   }
44781
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44786   void * jresult ;
44787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44788   Dali::AlphaFunction result;
44789
44790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44791   {
44792     try {
44793       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44794     } CALL_CATCH_EXCEPTION(0);
44795   }
44796
44797   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44798   return jresult;
44799 }
44800
44801
44802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44804   Dali::AlphaFunction arg2 ;
44805   Dali::AlphaFunction *argp2 ;
44806
44807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44808   argp2 = (Dali::AlphaFunction *)jarg2;
44809   if (!argp2) {
44810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44811     return ;
44812   }
44813   arg2 = *argp2;
44814   {
44815     try {
44816       (arg1)->SetScrollFlickAlphaFunction(arg2);
44817     } CALL_CATCH_EXCEPTION();
44818   }
44819
44820 }
44821
44822
44823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44824   float jresult ;
44825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44826   float result;
44827
44828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44829   {
44830     try {
44831       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44832     } CALL_CATCH_EXCEPTION(0);
44833   }
44834
44835   jresult = result;
44836   return jresult;
44837 }
44838
44839
44840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44842   float arg2 ;
44843
44844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44845   arg2 = (float)jarg2;
44846   {
44847     try {
44848       (arg1)->SetScrollSnapDuration(arg2);
44849     } CALL_CATCH_EXCEPTION();
44850   }
44851
44852 }
44853
44854
44855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44856   float jresult ;
44857   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44858   float result;
44859
44860   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44861   {
44862     try {
44863       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44864     } CALL_CATCH_EXCEPTION(0);
44865   }
44866
44867   jresult = result;
44868   return jresult;
44869 }
44870
44871
44872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44874   float arg2 ;
44875
44876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44877   arg2 = (float)jarg2;
44878   {
44879     try {
44880       (arg1)->SetScrollFlickDuration(arg2);
44881     } CALL_CATCH_EXCEPTION();
44882   }
44883
44884 }
44885
44886
44887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44888   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44889   Dali::Toolkit::RulerPtr arg2 ;
44890   Dali::Toolkit::RulerPtr *argp2 ;
44891
44892   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44893   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44894   if (!argp2) {
44895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44896     return ;
44897   }
44898   arg2 = *argp2;
44899   {
44900     try {
44901       (arg1)->SetRulerX(arg2);
44902     } CALL_CATCH_EXCEPTION();
44903   }
44904
44905 }
44906
44907
44908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44910   Dali::Toolkit::RulerPtr arg2 ;
44911   Dali::Toolkit::RulerPtr *argp2 ;
44912
44913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44914   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44915   if (!argp2) {
44916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44917     return ;
44918   }
44919   arg2 = *argp2;
44920   {
44921     try {
44922       (arg1)->SetRulerY(arg2);
44923     } CALL_CATCH_EXCEPTION();
44924   }
44925
44926 }
44927
44928
44929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44931   bool arg2 ;
44932
44933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44934   arg2 = jarg2 ? true : false;
44935   {
44936     try {
44937       (arg1)->SetScrollSensitive(arg2);
44938     } CALL_CATCH_EXCEPTION();
44939   }
44940
44941 }
44942
44943
44944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
44945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44946   float arg2 ;
44947   float arg3 ;
44948
44949   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44950   arg2 = (float)jarg2;
44951   arg3 = (float)jarg3;
44952   {
44953     try {
44954       (arg1)->SetMaxOvershoot(arg2,arg3);
44955     } CALL_CATCH_EXCEPTION();
44956   }
44957
44958 }
44959
44960
44961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
44962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44963   Dali::AlphaFunction arg2 ;
44964   Dali::AlphaFunction *argp2 ;
44965
44966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44967   argp2 = (Dali::AlphaFunction *)jarg2;
44968   if (!argp2) {
44969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44970     return ;
44971   }
44972   arg2 = *argp2;
44973   {
44974     try {
44975       (arg1)->SetSnapOvershootAlphaFunction(arg2);
44976     } CALL_CATCH_EXCEPTION();
44977   }
44978
44979 }
44980
44981
44982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
44983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44984   float arg2 ;
44985
44986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44987   arg2 = (float)jarg2;
44988   {
44989     try {
44990       (arg1)->SetSnapOvershootDuration(arg2);
44991     } CALL_CATCH_EXCEPTION();
44992   }
44993
44994 }
44995
44996
44997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
44998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44999   bool arg2 ;
45000
45001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45002   arg2 = jarg2 ? true : false;
45003   {
45004     try {
45005       (arg1)->SetActorAutoSnap(arg2);
45006     } CALL_CATCH_EXCEPTION();
45007   }
45008
45009 }
45010
45011
45012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
45013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45014   bool arg2 ;
45015
45016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45017   arg2 = jarg2 ? true : false;
45018   {
45019     try {
45020       (arg1)->SetWrapMode(arg2);
45021     } CALL_CATCH_EXCEPTION();
45022   }
45023
45024 }
45025
45026
45027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
45028   int jresult ;
45029   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45030   int result;
45031
45032   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45033   {
45034     try {
45035       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
45036     } CALL_CATCH_EXCEPTION(0);
45037   }
45038
45039   jresult = result;
45040   return jresult;
45041 }
45042
45043
45044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
45045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45046   int arg2 ;
45047
45048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45049   arg2 = (int)jarg2;
45050   {
45051     try {
45052       (arg1)->SetScrollUpdateDistance(arg2);
45053     } CALL_CATCH_EXCEPTION();
45054   }
45055
45056 }
45057
45058
45059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
45060   unsigned int jresult ;
45061   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45062   bool result;
45063
45064   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45065   {
45066     try {
45067       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
45068     } CALL_CATCH_EXCEPTION(0);
45069   }
45070
45071   jresult = result;
45072   return jresult;
45073 }
45074
45075
45076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
45077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45078   bool arg2 ;
45079
45080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45081   arg2 = jarg2 ? true : false;
45082   {
45083     try {
45084       (arg1)->SetAxisAutoLock(arg2);
45085     } CALL_CATCH_EXCEPTION();
45086   }
45087
45088 }
45089
45090
45091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
45092   float jresult ;
45093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45094   float result;
45095
45096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45097   {
45098     try {
45099       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
45100     } CALL_CATCH_EXCEPTION(0);
45101   }
45102
45103   jresult = result;
45104   return jresult;
45105 }
45106
45107
45108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
45109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45110   float arg2 ;
45111
45112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45113   arg2 = (float)jarg2;
45114   {
45115     try {
45116       (arg1)->SetAxisAutoLockGradient(arg2);
45117     } CALL_CATCH_EXCEPTION();
45118   }
45119
45120 }
45121
45122
45123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
45124   float jresult ;
45125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45126   float result;
45127
45128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45129   {
45130     try {
45131       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
45132     } CALL_CATCH_EXCEPTION(0);
45133   }
45134
45135   jresult = result;
45136   return jresult;
45137 }
45138
45139
45140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
45141   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45142   float arg2 ;
45143
45144   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45145   arg2 = (float)jarg2;
45146   {
45147     try {
45148       (arg1)->SetFrictionCoefficient(arg2);
45149     } CALL_CATCH_EXCEPTION();
45150   }
45151
45152 }
45153
45154
45155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
45156   float jresult ;
45157   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45158   float result;
45159
45160   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45161   {
45162     try {
45163       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
45164     } CALL_CATCH_EXCEPTION(0);
45165   }
45166
45167   jresult = result;
45168   return jresult;
45169 }
45170
45171
45172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
45173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45174   float arg2 ;
45175
45176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45177   arg2 = (float)jarg2;
45178   {
45179     try {
45180       (arg1)->SetFlickSpeedCoefficient(arg2);
45181     } CALL_CATCH_EXCEPTION();
45182   }
45183
45184 }
45185
45186
45187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45188   void * jresult ;
45189   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45190   Dali::Vector2 result;
45191
45192   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45193   {
45194     try {
45195       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45196     } CALL_CATCH_EXCEPTION(0);
45197   }
45198
45199   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45200   return jresult;
45201 }
45202
45203
45204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45205   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45206   Dali::Vector2 *arg2 = 0 ;
45207
45208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45209   arg2 = (Dali::Vector2 *)jarg2;
45210   if (!arg2) {
45211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45212     return ;
45213   }
45214   {
45215     try {
45216       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45217     } CALL_CATCH_EXCEPTION();
45218   }
45219
45220 }
45221
45222
45223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45224   float jresult ;
45225   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45226   float result;
45227
45228   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45229   {
45230     try {
45231       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45232     } CALL_CATCH_EXCEPTION(0);
45233   }
45234
45235   jresult = result;
45236   return jresult;
45237 }
45238
45239
45240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45242   float arg2 ;
45243
45244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45245   arg2 = (float)jarg2;
45246   {
45247     try {
45248       (arg1)->SetMinimumSpeedForFlick(arg2);
45249     } CALL_CATCH_EXCEPTION();
45250   }
45251
45252 }
45253
45254
45255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45256   float jresult ;
45257   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45258   float result;
45259
45260   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45261   {
45262     try {
45263       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45264     } CALL_CATCH_EXCEPTION(0);
45265   }
45266
45267   jresult = result;
45268   return jresult;
45269 }
45270
45271
45272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45274   float arg2 ;
45275
45276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45277   arg2 = (float)jarg2;
45278   {
45279     try {
45280       (arg1)->SetMaxFlickSpeed(arg2);
45281     } CALL_CATCH_EXCEPTION();
45282   }
45283
45284 }
45285
45286
45287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45288   void * jresult ;
45289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45290   Dali::Vector2 result;
45291
45292   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45293   {
45294     try {
45295       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45296     } CALL_CATCH_EXCEPTION(0);
45297   }
45298
45299   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45300   return jresult;
45301 }
45302
45303
45304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45306   Dali::Vector2 arg2 ;
45307   Dali::Vector2 *argp2 ;
45308
45309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45310   argp2 = (Dali::Vector2 *)jarg2;
45311   if (!argp2) {
45312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45313     return ;
45314   }
45315   arg2 = *argp2;
45316   {
45317     try {
45318       (arg1)->SetWheelScrollDistanceStep(arg2);
45319     } CALL_CATCH_EXCEPTION();
45320   }
45321
45322 }
45323
45324
45325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45326   void * jresult ;
45327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45328   Dali::Vector2 result;
45329
45330   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45331   {
45332     try {
45333       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45334     } CALL_CATCH_EXCEPTION(0);
45335   }
45336
45337   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45338   return jresult;
45339 }
45340
45341
45342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45343   unsigned int jresult ;
45344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45345   unsigned int result;
45346
45347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45348   {
45349     try {
45350       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45351     } CALL_CATCH_EXCEPTION(0);
45352   }
45353
45354   jresult = result;
45355   return jresult;
45356 }
45357
45358
45359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45361   Dali::Vector2 *arg2 = 0 ;
45362
45363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45364   arg2 = (Dali::Vector2 *)jarg2;
45365   if (!arg2) {
45366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45367     return ;
45368   }
45369   {
45370     try {
45371       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45372     } CALL_CATCH_EXCEPTION();
45373   }
45374
45375 }
45376
45377
45378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45380   Dali::Vector2 *arg2 = 0 ;
45381   float arg3 ;
45382
45383   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45384   arg2 = (Dali::Vector2 *)jarg2;
45385   if (!arg2) {
45386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45387     return ;
45388   }
45389   arg3 = (float)jarg3;
45390   {
45391     try {
45392       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45393     } CALL_CATCH_EXCEPTION();
45394   }
45395
45396 }
45397
45398
45399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45401   Dali::Vector2 *arg2 = 0 ;
45402   float arg3 ;
45403   Dali::AlphaFunction arg4 ;
45404   Dali::AlphaFunction *argp4 ;
45405
45406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45407   arg2 = (Dali::Vector2 *)jarg2;
45408   if (!arg2) {
45409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45410     return ;
45411   }
45412   arg3 = (float)jarg3;
45413   argp4 = (Dali::AlphaFunction *)jarg4;
45414   if (!argp4) {
45415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45416     return ;
45417   }
45418   arg4 = *argp4;
45419   {
45420     try {
45421       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45422     } CALL_CATCH_EXCEPTION();
45423   }
45424
45425 }
45426
45427
45428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45430   Dali::Vector2 *arg2 = 0 ;
45431   float arg3 ;
45432   Dali::Toolkit::DirectionBias arg4 ;
45433   Dali::Toolkit::DirectionBias arg5 ;
45434
45435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45436   arg2 = (Dali::Vector2 *)jarg2;
45437   if (!arg2) {
45438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45439     return ;
45440   }
45441   arg3 = (float)jarg3;
45442   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45443   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45444   {
45445     try {
45446       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45447     } CALL_CATCH_EXCEPTION();
45448   }
45449
45450 }
45451
45452
45453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45454   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45455   Dali::Vector2 *arg2 = 0 ;
45456   float arg3 ;
45457   Dali::AlphaFunction arg4 ;
45458   Dali::Toolkit::DirectionBias arg5 ;
45459   Dali::Toolkit::DirectionBias arg6 ;
45460   Dali::AlphaFunction *argp4 ;
45461
45462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45463   arg2 = (Dali::Vector2 *)jarg2;
45464   if (!arg2) {
45465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45466     return ;
45467   }
45468   arg3 = (float)jarg3;
45469   argp4 = (Dali::AlphaFunction *)jarg4;
45470   if (!argp4) {
45471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45472     return ;
45473   }
45474   arg4 = *argp4;
45475   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45476   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45477   {
45478     try {
45479       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45480     } CALL_CATCH_EXCEPTION();
45481   }
45482
45483 }
45484
45485
45486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45488   unsigned int arg2 ;
45489
45490   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45491   arg2 = (unsigned int)jarg2;
45492   {
45493     try {
45494       (arg1)->ScrollTo(arg2);
45495     } CALL_CATCH_EXCEPTION();
45496   }
45497
45498 }
45499
45500
45501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45502   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45503   unsigned int arg2 ;
45504   float arg3 ;
45505
45506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45507   arg2 = (unsigned int)jarg2;
45508   arg3 = (float)jarg3;
45509   {
45510     try {
45511       (arg1)->ScrollTo(arg2,arg3);
45512     } CALL_CATCH_EXCEPTION();
45513   }
45514
45515 }
45516
45517
45518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45519   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45520   unsigned int arg2 ;
45521   float arg3 ;
45522   Dali::Toolkit::DirectionBias arg4 ;
45523
45524   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45525   arg2 = (unsigned int)jarg2;
45526   arg3 = (float)jarg3;
45527   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45528   {
45529     try {
45530       (arg1)->ScrollTo(arg2,arg3,arg4);
45531     } CALL_CATCH_EXCEPTION();
45532   }
45533
45534 }
45535
45536
45537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45539   Dali::Actor *arg2 = 0 ;
45540
45541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45542   arg2 = (Dali::Actor *)jarg2;
45543   if (!arg2) {
45544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45545     return ;
45546   }
45547   {
45548     try {
45549       (arg1)->ScrollTo(*arg2);
45550     } CALL_CATCH_EXCEPTION();
45551   }
45552
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45558   Dali::Actor *arg2 = 0 ;
45559   float arg3 ;
45560
45561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45562   arg2 = (Dali::Actor *)jarg2;
45563   if (!arg2) {
45564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45565     return ;
45566   }
45567   arg3 = (float)jarg3;
45568   {
45569     try {
45570       (arg1)->ScrollTo(*arg2,arg3);
45571     } CALL_CATCH_EXCEPTION();
45572   }
45573
45574 }
45575
45576
45577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45578   unsigned int jresult ;
45579   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45580   bool result;
45581
45582   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45583   {
45584     try {
45585       result = (bool)(arg1)->ScrollToSnapPoint();
45586     } CALL_CATCH_EXCEPTION(0);
45587   }
45588
45589   jresult = result;
45590   return jresult;
45591 }
45592
45593
45594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45595   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45596   Dali::Constraint arg2 ;
45597   Dali::Constraint *argp2 ;
45598
45599   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45600   argp2 = (Dali::Constraint *)jarg2;
45601   if (!argp2) {
45602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45603     return ;
45604   }
45605   arg2 = *argp2;
45606   {
45607     try {
45608       (arg1)->ApplyConstraintToChildren(arg2);
45609     } CALL_CATCH_EXCEPTION();
45610   }
45611
45612 }
45613
45614
45615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45616   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45617
45618   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45619   {
45620     try {
45621       (arg1)->RemoveConstraintsFromChildren();
45622     } CALL_CATCH_EXCEPTION();
45623   }
45624
45625 }
45626
45627
45628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45630   Dali::Toolkit::ScrollViewEffect arg2 ;
45631   Dali::Toolkit::ScrollViewEffect *argp2 ;
45632
45633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45634   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45635   if (!argp2) {
45636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45637     return ;
45638   }
45639   arg2 = *argp2;
45640   {
45641     try {
45642       (arg1)->ApplyEffect(arg2);
45643     } CALL_CATCH_EXCEPTION();
45644   }
45645
45646 }
45647
45648
45649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45651   Dali::Toolkit::ScrollViewEffect arg2 ;
45652   Dali::Toolkit::ScrollViewEffect *argp2 ;
45653
45654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45655   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45656   if (!argp2) {
45657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45658     return ;
45659   }
45660   arg2 = *argp2;
45661   {
45662     try {
45663       (arg1)->RemoveEffect(arg2);
45664     } CALL_CATCH_EXCEPTION();
45665   }
45666
45667 }
45668
45669
45670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45672
45673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45674   {
45675     try {
45676       (arg1)->RemoveAllEffects();
45677     } CALL_CATCH_EXCEPTION();
45678   }
45679
45680 }
45681
45682
45683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45685   Dali::Actor arg2 ;
45686   Dali::Actor *argp2 ;
45687
45688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45689   argp2 = (Dali::Actor *)jarg2;
45690   if (!argp2) {
45691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45692     return ;
45693   }
45694   arg2 = *argp2;
45695   {
45696     try {
45697       (arg1)->BindActor(arg2);
45698     } CALL_CATCH_EXCEPTION();
45699   }
45700
45701 }
45702
45703
45704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45706   Dali::Actor arg2 ;
45707   Dali::Actor *argp2 ;
45708
45709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45710   argp2 = (Dali::Actor *)jarg2;
45711   if (!argp2) {
45712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45713     return ;
45714   }
45715   arg2 = *argp2;
45716   {
45717     try {
45718       (arg1)->UnbindActor(arg2);
45719     } CALL_CATCH_EXCEPTION();
45720   }
45721
45722 }
45723
45724
45725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45727   Dali::Radian arg2 ;
45728   Dali::Radian arg3 ;
45729   Dali::Radian *argp2 ;
45730   Dali::Radian *argp3 ;
45731
45732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45733   argp2 = (Dali::Radian *)jarg2;
45734   if (!argp2) {
45735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45736     return ;
45737   }
45738   arg2 = *argp2;
45739   argp3 = (Dali::Radian *)jarg3;
45740   if (!argp3) {
45741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45742     return ;
45743   }
45744   arg3 = *argp3;
45745   {
45746     try {
45747       (arg1)->SetScrollingDirection(arg2,arg3);
45748     } CALL_CATCH_EXCEPTION();
45749   }
45750
45751 }
45752
45753
45754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45755   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45756   Dali::Radian arg2 ;
45757   Dali::Radian *argp2 ;
45758
45759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45760   argp2 = (Dali::Radian *)jarg2;
45761   if (!argp2) {
45762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45763     return ;
45764   }
45765   arg2 = *argp2;
45766   {
45767     try {
45768       (arg1)->SetScrollingDirection(arg2);
45769     } CALL_CATCH_EXCEPTION();
45770   }
45771
45772 }
45773
45774
45775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45776   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45777   Dali::Radian arg2 ;
45778   Dali::Radian *argp2 ;
45779
45780   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45781   argp2 = (Dali::Radian *)jarg2;
45782   if (!argp2) {
45783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45784     return ;
45785   }
45786   arg2 = *argp2;
45787   {
45788     try {
45789       (arg1)->RemoveScrollingDirection(arg2);
45790     } CALL_CATCH_EXCEPTION();
45791   }
45792
45793 }
45794
45795
45796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45797   void * jresult ;
45798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45799   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45800
45801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45802   {
45803     try {
45804       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45805     } CALL_CATCH_EXCEPTION(0);
45806   }
45807
45808   jresult = (void *)result;
45809   return jresult;
45810 }
45811
45812
45813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45814   int jresult ;
45815   int result;
45816
45817   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45818   jresult = (int)result;
45819   return jresult;
45820 }
45821
45822
45823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45824   int jresult ;
45825   int result;
45826
45827   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45828   jresult = (int)result;
45829   return jresult;
45830 }
45831
45832
45833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45834   int jresult ;
45835   int result;
45836
45837   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45838   jresult = (int)result;
45839   return jresult;
45840 }
45841
45842
45843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45844   int jresult ;
45845   int result;
45846
45847   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45848   jresult = (int)result;
45849   return jresult;
45850 }
45851
45852
45853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45854   int jresult ;
45855   int result;
45856
45857   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45858   jresult = (int)result;
45859   return jresult;
45860 }
45861
45862
45863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45864   void * jresult ;
45865   Dali::Toolkit::TableView::Property *result = 0 ;
45866
45867   {
45868     try {
45869       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45870     } CALL_CATCH_EXCEPTION(0);
45871   }
45872
45873   jresult = (void *)result;
45874   return jresult;
45875 }
45876
45877
45878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45879   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45880
45881   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45882   {
45883     try {
45884       delete arg1;
45885     } CALL_CATCH_EXCEPTION();
45886   }
45887
45888 }
45889
45890
45891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45892   int jresult ;
45893   int result;
45894
45895   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45896   jresult = (int)result;
45897   return jresult;
45898 }
45899
45900
45901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45902   int jresult ;
45903   int result;
45904
45905   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45906   jresult = (int)result;
45907   return jresult;
45908 }
45909
45910
45911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45912   int jresult ;
45913   int result;
45914
45915   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45916   jresult = (int)result;
45917   return jresult;
45918 }
45919
45920
45921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45922   int jresult ;
45923   int result;
45924
45925   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45926   jresult = (int)result;
45927   return jresult;
45928 }
45929
45930
45931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45932   int jresult ;
45933   int result;
45934
45935   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45936   jresult = (int)result;
45937   return jresult;
45938 }
45939
45940
45941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45942   void * jresult ;
45943   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45944
45945   {
45946     try {
45947       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
45948     } CALL_CATCH_EXCEPTION(0);
45949   }
45950
45951   jresult = (void *)result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
45957   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
45958
45959   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
45960   {
45961     try {
45962       delete arg1;
45963     } CALL_CATCH_EXCEPTION();
45964   }
45965
45966 }
45967
45968
45969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
45970   void * jresult ;
45971   unsigned int arg1 ;
45972   unsigned int arg2 ;
45973   unsigned int arg3 ;
45974   unsigned int arg4 ;
45975   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45976
45977   arg1 = (unsigned int)jarg1;
45978   arg2 = (unsigned int)jarg2;
45979   arg3 = (unsigned int)jarg3;
45980   arg4 = (unsigned int)jarg4;
45981   {
45982     try {
45983       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
45984     } CALL_CATCH_EXCEPTION(0);
45985   }
45986
45987   jresult = (void *)result;
45988   return jresult;
45989 }
45990
45991
45992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
45993   void * jresult ;
45994   unsigned int arg1 ;
45995   unsigned int arg2 ;
45996   unsigned int arg3 ;
45997   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45998
45999   arg1 = (unsigned int)jarg1;
46000   arg2 = (unsigned int)jarg2;
46001   arg3 = (unsigned int)jarg3;
46002   {
46003     try {
46004       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
46005     } CALL_CATCH_EXCEPTION(0);
46006   }
46007
46008   jresult = (void *)result;
46009   return jresult;
46010 }
46011
46012
46013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46014   void * jresult ;
46015   unsigned int arg1 ;
46016   unsigned int arg2 ;
46017   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46018
46019   arg1 = (unsigned int)jarg1;
46020   arg2 = (unsigned int)jarg2;
46021   {
46022     try {
46023       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
46024     } CALL_CATCH_EXCEPTION(0);
46025   }
46026
46027   jresult = (void *)result;
46028   return jresult;
46029 }
46030
46031
46032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
46033   void * jresult ;
46034   unsigned int arg1 ;
46035   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46036
46037   arg1 = (unsigned int)jarg1;
46038   {
46039     try {
46040       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
46041     } CALL_CATCH_EXCEPTION(0);
46042   }
46043
46044   jresult = (void *)result;
46045   return jresult;
46046 }
46047
46048
46049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
46050   void * jresult ;
46051   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46052
46053   {
46054     try {
46055       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
46056     } CALL_CATCH_EXCEPTION(0);
46057   }
46058
46059   jresult = (void *)result;
46060   return jresult;
46061 }
46062
46063
46064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
46065   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46066   unsigned int arg2 ;
46067
46068   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46069   arg2 = (unsigned int)jarg2;
46070   if (arg1) (arg1)->rowIndex = arg2;
46071 }
46072
46073
46074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
46075   unsigned int jresult ;
46076   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46077   unsigned int result;
46078
46079   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46080   result = (unsigned int) ((arg1)->rowIndex);
46081   jresult = result;
46082   return jresult;
46083 }
46084
46085
46086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
46087   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46088   unsigned int arg2 ;
46089
46090   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46091   arg2 = (unsigned int)jarg2;
46092   if (arg1) (arg1)->columnIndex = arg2;
46093 }
46094
46095
46096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
46097   unsigned int jresult ;
46098   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46099   unsigned int result;
46100
46101   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46102   result = (unsigned int) ((arg1)->columnIndex);
46103   jresult = result;
46104   return jresult;
46105 }
46106
46107
46108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
46109   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46110   unsigned int arg2 ;
46111
46112   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46113   arg2 = (unsigned int)jarg2;
46114   if (arg1) (arg1)->rowSpan = arg2;
46115 }
46116
46117
46118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
46119   unsigned int jresult ;
46120   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46121   unsigned int result;
46122
46123   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46124   result = (unsigned int) ((arg1)->rowSpan);
46125   jresult = result;
46126   return jresult;
46127 }
46128
46129
46130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
46131   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46132   unsigned int arg2 ;
46133
46134   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46135   arg2 = (unsigned int)jarg2;
46136   if (arg1) (arg1)->columnSpan = arg2;
46137 }
46138
46139
46140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
46141   unsigned int jresult ;
46142   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46143   unsigned int result;
46144
46145   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46146   result = (unsigned int) ((arg1)->columnSpan);
46147   jresult = result;
46148   return jresult;
46149 }
46150
46151
46152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
46153   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46154
46155   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46156   {
46157     try {
46158       delete arg1;
46159     } CALL_CATCH_EXCEPTION();
46160   }
46161
46162 }
46163
46164
46165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
46166   void * jresult ;
46167   Dali::Toolkit::TableView *result = 0 ;
46168
46169   {
46170     try {
46171       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
46172     } CALL_CATCH_EXCEPTION(0);
46173   }
46174
46175   jresult = (void *)result;
46176   return jresult;
46177 }
46178
46179
46180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
46181   void * jresult ;
46182   Dali::Toolkit::TableView *arg1 = 0 ;
46183   Dali::Toolkit::TableView *result = 0 ;
46184
46185   arg1 = (Dali::Toolkit::TableView *)jarg1;
46186   if (!arg1) {
46187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46188     return 0;
46189   }
46190   {
46191     try {
46192       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46193     } CALL_CATCH_EXCEPTION(0);
46194   }
46195
46196   jresult = (void *)result;
46197   return jresult;
46198 }
46199
46200
46201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46202   void * jresult ;
46203   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46204   Dali::Toolkit::TableView *arg2 = 0 ;
46205   Dali::Toolkit::TableView *result = 0 ;
46206
46207   arg1 = (Dali::Toolkit::TableView *)jarg1;
46208   arg2 = (Dali::Toolkit::TableView *)jarg2;
46209   if (!arg2) {
46210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46211     return 0;
46212   }
46213   {
46214     try {
46215       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46216     } CALL_CATCH_EXCEPTION(0);
46217   }
46218
46219   jresult = (void *)result;
46220   return jresult;
46221 }
46222
46223
46224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46226
46227   arg1 = (Dali::Toolkit::TableView *)jarg1;
46228   {
46229     try {
46230       delete arg1;
46231     } CALL_CATCH_EXCEPTION();
46232   }
46233
46234 }
46235
46236
46237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46238   void * jresult ;
46239   unsigned int arg1 ;
46240   unsigned int arg2 ;
46241   Dali::Toolkit::TableView result;
46242
46243   arg1 = (unsigned int)jarg1;
46244   arg2 = (unsigned int)jarg2;
46245   {
46246     try {
46247       result = Dali::Toolkit::TableView::New(arg1,arg2);
46248     } CALL_CATCH_EXCEPTION(0);
46249   }
46250
46251   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46252   return jresult;
46253 }
46254
46255
46256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46257   void * jresult ;
46258   Dali::BaseHandle arg1 ;
46259   Dali::BaseHandle *argp1 ;
46260   Dali::Toolkit::TableView result;
46261
46262   argp1 = (Dali::BaseHandle *)jarg1;
46263   if (!argp1) {
46264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46265     return 0;
46266   }
46267   arg1 = *argp1;
46268   {
46269     try {
46270       result = Dali::Toolkit::TableView::DownCast(arg1);
46271     } CALL_CATCH_EXCEPTION(0);
46272   }
46273
46274   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46275   return jresult;
46276 }
46277
46278
46279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46280   unsigned int jresult ;
46281   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46282   Dali::Actor arg2 ;
46283   Dali::Toolkit::TableView::CellPosition arg3 ;
46284   Dali::Actor *argp2 ;
46285   Dali::Toolkit::TableView::CellPosition *argp3 ;
46286   bool result;
46287
46288   arg1 = (Dali::Toolkit::TableView *)jarg1;
46289   argp2 = (Dali::Actor *)jarg2;
46290   if (!argp2) {
46291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46292     return 0;
46293   }
46294   arg2 = *argp2;
46295   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46296   if (!argp3) {
46297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46298     return 0;
46299   }
46300   arg3 = *argp3;
46301   {
46302     try {
46303       result = (bool)(arg1)->AddChild(arg2,arg3);
46304     } CALL_CATCH_EXCEPTION(0);
46305   }
46306
46307   jresult = result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46313   void * jresult ;
46314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46315   Dali::Toolkit::TableView::CellPosition arg2 ;
46316   Dali::Toolkit::TableView::CellPosition *argp2 ;
46317   Dali::Actor result;
46318
46319   arg1 = (Dali::Toolkit::TableView *)jarg1;
46320   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46321   if (!argp2) {
46322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46323     return 0;
46324   }
46325   arg2 = *argp2;
46326   {
46327     try {
46328       result = (arg1)->GetChildAt(arg2);
46329     } CALL_CATCH_EXCEPTION(0);
46330   }
46331
46332   jresult = new Dali::Actor((const Dali::Actor &)result);
46333   return jresult;
46334 }
46335
46336
46337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46338   void * jresult ;
46339   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46340   Dali::Toolkit::TableView::CellPosition arg2 ;
46341   Dali::Toolkit::TableView::CellPosition *argp2 ;
46342   Dali::Actor result;
46343
46344   arg1 = (Dali::Toolkit::TableView *)jarg1;
46345   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46346   if (!argp2) {
46347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46348     return 0;
46349   }
46350   arg2 = *argp2;
46351   {
46352     try {
46353       result = (arg1)->RemoveChildAt(arg2);
46354     } CALL_CATCH_EXCEPTION(0);
46355   }
46356
46357   jresult = new Dali::Actor((const Dali::Actor &)result);
46358   return jresult;
46359 }
46360
46361
46362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46363   unsigned int jresult ;
46364   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46365   Dali::Actor arg2 ;
46366   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46367   Dali::Actor *argp2 ;
46368   bool result;
46369
46370   arg1 = (Dali::Toolkit::TableView *)jarg1;
46371   argp2 = (Dali::Actor *)jarg2;
46372   if (!argp2) {
46373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46374     return 0;
46375   }
46376   arg2 = *argp2;
46377   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46378   if (!arg3) {
46379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46380     return 0;
46381   }
46382   {
46383     try {
46384       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46385     } CALL_CATCH_EXCEPTION(0);
46386   }
46387
46388   jresult = result;
46389   return jresult;
46390 }
46391
46392
46393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46395   unsigned int arg2 ;
46396
46397   arg1 = (Dali::Toolkit::TableView *)jarg1;
46398   arg2 = (unsigned int)jarg2;
46399   {
46400     try {
46401       (arg1)->InsertRow(arg2);
46402     } CALL_CATCH_EXCEPTION();
46403   }
46404
46405 }
46406
46407
46408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46409   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46410   unsigned int arg2 ;
46411
46412   arg1 = (Dali::Toolkit::TableView *)jarg1;
46413   arg2 = (unsigned int)jarg2;
46414   {
46415     try {
46416       (arg1)->DeleteRow(arg2);
46417     } CALL_CATCH_EXCEPTION();
46418   }
46419
46420 }
46421
46422
46423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46424   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46425   unsigned int arg2 ;
46426   std::vector< Dali::Actor > *arg3 = 0 ;
46427
46428   arg1 = (Dali::Toolkit::TableView *)jarg1;
46429   arg2 = (unsigned int)jarg2;
46430   arg3 = (std::vector< Dali::Actor > *)jarg3;
46431   if (!arg3) {
46432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46433     return ;
46434   }
46435   {
46436     try {
46437       (arg1)->DeleteRow(arg2,*arg3);
46438     } CALL_CATCH_EXCEPTION();
46439   }
46440
46441 }
46442
46443
46444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46445   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46446   unsigned int arg2 ;
46447
46448   arg1 = (Dali::Toolkit::TableView *)jarg1;
46449   arg2 = (unsigned int)jarg2;
46450   {
46451     try {
46452       (arg1)->InsertColumn(arg2);
46453     } CALL_CATCH_EXCEPTION();
46454   }
46455
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46460   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46461   unsigned int arg2 ;
46462
46463   arg1 = (Dali::Toolkit::TableView *)jarg1;
46464   arg2 = (unsigned int)jarg2;
46465   {
46466     try {
46467       (arg1)->DeleteColumn(arg2);
46468     } CALL_CATCH_EXCEPTION();
46469   }
46470
46471 }
46472
46473
46474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46475   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46476   unsigned int arg2 ;
46477   std::vector< Dali::Actor > *arg3 = 0 ;
46478
46479   arg1 = (Dali::Toolkit::TableView *)jarg1;
46480   arg2 = (unsigned int)jarg2;
46481   arg3 = (std::vector< Dali::Actor > *)jarg3;
46482   if (!arg3) {
46483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46484     return ;
46485   }
46486   {
46487     try {
46488       (arg1)->DeleteColumn(arg2,*arg3);
46489     } CALL_CATCH_EXCEPTION();
46490   }
46491
46492 }
46493
46494
46495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46496   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46497   unsigned int arg2 ;
46498   unsigned int arg3 ;
46499
46500   arg1 = (Dali::Toolkit::TableView *)jarg1;
46501   arg2 = (unsigned int)jarg2;
46502   arg3 = (unsigned int)jarg3;
46503   {
46504     try {
46505       (arg1)->Resize(arg2,arg3);
46506     } CALL_CATCH_EXCEPTION();
46507   }
46508
46509 }
46510
46511
46512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46513   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46514   unsigned int arg2 ;
46515   unsigned int arg3 ;
46516   std::vector< Dali::Actor > *arg4 = 0 ;
46517
46518   arg1 = (Dali::Toolkit::TableView *)jarg1;
46519   arg2 = (unsigned int)jarg2;
46520   arg3 = (unsigned int)jarg3;
46521   arg4 = (std::vector< Dali::Actor > *)jarg4;
46522   if (!arg4) {
46523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46524     return ;
46525   }
46526   {
46527     try {
46528       (arg1)->Resize(arg2,arg3,*arg4);
46529     } CALL_CATCH_EXCEPTION();
46530   }
46531
46532 }
46533
46534
46535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46537   Dali::Size arg2 ;
46538   Dali::Size *argp2 ;
46539
46540   arg1 = (Dali::Toolkit::TableView *)jarg1;
46541   argp2 = (Dali::Size *)jarg2;
46542   if (!argp2) {
46543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46544     return ;
46545   }
46546   arg2 = *argp2;
46547   {
46548     try {
46549       (arg1)->SetCellPadding(arg2);
46550     } CALL_CATCH_EXCEPTION();
46551   }
46552
46553 }
46554
46555
46556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46557   void * jresult ;
46558   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46559   Dali::Size result;
46560
46561   arg1 = (Dali::Toolkit::TableView *)jarg1;
46562   {
46563     try {
46564       result = (arg1)->GetCellPadding();
46565     } CALL_CATCH_EXCEPTION(0);
46566   }
46567
46568   jresult = new Dali::Size((const Dali::Size &)result);
46569   return jresult;
46570 }
46571
46572
46573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46575   unsigned int arg2 ;
46576
46577   arg1 = (Dali::Toolkit::TableView *)jarg1;
46578   arg2 = (unsigned int)jarg2;
46579   {
46580     try {
46581       (arg1)->SetFitHeight(arg2);
46582     } CALL_CATCH_EXCEPTION();
46583   }
46584
46585 }
46586
46587
46588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46589   unsigned int jresult ;
46590   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46591   unsigned int arg2 ;
46592   bool result;
46593
46594   arg1 = (Dali::Toolkit::TableView *)jarg1;
46595   arg2 = (unsigned int)jarg2;
46596   {
46597     try {
46598       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46599     } CALL_CATCH_EXCEPTION(0);
46600   }
46601
46602   jresult = result;
46603   return jresult;
46604 }
46605
46606
46607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46608   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46609   unsigned int arg2 ;
46610
46611   arg1 = (Dali::Toolkit::TableView *)jarg1;
46612   arg2 = (unsigned int)jarg2;
46613   {
46614     try {
46615       (arg1)->SetFitWidth(arg2);
46616     } CALL_CATCH_EXCEPTION();
46617   }
46618
46619 }
46620
46621
46622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46623   unsigned int jresult ;
46624   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46625   unsigned int arg2 ;
46626   bool result;
46627
46628   arg1 = (Dali::Toolkit::TableView *)jarg1;
46629   arg2 = (unsigned int)jarg2;
46630   {
46631     try {
46632       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46633     } CALL_CATCH_EXCEPTION(0);
46634   }
46635
46636   jresult = result;
46637   return jresult;
46638 }
46639
46640
46641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46642   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46643   unsigned int arg2 ;
46644   float arg3 ;
46645
46646   arg1 = (Dali::Toolkit::TableView *)jarg1;
46647   arg2 = (unsigned int)jarg2;
46648   arg3 = (float)jarg3;
46649   {
46650     try {
46651       (arg1)->SetFixedHeight(arg2,arg3);
46652     } CALL_CATCH_EXCEPTION();
46653   }
46654
46655 }
46656
46657
46658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46659   float jresult ;
46660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46661   unsigned int arg2 ;
46662   float result;
46663
46664   arg1 = (Dali::Toolkit::TableView *)jarg1;
46665   arg2 = (unsigned int)jarg2;
46666   {
46667     try {
46668       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46669     } CALL_CATCH_EXCEPTION(0);
46670   }
46671
46672   jresult = result;
46673   return jresult;
46674 }
46675
46676
46677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46678   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46679   unsigned int arg2 ;
46680   float arg3 ;
46681
46682   arg1 = (Dali::Toolkit::TableView *)jarg1;
46683   arg2 = (unsigned int)jarg2;
46684   arg3 = (float)jarg3;
46685   {
46686     try {
46687       (arg1)->SetRelativeHeight(arg2,arg3);
46688     } CALL_CATCH_EXCEPTION();
46689   }
46690
46691 }
46692
46693
46694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
46695   float jresult ;
46696   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46697   unsigned int arg2 ;
46698   float result;
46699
46700   arg1 = (Dali::Toolkit::TableView *)jarg1;
46701   arg2 = (unsigned int)jarg2;
46702   {
46703     try {
46704       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
46705     } CALL_CATCH_EXCEPTION(0);
46706   }
46707
46708   jresult = result;
46709   return jresult;
46710 }
46711
46712
46713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46714   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46715   unsigned int arg2 ;
46716   float arg3 ;
46717
46718   arg1 = (Dali::Toolkit::TableView *)jarg1;
46719   arg2 = (unsigned int)jarg2;
46720   arg3 = (float)jarg3;
46721   {
46722     try {
46723       (arg1)->SetFixedWidth(arg2,arg3);
46724     } CALL_CATCH_EXCEPTION();
46725   }
46726
46727 }
46728
46729
46730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
46731   float jresult ;
46732   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46733   unsigned int arg2 ;
46734   float result;
46735
46736   arg1 = (Dali::Toolkit::TableView *)jarg1;
46737   arg2 = (unsigned int)jarg2;
46738   {
46739     try {
46740       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
46741     } CALL_CATCH_EXCEPTION(0);
46742   }
46743
46744   jresult = result;
46745   return jresult;
46746 }
46747
46748
46749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46750   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46751   unsigned int arg2 ;
46752   float arg3 ;
46753
46754   arg1 = (Dali::Toolkit::TableView *)jarg1;
46755   arg2 = (unsigned int)jarg2;
46756   arg3 = (float)jarg3;
46757   {
46758     try {
46759       (arg1)->SetRelativeWidth(arg2,arg3);
46760     } CALL_CATCH_EXCEPTION();
46761   }
46762
46763 }
46764
46765
46766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
46767   float jresult ;
46768   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46769   unsigned int arg2 ;
46770   float result;
46771
46772   arg1 = (Dali::Toolkit::TableView *)jarg1;
46773   arg2 = (unsigned int)jarg2;
46774   {
46775     try {
46776       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
46777     } CALL_CATCH_EXCEPTION(0);
46778   }
46779
46780   jresult = result;
46781   return jresult;
46782 }
46783
46784
46785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46786   unsigned int jresult ;
46787   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46788   unsigned int result;
46789
46790   arg1 = (Dali::Toolkit::TableView *)jarg1;
46791   {
46792     try {
46793       result = (unsigned int)(arg1)->GetRows();
46794     } CALL_CATCH_EXCEPTION(0);
46795   }
46796
46797   jresult = result;
46798   return jresult;
46799 }
46800
46801
46802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
46803   unsigned int jresult ;
46804   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46805   unsigned int result;
46806
46807   arg1 = (Dali::Toolkit::TableView *)jarg1;
46808   {
46809     try {
46810       result = (unsigned int)(arg1)->GetColumns();
46811     } CALL_CATCH_EXCEPTION(0);
46812   }
46813
46814   jresult = result;
46815   return jresult;
46816 }
46817
46818
46819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46820   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46821   Dali::Toolkit::TableView::CellPosition arg2 ;
46822   Dali::HorizontalAlignment::Type arg3 ;
46823   Dali::VerticalAlignment::Type arg4 ;
46824   Dali::Toolkit::TableView::CellPosition *argp2 ;
46825
46826   arg1 = (Dali::Toolkit::TableView *)jarg1;
46827   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46828   if (!argp2) {
46829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46830     return ;
46831   }
46832   arg2 = *argp2;
46833   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46834   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46835   {
46836     try {
46837       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46838     } CALL_CATCH_EXCEPTION();
46839   }
46840
46841 }
46842
46843
46844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46845   unsigned int jresult ;
46846   unsigned int result;
46847
46848   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46849   jresult = result;
46850   return jresult;
46851 }
46852
46853
46854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46855   int jresult ;
46856   int result;
46857
46858   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46859   jresult = (int)result;
46860   return jresult;
46861 }
46862
46863
46864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46865   int jresult ;
46866   int result;
46867
46868   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46869   jresult = (int)result;
46870   return jresult;
46871 }
46872
46873
46874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46875   int jresult ;
46876   int result;
46877
46878   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46879   jresult = (int)result;
46880   return jresult;
46881 }
46882
46883
46884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46885   int jresult ;
46886   int result;
46887
46888   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46889   jresult = (int)result;
46890   return jresult;
46891 }
46892
46893
46894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46895   int jresult ;
46896   int result;
46897
46898   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46899   jresult = (int)result;
46900   return jresult;
46901 }
46902
46903
46904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46905   int jresult ;
46906   int result;
46907
46908   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46909   jresult = (int)result;
46910   return jresult;
46911 }
46912
46913
46914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46915   int jresult ;
46916   int result;
46917
46918   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46919   jresult = (int)result;
46920   return jresult;
46921 }
46922
46923
46924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46925   int jresult ;
46926   int result;
46927
46928   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46929   jresult = (int)result;
46930   return jresult;
46931 }
46932
46933
46934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46935   int jresult ;
46936   int result;
46937
46938   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46939   jresult = (int)result;
46940   return jresult;
46941 }
46942
46943
46944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
46945   int jresult ;
46946   int result;
46947
46948   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
46949   jresult = (int)result;
46950   return jresult;
46951 }
46952
46953
46954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
46955   int jresult ;
46956   int result;
46957
46958   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
46959   jresult = (int)result;
46960   return jresult;
46961 }
46962
46963
46964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
46965   int jresult ;
46966   int result;
46967
46968   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
46969   jresult = (int)result;
46970   return jresult;
46971 }
46972
46973
46974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
46975   int jresult ;
46976   int result;
46977
46978   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
46979   jresult = (int)result;
46980   return jresult;
46981 }
46982
46983
46984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
46985   int jresult ;
46986   int result;
46987
46988   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
46989   jresult = (int)result;
46990   return jresult;
46991 }
46992
46993
46994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
46995   int jresult ;
46996   int result;
46997
46998   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
46999   jresult = (int)result;
47000   return jresult;
47001 }
47002
47003
47004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
47005   int jresult ;
47006   int result;
47007
47008   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
47009   jresult = (int)result;
47010   return jresult;
47011 }
47012
47013
47014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
47015   int jresult ;
47016   int result;
47017
47018   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
47019   jresult = (int)result;
47020   return jresult;
47021 }
47022
47023
47024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
47025   int jresult ;
47026   int result;
47027
47028   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
47029   jresult = (int)result;
47030   return jresult;
47031 }
47032
47033
47034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
47035   void * jresult ;
47036   Dali::Toolkit::TextLabel::Property *result = 0 ;
47037
47038   {
47039     try {
47040       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
47041     } CALL_CATCH_EXCEPTION(0);
47042   }
47043
47044   jresult = (void *)result;
47045   return jresult;
47046 }
47047
47048
47049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
47050   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
47051
47052   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
47053   {
47054     try {
47055       delete arg1;
47056     } CALL_CATCH_EXCEPTION();
47057   }
47058
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
47063   void * jresult ;
47064   Dali::Toolkit::TextLabel result;
47065
47066   {
47067     try {
47068       result = Dali::Toolkit::TextLabel::New();
47069     } CALL_CATCH_EXCEPTION(0);
47070   }
47071
47072   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47073   return jresult;
47074 }
47075
47076
47077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
47078   void * jresult ;
47079   std::string *arg1 = 0 ;
47080   Dali::Toolkit::TextLabel result;
47081
47082   if (!jarg1) {
47083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47084     return 0;
47085   }
47086   std::string arg1_str(jarg1);
47087   arg1 = &arg1_str;
47088   {
47089     try {
47090       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
47091     } CALL_CATCH_EXCEPTION(0);
47092   }
47093
47094   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47095
47096   //argout typemap for const std::string&
47097
47098   return jresult;
47099 }
47100
47101
47102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
47103   void * jresult ;
47104   Dali::Toolkit::TextLabel *result = 0 ;
47105
47106   {
47107     try {
47108       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
47109     } CALL_CATCH_EXCEPTION(0);
47110   }
47111
47112   jresult = (void *)result;
47113   return jresult;
47114 }
47115
47116
47117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
47118   void * jresult ;
47119   Dali::Toolkit::TextLabel *arg1 = 0 ;
47120   Dali::Toolkit::TextLabel *result = 0 ;
47121
47122   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47123   if (!arg1) {
47124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47125     return 0;
47126   }
47127   {
47128     try {
47129       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
47130     } CALL_CATCH_EXCEPTION(0);
47131   }
47132
47133   jresult = (void *)result;
47134   return jresult;
47135 }
47136
47137
47138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
47139   void * jresult ;
47140   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47141   Dali::Toolkit::TextLabel *arg2 = 0 ;
47142   Dali::Toolkit::TextLabel *result = 0 ;
47143
47144   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47145   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
47146   if (!arg2) {
47147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47148     return 0;
47149   }
47150   {
47151     try {
47152       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
47153     } CALL_CATCH_EXCEPTION(0);
47154   }
47155
47156   jresult = (void *)result;
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
47162   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47163
47164   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47165   {
47166     try {
47167       delete arg1;
47168     } CALL_CATCH_EXCEPTION();
47169   }
47170
47171 }
47172
47173
47174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
47175   void * jresult ;
47176   Dali::BaseHandle arg1 ;
47177   Dali::BaseHandle *argp1 ;
47178   Dali::Toolkit::TextLabel result;
47179
47180   argp1 = (Dali::BaseHandle *)jarg1;
47181   if (!argp1) {
47182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47183     return 0;
47184   }
47185   arg1 = *argp1;
47186   {
47187     try {
47188       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47189     } CALL_CATCH_EXCEPTION(0);
47190   }
47191
47192   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47193   return jresult;
47194 }
47195
47196
47197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47198   void * jresult ;
47199   Dali::Toolkit::AccessibilityManager *result = 0 ;
47200
47201   {
47202     try {
47203       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47204     } CALL_CATCH_EXCEPTION(0);
47205   }
47206
47207   jresult = (void *)result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47214
47215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47216   {
47217     try {
47218       delete arg1;
47219     } CALL_CATCH_EXCEPTION();
47220   }
47221
47222 }
47223
47224
47225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47226   void * jresult ;
47227   Dali::Toolkit::AccessibilityManager result;
47228
47229   {
47230     try {
47231       result = Dali::Toolkit::AccessibilityManager::Get();
47232     } CALL_CATCH_EXCEPTION(0);
47233   }
47234
47235   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47236   return jresult;
47237 }
47238
47239
47240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47242   Dali::Actor arg2 ;
47243   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47244   std::string *arg4 = 0 ;
47245   Dali::Actor *argp2 ;
47246
47247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47248   argp2 = (Dali::Actor *)jarg2;
47249   if (!argp2) {
47250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47251     return ;
47252   }
47253   arg2 = *argp2;
47254   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47255   if (!jarg4) {
47256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47257     return ;
47258   }
47259   std::string arg4_str(jarg4);
47260   arg4 = &arg4_str;
47261   {
47262     try {
47263       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47264     } CALL_CATCH_EXCEPTION();
47265   }
47266
47267
47268   //argout typemap for const std::string&
47269
47270 }
47271
47272
47273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47274   char * jresult ;
47275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47276   Dali::Actor arg2 ;
47277   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47278   Dali::Actor *argp2 ;
47279   std::string result;
47280
47281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47282   argp2 = (Dali::Actor *)jarg2;
47283   if (!argp2) {
47284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47285     return 0;
47286   }
47287   arg2 = *argp2;
47288   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47289   {
47290     try {
47291       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47292     } CALL_CATCH_EXCEPTION(0);
47293   }
47294
47295   jresult = SWIG_csharp_string_callback((&result)->c_str());
47296   return jresult;
47297 }
47298
47299
47300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47302   Dali::Actor arg2 ;
47303   unsigned int arg3 ;
47304   Dali::Actor *argp2 ;
47305
47306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47307   argp2 = (Dali::Actor *)jarg2;
47308   if (!argp2) {
47309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47310     return ;
47311   }
47312   arg2 = *argp2;
47313   arg3 = (unsigned int)jarg3;
47314   {
47315     try {
47316       (arg1)->SetFocusOrder(arg2,arg3);
47317     } CALL_CATCH_EXCEPTION();
47318   }
47319
47320 }
47321
47322
47323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47324   unsigned int jresult ;
47325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47326   Dali::Actor arg2 ;
47327   Dali::Actor *argp2 ;
47328   unsigned int result;
47329
47330   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47331   argp2 = (Dali::Actor *)jarg2;
47332   if (!argp2) {
47333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47334     return 0;
47335   }
47336   arg2 = *argp2;
47337   {
47338     try {
47339       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47340     } CALL_CATCH_EXCEPTION(0);
47341   }
47342
47343   jresult = result;
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47349   unsigned int jresult ;
47350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47351   unsigned int result;
47352
47353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47354   {
47355     try {
47356       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47357     } CALL_CATCH_EXCEPTION(0);
47358   }
47359
47360   jresult = result;
47361   return jresult;
47362 }
47363
47364
47365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47366   void * jresult ;
47367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47368   unsigned int arg2 ;
47369   Dali::Actor result;
47370
47371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47372   arg2 = (unsigned int)jarg2;
47373   {
47374     try {
47375       result = (arg1)->GetActorByFocusOrder(arg2);
47376     } CALL_CATCH_EXCEPTION(0);
47377   }
47378
47379   jresult = new Dali::Actor((const Dali::Actor &)result);
47380   return jresult;
47381 }
47382
47383
47384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47385   unsigned int jresult ;
47386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47387   Dali::Actor arg2 ;
47388   Dali::Actor *argp2 ;
47389   bool result;
47390
47391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47392   argp2 = (Dali::Actor *)jarg2;
47393   if (!argp2) {
47394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47395     return 0;
47396   }
47397   arg2 = *argp2;
47398   {
47399     try {
47400       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47401     } CALL_CATCH_EXCEPTION(0);
47402   }
47403
47404   jresult = result;
47405   return jresult;
47406 }
47407
47408
47409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47410   void * jresult ;
47411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47412   Dali::Actor result;
47413
47414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47415   {
47416     try {
47417       result = (arg1)->GetCurrentFocusActor();
47418     } CALL_CATCH_EXCEPTION(0);
47419   }
47420
47421   jresult = new Dali::Actor((const Dali::Actor &)result);
47422   return jresult;
47423 }
47424
47425
47426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47427   void * jresult ;
47428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47429   Dali::Actor result;
47430
47431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47432   {
47433     try {
47434       result = (arg1)->GetCurrentFocusGroup();
47435     } CALL_CATCH_EXCEPTION(0);
47436   }
47437
47438   jresult = new Dali::Actor((const Dali::Actor &)result);
47439   return jresult;
47440 }
47441
47442
47443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47444   unsigned int jresult ;
47445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47446   unsigned int result;
47447
47448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47449   {
47450     try {
47451       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47452     } CALL_CATCH_EXCEPTION(0);
47453   }
47454
47455   jresult = result;
47456   return jresult;
47457 }
47458
47459
47460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47461   unsigned int jresult ;
47462   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47463   bool result;
47464
47465   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47466   {
47467     try {
47468       result = (bool)(arg1)->MoveFocusForward();
47469     } CALL_CATCH_EXCEPTION(0);
47470   }
47471
47472   jresult = result;
47473   return jresult;
47474 }
47475
47476
47477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
47478   unsigned int jresult ;
47479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47480   bool result;
47481
47482   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47483   {
47484     try {
47485       result = (bool)(arg1)->MoveFocusBackward();
47486     } CALL_CATCH_EXCEPTION(0);
47487   }
47488
47489   jresult = result;
47490   return jresult;
47491 }
47492
47493
47494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47495   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47496
47497   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47498   {
47499     try {
47500       (arg1)->ClearFocus();
47501     } CALL_CATCH_EXCEPTION();
47502   }
47503
47504 }
47505
47506
47507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47508   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47509
47510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47511   {
47512     try {
47513       (arg1)->Reset();
47514     } CALL_CATCH_EXCEPTION();
47515   }
47516
47517 }
47518
47519
47520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47522   Dali::Actor arg2 ;
47523   bool arg3 ;
47524   Dali::Actor *argp2 ;
47525
47526   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47527   argp2 = (Dali::Actor *)jarg2;
47528   if (!argp2) {
47529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47530     return ;
47531   }
47532   arg2 = *argp2;
47533   arg3 = jarg3 ? true : false;
47534   {
47535     try {
47536       (arg1)->SetFocusGroup(arg2,arg3);
47537     } CALL_CATCH_EXCEPTION();
47538   }
47539
47540 }
47541
47542
47543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
47544   unsigned int jresult ;
47545   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47546   Dali::Actor arg2 ;
47547   Dali::Actor *argp2 ;
47548   bool result;
47549
47550   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47551   argp2 = (Dali::Actor *)jarg2;
47552   if (!argp2) {
47553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47554     return 0;
47555   }
47556   arg2 = *argp2;
47557   {
47558     try {
47559       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47560     } CALL_CATCH_EXCEPTION(0);
47561   }
47562
47563   jresult = result;
47564   return jresult;
47565 }
47566
47567
47568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47570   bool arg2 ;
47571
47572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47573   arg2 = jarg2 ? true : false;
47574   {
47575     try {
47576       (arg1)->SetGroupMode(arg2);
47577     } CALL_CATCH_EXCEPTION();
47578   }
47579
47580 }
47581
47582
47583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47584   unsigned int jresult ;
47585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47586   bool result;
47587
47588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47589   {
47590     try {
47591       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47592     } CALL_CATCH_EXCEPTION(0);
47593   }
47594
47595   jresult = result;
47596   return jresult;
47597 }
47598
47599
47600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47601   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47602   bool arg2 ;
47603
47604   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47605   arg2 = jarg2 ? true : false;
47606   {
47607     try {
47608       (arg1)->SetWrapMode(arg2);
47609     } CALL_CATCH_EXCEPTION();
47610   }
47611
47612 }
47613
47614
47615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47616   unsigned int jresult ;
47617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47618   bool result;
47619
47620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47621   {
47622     try {
47623       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47624     } CALL_CATCH_EXCEPTION(0);
47625   }
47626
47627   jresult = result;
47628   return jresult;
47629 }
47630
47631
47632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47633   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47634   Dali::Actor arg2 ;
47635   Dali::Actor *argp2 ;
47636
47637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47638   argp2 = (Dali::Actor *)jarg2;
47639   if (!argp2) {
47640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47641     return ;
47642   }
47643   arg2 = *argp2;
47644   {
47645     try {
47646       (arg1)->SetFocusIndicatorActor(arg2);
47647     } CALL_CATCH_EXCEPTION();
47648   }
47649
47650 }
47651
47652
47653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47654   void * jresult ;
47655   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47656   Dali::Actor result;
47657
47658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47659   {
47660     try {
47661       result = (arg1)->GetFocusIndicatorActor();
47662     } CALL_CATCH_EXCEPTION(0);
47663   }
47664
47665   jresult = new Dali::Actor((const Dali::Actor &)result);
47666   return jresult;
47667 }
47668
47669
47670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47671   void * jresult ;
47672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47673   Dali::Actor arg2 ;
47674   Dali::Actor *argp2 ;
47675   Dali::Actor result;
47676
47677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47678   argp2 = (Dali::Actor *)jarg2;
47679   if (!argp2) {
47680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47681     return 0;
47682   }
47683   arg2 = *argp2;
47684   {
47685     try {
47686       result = (arg1)->GetFocusGroup(arg2);
47687     } CALL_CATCH_EXCEPTION(0);
47688   }
47689
47690   jresult = new Dali::Actor((const Dali::Actor &)result);
47691   return jresult;
47692 }
47693
47694
47695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47696   void * jresult ;
47697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47698   Dali::Vector2 result;
47699
47700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47701   {
47702     try {
47703       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47704     } CALL_CATCH_EXCEPTION(0);
47705   }
47706
47707   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47708   return jresult;
47709 }
47710
47711
47712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47713   void * jresult ;
47714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47715   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47716
47717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47718   {
47719     try {
47720       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47721     } CALL_CATCH_EXCEPTION(0);
47722   }
47723
47724   jresult = (void *)result;
47725   return jresult;
47726 }
47727
47728
47729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47730   void * jresult ;
47731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47732   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47733
47734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47735   {
47736     try {
47737       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47738     } CALL_CATCH_EXCEPTION(0);
47739   }
47740
47741   jresult = (void *)result;
47742   return jresult;
47743 }
47744
47745
47746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47747   void * jresult ;
47748   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47749   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47750
47751   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47752   {
47753     try {
47754       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47755     } CALL_CATCH_EXCEPTION(0);
47756   }
47757
47758   jresult = (void *)result;
47759   return jresult;
47760 }
47761
47762
47763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47764   void * jresult ;
47765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47766   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47767
47768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47769   {
47770     try {
47771       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47772     } CALL_CATCH_EXCEPTION(0);
47773   }
47774
47775   jresult = (void *)result;
47776   return jresult;
47777 }
47778
47779
47780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
47781   void * jresult ;
47782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47783   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47784
47785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47786   {
47787     try {
47788       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
47789     } CALL_CATCH_EXCEPTION(0);
47790   }
47791
47792   jresult = (void *)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
47798   void * jresult ;
47799   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47800   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47801
47802   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47803   {
47804     try {
47805       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
47806     } CALL_CATCH_EXCEPTION(0);
47807   }
47808
47809   jresult = (void *)result;
47810   return jresult;
47811 }
47812
47813
47814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
47815   void * jresult ;
47816   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47817   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47818
47819   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47820   {
47821     try {
47822       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
47823     } CALL_CATCH_EXCEPTION(0);
47824   }
47825
47826   jresult = (void *)result;
47827   return jresult;
47828 }
47829
47830
47831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
47832   void * jresult ;
47833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47834   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47835
47836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47837   {
47838     try {
47839       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
47840     } CALL_CATCH_EXCEPTION(0);
47841   }
47842
47843   jresult = (void *)result;
47844   return jresult;
47845 }
47846
47847
47848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
47849   void * jresult ;
47850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47852
47853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47854   {
47855     try {
47856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
47857     } CALL_CATCH_EXCEPTION(0);
47858   }
47859
47860   jresult = (void *)result;
47861   return jresult;
47862 }
47863
47864
47865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
47866   void * jresult ;
47867   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47868   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47869
47870   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47871   {
47872     try {
47873       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
47874     } CALL_CATCH_EXCEPTION(0);
47875   }
47876
47877   jresult = (void *)result;
47878   return jresult;
47879 }
47880
47881
47882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
47883   void * jresult ;
47884   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47885   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47886
47887   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47888   {
47889     try {
47890       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
47891     } CALL_CATCH_EXCEPTION(0);
47892   }
47893
47894   jresult = (void *)result;
47895   return jresult;
47896 }
47897
47898
47899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
47900   void * jresult ;
47901   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47902   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47903
47904   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47905   {
47906     try {
47907       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
47908     } CALL_CATCH_EXCEPTION(0);
47909   }
47910
47911   jresult = (void *)result;
47912   return jresult;
47913 }
47914
47915
47916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
47917   void * jresult ;
47918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47919   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47920
47921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47922   {
47923     try {
47924       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
47925     } CALL_CATCH_EXCEPTION(0);
47926   }
47927
47928   jresult = (void *)result;
47929   return jresult;
47930 }
47931
47932
47933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
47934   void * jresult ;
47935   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47936   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47937
47938   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47939   {
47940     try {
47941       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
47942     } CALL_CATCH_EXCEPTION(0);
47943   }
47944
47945   jresult = (void *)result;
47946   return jresult;
47947 }
47948
47949
47950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
47951   void * jresult ;
47952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47953   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47954
47955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47956   {
47957     try {
47958       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
47959     } CALL_CATCH_EXCEPTION(0);
47960   }
47961
47962   jresult = (void *)result;
47963   return jresult;
47964 }
47965
47966
47967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
47968   void * jresult ;
47969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47970   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47971
47972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47973   {
47974     try {
47975       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
47976     } CALL_CATCH_EXCEPTION(0);
47977   }
47978
47979   jresult = (void *)result;
47980   return jresult;
47981 }
47982
47983
47984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
47985   void * jresult ;
47986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47988
47989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47990   {
47991     try {
47992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
47993     } CALL_CATCH_EXCEPTION(0);
47994   }
47995
47996   jresult = (void *)result;
47997   return jresult;
47998 }
47999
48000
48001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
48002   void * jresult ;
48003   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48004   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48005
48006   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48007   {
48008     try {
48009       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
48010     } CALL_CATCH_EXCEPTION(0);
48011   }
48012
48013   jresult = (void *)result;
48014   return jresult;
48015 }
48016
48017
48018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
48019   void * jresult ;
48020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48021   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48022
48023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48024   {
48025     try {
48026       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
48027     } CALL_CATCH_EXCEPTION(0);
48028   }
48029
48030   jresult = (void *)result;
48031   return jresult;
48032 }
48033
48034
48035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
48036   void * jresult ;
48037   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48038   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48039
48040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48041   {
48042     try {
48043       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
48044     } CALL_CATCH_EXCEPTION(0);
48045   }
48046
48047   jresult = (void *)result;
48048   return jresult;
48049 }
48050
48051
48052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
48053   void * jresult ;
48054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48055   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48056
48057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48058   {
48059     try {
48060       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
48061     } CALL_CATCH_EXCEPTION(0);
48062   }
48063
48064   jresult = (void *)result;
48065   return jresult;
48066 }
48067
48068
48069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
48070   void * jresult ;
48071   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48072   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48073
48074   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48075   {
48076     try {
48077       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
48078     } CALL_CATCH_EXCEPTION(0);
48079   }
48080
48081   jresult = (void *)result;
48082   return jresult;
48083 }
48084
48085
48086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
48087   void * jresult ;
48088   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48089   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48090
48091   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48092   {
48093     try {
48094       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
48095     } CALL_CATCH_EXCEPTION(0);
48096   }
48097
48098   jresult = (void *)result;
48099   return jresult;
48100 }
48101
48102
48103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
48104   void * jresult ;
48105   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48106   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48107
48108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48109   {
48110     try {
48111       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
48112     } CALL_CATCH_EXCEPTION(0);
48113   }
48114
48115   jresult = (void *)result;
48116   return jresult;
48117 }
48118
48119
48120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
48121   void * jresult ;
48122   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48123   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48124
48125   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48126   {
48127     try {
48128       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
48129     } CALL_CATCH_EXCEPTION(0);
48130   }
48131
48132   jresult = (void *)result;
48133   return jresult;
48134 }
48135
48136
48137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
48138   void * jresult ;
48139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48140   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48141
48142   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48143   {
48144     try {
48145       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
48146     } CALL_CATCH_EXCEPTION(0);
48147   }
48148
48149   jresult = (void *)result;
48150   return jresult;
48151 }
48152
48153
48154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
48155   void * jresult ;
48156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48157   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48158
48159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48160   {
48161     try {
48162       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
48163     } CALL_CATCH_EXCEPTION(0);
48164   }
48165
48166   jresult = (void *)result;
48167   return jresult;
48168 }
48169
48170
48171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
48172   void * jresult ;
48173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48174   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48175
48176   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48177   {
48178     try {
48179       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
48180     } CALL_CATCH_EXCEPTION(0);
48181   }
48182
48183   jresult = (void *)result;
48184   return jresult;
48185 }
48186
48187
48188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48189   void * jresult ;
48190   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48191   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48192
48193   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48194   {
48195     try {
48196       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48197     } CALL_CATCH_EXCEPTION(0);
48198   }
48199
48200   jresult = (void *)result;
48201   return jresult;
48202 }
48203
48204
48205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48206   void * jresult ;
48207   Dali::Toolkit::StyleManager *result = 0 ;
48208
48209   {
48210     try {
48211       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48212     } CALL_CATCH_EXCEPTION(0);
48213   }
48214
48215   jresult = (void *)result;
48216   return jresult;
48217 }
48218
48219
48220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48221   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48222
48223   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48224   {
48225     try {
48226       delete arg1;
48227     } CALL_CATCH_EXCEPTION();
48228   }
48229
48230 }
48231
48232
48233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48234   void * jresult ;
48235   Dali::Toolkit::StyleManager result;
48236
48237   {
48238     try {
48239       result = Dali::Toolkit::StyleManager::Get();
48240     } CALL_CATCH_EXCEPTION(0);
48241   }
48242
48243   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48244   return jresult;
48245 }
48246
48247
48248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48249   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48250   std::string *arg2 = 0 ;
48251
48252   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48253   if (!jarg2) {
48254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48255     return ;
48256   }
48257   std::string arg2_str(jarg2);
48258   arg2 = &arg2_str;
48259   {
48260     try {
48261       (arg1)->ApplyTheme((std::string const &)*arg2);
48262     } CALL_CATCH_EXCEPTION();
48263   }
48264
48265
48266   //argout typemap for const std::string&
48267
48268 }
48269
48270
48271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48272   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48273
48274   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48275   {
48276     try {
48277       (arg1)->ApplyDefaultTheme();
48278     } CALL_CATCH_EXCEPTION();
48279   }
48280
48281 }
48282
48283
48284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48285   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48286   std::string *arg2 = 0 ;
48287   Dali::Property::Value *arg3 = 0 ;
48288
48289   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48290   if (!jarg2) {
48291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48292     return ;
48293   }
48294   std::string arg2_str(jarg2);
48295   arg2 = &arg2_str;
48296   arg3 = (Dali::Property::Value *)jarg3;
48297   if (!arg3) {
48298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48299     return ;
48300   }
48301   {
48302     try {
48303       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48304     } CALL_CATCH_EXCEPTION();
48305   }
48306
48307
48308   //argout typemap for const std::string&
48309
48310 }
48311
48312
48313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48314   unsigned int jresult ;
48315   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48316   std::string *arg2 = 0 ;
48317   Dali::Property::Value *arg3 = 0 ;
48318   bool result;
48319
48320   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48321   if (!jarg2) {
48322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48323     return 0;
48324   }
48325   std::string arg2_str(jarg2);
48326   arg2 = &arg2_str;
48327   arg3 = (Dali::Property::Value *)jarg3;
48328   if (!arg3) {
48329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48330     return 0;
48331   }
48332   {
48333     try {
48334       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48335     } CALL_CATCH_EXCEPTION(0);
48336   }
48337
48338   jresult = result;
48339
48340   //argout typemap for const std::string&
48341
48342   return jresult;
48343 }
48344
48345
48346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48347   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48348   Dali::Toolkit::Control arg2 ;
48349   std::string *arg3 = 0 ;
48350   std::string *arg4 = 0 ;
48351   Dali::Toolkit::Control *argp2 ;
48352
48353   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48354   argp2 = (Dali::Toolkit::Control *)jarg2;
48355   if (!argp2) {
48356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48357     return ;
48358   }
48359   arg2 = *argp2;
48360   if (!jarg3) {
48361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48362     return ;
48363   }
48364   std::string arg3_str(jarg3);
48365   arg3 = &arg3_str;
48366   if (!jarg4) {
48367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48368     return ;
48369   }
48370   std::string arg4_str(jarg4);
48371   arg4 = &arg4_str;
48372   {
48373     try {
48374       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48375     } CALL_CATCH_EXCEPTION();
48376   }
48377
48378
48379   //argout typemap for const std::string&
48380
48381
48382   //argout typemap for const std::string&
48383
48384 }
48385
48386
48387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48388   void * jresult ;
48389   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48390   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48391
48392   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48393   {
48394     try {
48395       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48396     } CALL_CATCH_EXCEPTION(0);
48397   }
48398
48399   jresult = (void *)result;
48400   return jresult;
48401 }
48402
48403
48404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48405   int jresult ;
48406   int result;
48407
48408   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48409   jresult = (int)result;
48410   return jresult;
48411 }
48412
48413
48414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48415   int jresult ;
48416   int result;
48417
48418   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48419   jresult = (int)result;
48420   return jresult;
48421 }
48422
48423
48424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48425   int jresult ;
48426   int result;
48427
48428   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48429   jresult = (int)result;
48430   return jresult;
48431 }
48432
48433
48434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48435   int jresult ;
48436   int result;
48437
48438   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48439   jresult = (int)result;
48440   return jresult;
48441 }
48442
48443
48444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48445   int jresult ;
48446   int result;
48447
48448   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48449   jresult = (int)result;
48450   return jresult;
48451 }
48452
48453
48454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48455   int jresult ;
48456   int result;
48457
48458   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48459   jresult = (int)result;
48460   return jresult;
48461 }
48462
48463
48464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48465   int jresult ;
48466   int result;
48467
48468   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48469   jresult = (int)result;
48470   return jresult;
48471 }
48472
48473
48474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48475   int jresult ;
48476   int result;
48477
48478   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48479   jresult = (int)result;
48480   return jresult;
48481 }
48482
48483
48484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48485   int jresult ;
48486   int result;
48487
48488   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48489   jresult = (int)result;
48490   return jresult;
48491 }
48492
48493
48494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48495   int jresult ;
48496   int result;
48497
48498   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48499   jresult = (int)result;
48500   return jresult;
48501 }
48502
48503
48504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48505   int jresult ;
48506   int result;
48507
48508   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48509   jresult = (int)result;
48510   return jresult;
48511 }
48512
48513
48514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48515   int jresult ;
48516   int result;
48517
48518   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48519   jresult = (int)result;
48520   return jresult;
48521 }
48522
48523
48524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48525   int jresult ;
48526   int result;
48527
48528   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48529   jresult = (int)result;
48530   return jresult;
48531 }
48532
48533
48534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48535   int jresult ;
48536   int result;
48537
48538   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48539   jresult = (int)result;
48540   return jresult;
48541 }
48542
48543
48544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48545   int jresult ;
48546   int result;
48547
48548   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48549   jresult = (int)result;
48550   return jresult;
48551 }
48552
48553
48554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48555   void * jresult ;
48556   Dali::Toolkit::Slider::Property *result = 0 ;
48557
48558   {
48559     try {
48560       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48561     } CALL_CATCH_EXCEPTION(0);
48562   }
48563
48564   jresult = (void *)result;
48565   return jresult;
48566 }
48567
48568
48569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48570   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48571
48572   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48573   {
48574     try {
48575       delete arg1;
48576     } CALL_CATCH_EXCEPTION();
48577   }
48578
48579 }
48580
48581
48582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48583   void * jresult ;
48584   Dali::Toolkit::Slider result;
48585
48586   {
48587     try {
48588       result = Dali::Toolkit::Slider::New();
48589     } CALL_CATCH_EXCEPTION(0);
48590   }
48591
48592   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48593   return jresult;
48594 }
48595
48596
48597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48598   void * jresult ;
48599   Dali::Toolkit::Slider *result = 0 ;
48600
48601   {
48602     try {
48603       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48604     } CALL_CATCH_EXCEPTION(0);
48605   }
48606
48607   jresult = (void *)result;
48608   return jresult;
48609 }
48610
48611
48612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48613   void * jresult ;
48614   Dali::Toolkit::Slider *arg1 = 0 ;
48615   Dali::Toolkit::Slider *result = 0 ;
48616
48617   arg1 = (Dali::Toolkit::Slider *)jarg1;
48618   if (!arg1) {
48619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48620     return 0;
48621   }
48622   {
48623     try {
48624       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48625     } CALL_CATCH_EXCEPTION(0);
48626   }
48627
48628   jresult = (void *)result;
48629   return jresult;
48630 }
48631
48632
48633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48634   void * jresult ;
48635   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48636   Dali::Toolkit::Slider *arg2 = 0 ;
48637   Dali::Toolkit::Slider *result = 0 ;
48638
48639   arg1 = (Dali::Toolkit::Slider *)jarg1;
48640   arg2 = (Dali::Toolkit::Slider *)jarg2;
48641   if (!arg2) {
48642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48643     return 0;
48644   }
48645   {
48646     try {
48647       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48648     } CALL_CATCH_EXCEPTION(0);
48649   }
48650
48651   jresult = (void *)result;
48652   return jresult;
48653 }
48654
48655
48656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48657   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48658
48659   arg1 = (Dali::Toolkit::Slider *)jarg1;
48660   {
48661     try {
48662       delete arg1;
48663     } CALL_CATCH_EXCEPTION();
48664   }
48665
48666 }
48667
48668
48669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48670   void * jresult ;
48671   Dali::BaseHandle arg1 ;
48672   Dali::BaseHandle *argp1 ;
48673   Dali::Toolkit::Slider result;
48674
48675   argp1 = (Dali::BaseHandle *)jarg1;
48676   if (!argp1) {
48677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48678     return 0;
48679   }
48680   arg1 = *argp1;
48681   {
48682     try {
48683       result = Dali::Toolkit::Slider::DownCast(arg1);
48684     } CALL_CATCH_EXCEPTION(0);
48685   }
48686
48687   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48688   return jresult;
48689 }
48690
48691
48692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48693   void * jresult ;
48694   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48695   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48696
48697   arg1 = (Dali::Toolkit::Slider *)jarg1;
48698   {
48699     try {
48700       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48701     } CALL_CATCH_EXCEPTION(0);
48702   }
48703
48704   jresult = (void *)result;
48705   return jresult;
48706 }
48707
48708
48709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
48710   void * jresult ;
48711   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48712   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48713
48714   arg1 = (Dali::Toolkit::Slider *)jarg1;
48715   {
48716     try {
48717       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
48718     } CALL_CATCH_EXCEPTION(0);
48719   }
48720
48721   jresult = (void *)result;
48722   return jresult;
48723 }
48724
48725
48726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48727   void * jresult ;
48728   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48729   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48730
48731   arg1 = (Dali::Toolkit::Slider *)jarg1;
48732   {
48733     try {
48734       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48735     } CALL_CATCH_EXCEPTION(0);
48736   }
48737
48738   jresult = (void *)result;
48739   return jresult;
48740 }
48741
48742
48743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48744   int jresult ;
48745   int result;
48746
48747   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48748   jresult = (int)result;
48749   return jresult;
48750 }
48751
48752
48753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48754   int jresult ;
48755   int result;
48756
48757   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48758   jresult = (int)result;
48759   return jresult;
48760 }
48761
48762
48763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48764   int jresult ;
48765   int result;
48766
48767   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48768   jresult = (int)result;
48769   return jresult;
48770 }
48771
48772
48773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48774   int jresult ;
48775   int result;
48776
48777   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48778   jresult = (int)result;
48779   return jresult;
48780 }
48781
48782
48783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48784   int result;
48785
48786   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48787
48788   return result;
48789 }
48790
48791
48792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48793   void * jresult ;
48794   Dali::Toolkit::VideoView::Property *result = 0 ;
48795
48796   {
48797     try {
48798       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48799     } CALL_CATCH_EXCEPTION(0);
48800   }
48801
48802   jresult = (void *)result;
48803   return jresult;
48804 }
48805
48806
48807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48808   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48809
48810   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48811   {
48812     try {
48813       delete arg1;
48814     } CALL_CATCH_EXCEPTION();
48815   }
48816
48817 }
48818
48819
48820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48821   void * jresult ;
48822   Dali::Toolkit::VideoView result;
48823
48824   {
48825     try {
48826       result = Dali::Toolkit::VideoView::New();
48827     } CALL_CATCH_EXCEPTION(0);
48828   }
48829
48830   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48831   return jresult;
48832 }
48833
48834
48835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48836   void * jresult ;
48837   std::string *arg1 = 0 ;
48838   Dali::Toolkit::VideoView result;
48839
48840   if (!jarg1) {
48841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48842     return 0;
48843   }
48844   std::string arg1_str(jarg1);
48845   arg1 = &arg1_str;
48846   {
48847     try {
48848       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48849     } CALL_CATCH_EXCEPTION(0);
48850   }
48851
48852   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48853
48854   //argout typemap for const std::string&
48855
48856   return jresult;
48857 }
48858
48859
48860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48861   void * jresult ;
48862   Dali::Toolkit::VideoView result;
48863   {
48864     try {
48865       result = Dali::Toolkit::VideoView::New(swCodec);
48866     } CALL_CATCH_EXCEPTION(0);
48867   }
48868
48869   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48870
48871   //argout typemap for const std::string&
48872
48873   return jresult;
48874 }
48875
48876
48877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
48878   void * jresult ;
48879   std::string *arg1 = 0 ;
48880   Dali::Toolkit::VideoView result;
48881
48882   if (!jarg1) {
48883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48884     return 0;
48885   }
48886   std::string arg1_str(jarg1);
48887   arg1 = &arg1_str;
48888   {
48889     try {
48890       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48891     } CALL_CATCH_EXCEPTION(0);
48892   }
48893
48894   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48895
48896   //argout typemap for const std::string&
48897
48898   return jresult;
48899 }
48900
48901
48902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48903   void * jresult ;
48904   Dali::Toolkit::VideoView *result = 0 ;
48905
48906   {
48907     try {
48908       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48909     } CALL_CATCH_EXCEPTION(0);
48910   }
48911
48912   jresult = (void *)result;
48913   return jresult;
48914 }
48915
48916
48917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48918   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48919
48920   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48921   {
48922     try {
48923       delete arg1;
48924     } CALL_CATCH_EXCEPTION();
48925   }
48926
48927 }
48928
48929
48930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48931   void * jresult ;
48932   Dali::Toolkit::VideoView *arg1 = 0 ;
48933   Dali::Toolkit::VideoView *result = 0 ;
48934
48935   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48936   if (!arg1) {
48937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48938     return 0;
48939   }
48940   {
48941     try {
48942       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48943     } CALL_CATCH_EXCEPTION(0);
48944   }
48945
48946   jresult = (void *)result;
48947   return jresult;
48948 }
48949
48950
48951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
48952   void * jresult ;
48953   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48954   Dali::Toolkit::VideoView *arg2 = 0 ;
48955   Dali::Toolkit::VideoView *result = 0 ;
48956
48957   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48958   arg2 = (Dali::Toolkit::VideoView *)jarg2;
48959   if (!arg2) {
48960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48961     return 0;
48962   }
48963   {
48964     try {
48965       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
48966     } CALL_CATCH_EXCEPTION(0);
48967   }
48968
48969   jresult = (void *)result;
48970   return jresult;
48971 }
48972
48973
48974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
48975   void * jresult ;
48976   Dali::BaseHandle arg1 ;
48977   Dali::BaseHandle *argp1 ;
48978   Dali::Toolkit::VideoView result;
48979
48980   argp1 = (Dali::BaseHandle *)jarg1;
48981   if (!argp1) {
48982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48983     return 0;
48984   }
48985   arg1 = *argp1;
48986   {
48987     try {
48988       result = Dali::Toolkit::VideoView::DownCast(arg1);
48989     } CALL_CATCH_EXCEPTION(0);
48990   }
48991
48992   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48993   return jresult;
48994 }
48995
48996
48997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
48998   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48999
49000   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49001   {
49002     try {
49003       (arg1)->Play();
49004     } CALL_CATCH_EXCEPTION();
49005   }
49006
49007 }
49008
49009
49010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
49011   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49012
49013   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49014   {
49015     try {
49016       (arg1)->Pause();
49017     } CALL_CATCH_EXCEPTION();
49018   }
49019
49020 }
49021
49022
49023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
49024   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49025
49026   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49027   {
49028     try {
49029       (arg1)->Stop();
49030     } CALL_CATCH_EXCEPTION();
49031   }
49032
49033 }
49034
49035
49036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
49037   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49038   int arg2 ;
49039
49040   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49041   arg2 = (int)jarg2;
49042   {
49043     try {
49044       (arg1)->Forward(arg2);
49045     } CALL_CATCH_EXCEPTION();
49046   }
49047
49048 }
49049
49050
49051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
49052   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49053   int arg2 ;
49054
49055   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49056   arg2 = (int)jarg2;
49057   {
49058     try {
49059       (arg1)->Backward(arg2);
49060     } CALL_CATCH_EXCEPTION();
49061   }
49062
49063 }
49064
49065
49066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
49067   void * jresult ;
49068   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49069   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
49070
49071   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49072   {
49073     try {
49074       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
49075     } CALL_CATCH_EXCEPTION(0);
49076   }
49077
49078   jresult = (void *)result;
49079   return jresult;
49080 }
49081
49082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
49083 {
49084   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
49085   if( arg1 == nullptr )
49086   {
49087     DALI_LOG_ERROR("VideoView is nullptr!");
49088     return nullptr;
49089   }
49090   void * ret = nullptr;
49091   {
49092     try{
49093
49094       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
49095       ret = Dali::AnyCast< void * >( result );
49096
49097     } CALL_CATCH_EXCEPTION(0);
49098   }
49099   return ret;
49100 }
49101
49102
49103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
49104   int jresult ;
49105   int result;
49106
49107   result = (int)Dali::Toolkit::Popup::Property::TITLE;
49108   jresult = (int)result;
49109   return jresult;
49110 }
49111
49112
49113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
49114   int jresult ;
49115   int result;
49116
49117   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
49118   jresult = (int)result;
49119   return jresult;
49120 }
49121
49122
49123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
49124   int jresult ;
49125   int result;
49126
49127   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
49128   jresult = (int)result;
49129   return jresult;
49130 }
49131
49132
49133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
49134   int jresult ;
49135   int result;
49136
49137   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
49138   jresult = (int)result;
49139   return jresult;
49140 }
49141
49142
49143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
49144   int jresult ;
49145   int result;
49146
49147   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
49148   jresult = (int)result;
49149   return jresult;
49150 }
49151
49152
49153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
49154   int jresult ;
49155   int result;
49156
49157   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
49158   jresult = (int)result;
49159   return jresult;
49160 }
49161
49162
49163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
49164   int jresult ;
49165   int result;
49166
49167   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
49168   jresult = (int)result;
49169   return jresult;
49170 }
49171
49172
49173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
49174   int jresult ;
49175   int result;
49176
49177   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
49178   jresult = (int)result;
49179   return jresult;
49180 }
49181
49182
49183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49184   int jresult ;
49185   int result;
49186
49187   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49188   jresult = (int)result;
49189   return jresult;
49190 }
49191
49192
49193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49194   int jresult ;
49195   int result;
49196
49197   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49198   jresult = (int)result;
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49204   int jresult ;
49205   int result;
49206
49207   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49208   jresult = (int)result;
49209   return jresult;
49210 }
49211
49212
49213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49214   int jresult ;
49215   int result;
49216
49217   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49218   jresult = (int)result;
49219   return jresult;
49220 }
49221
49222
49223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49224   int jresult ;
49225   int result;
49226
49227   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49228   jresult = (int)result;
49229   return jresult;
49230 }
49231
49232
49233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49234   int jresult ;
49235   int result;
49236
49237   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49238   jresult = (int)result;
49239   return jresult;
49240 }
49241
49242
49243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49244   int jresult ;
49245   int result;
49246
49247   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49248   jresult = (int)result;
49249   return jresult;
49250 }
49251
49252
49253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49254   int jresult ;
49255   int result;
49256
49257   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49258   jresult = (int)result;
49259   return jresult;
49260 }
49261
49262
49263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49264   int jresult ;
49265   int result;
49266
49267   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49268   jresult = (int)result;
49269   return jresult;
49270 }
49271
49272
49273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49274   int jresult ;
49275   int result;
49276
49277   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49278   jresult = (int)result;
49279   return jresult;
49280 }
49281
49282
49283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49284   int jresult ;
49285   int result;
49286
49287   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49288   jresult = (int)result;
49289   return jresult;
49290 }
49291
49292
49293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49294   int jresult ;
49295   int result;
49296
49297   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49298   jresult = (int)result;
49299   return jresult;
49300 }
49301
49302
49303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49304   int jresult ;
49305   int result;
49306
49307   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49308   jresult = (int)result;
49309   return jresult;
49310 }
49311
49312
49313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49314   void * jresult ;
49315   Dali::Toolkit::Popup::Property *result = 0 ;
49316
49317   {
49318     try {
49319       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49320     } CALL_CATCH_EXCEPTION(0);
49321   }
49322
49323   jresult = (void *)result;
49324   return jresult;
49325 }
49326
49327
49328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49329   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49330
49331   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49332   {
49333     try {
49334       delete arg1;
49335     } CALL_CATCH_EXCEPTION();
49336   }
49337
49338 }
49339
49340
49341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49342   void * jresult ;
49343   Dali::Toolkit::Popup *result = 0 ;
49344
49345   {
49346     try {
49347       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49348     } CALL_CATCH_EXCEPTION(0);
49349   }
49350
49351   jresult = (void *)result;
49352   return jresult;
49353 }
49354
49355
49356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49357   void * jresult ;
49358   Dali::Toolkit::Popup result;
49359
49360   {
49361     try {
49362       result = Dali::Toolkit::Popup::New();
49363     } CALL_CATCH_EXCEPTION(0);
49364   }
49365
49366   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49367   return jresult;
49368 }
49369
49370
49371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49372   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49373
49374   arg1 = (Dali::Toolkit::Popup *)jarg1;
49375   {
49376     try {
49377       delete arg1;
49378     } CALL_CATCH_EXCEPTION();
49379   }
49380
49381 }
49382
49383
49384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49385   void * jresult ;
49386   Dali::Toolkit::Popup *arg1 = 0 ;
49387   Dali::Toolkit::Popup *result = 0 ;
49388
49389   arg1 = (Dali::Toolkit::Popup *)jarg1;
49390   if (!arg1) {
49391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49392     return 0;
49393   }
49394   {
49395     try {
49396       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49397     } CALL_CATCH_EXCEPTION(0);
49398   }
49399
49400   jresult = (void *)result;
49401   return jresult;
49402 }
49403
49404
49405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49406   void * jresult ;
49407   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49408   Dali::Toolkit::Popup *arg2 = 0 ;
49409   Dali::Toolkit::Popup *result = 0 ;
49410
49411   arg1 = (Dali::Toolkit::Popup *)jarg1;
49412   arg2 = (Dali::Toolkit::Popup *)jarg2;
49413   if (!arg2) {
49414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49415     return 0;
49416   }
49417   {
49418     try {
49419       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49420     } CALL_CATCH_EXCEPTION(0);
49421   }
49422
49423   jresult = (void *)result;
49424   return jresult;
49425 }
49426
49427
49428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49429   void * jresult ;
49430   Dali::BaseHandle arg1 ;
49431   Dali::BaseHandle *argp1 ;
49432   Dali::Toolkit::Popup result;
49433
49434   argp1 = (Dali::BaseHandle *)jarg1;
49435   if (!argp1) {
49436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49437     return 0;
49438   }
49439   arg1 = *argp1;
49440   {
49441     try {
49442       result = Dali::Toolkit::Popup::DownCast(arg1);
49443     } CALL_CATCH_EXCEPTION(0);
49444   }
49445
49446   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49447   return jresult;
49448 }
49449
49450
49451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49452   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49453   Dali::Actor arg2 ;
49454   Dali::Actor *argp2 ;
49455
49456   arg1 = (Dali::Toolkit::Popup *)jarg1;
49457   argp2 = (Dali::Actor *)jarg2;
49458   if (!argp2) {
49459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49460     return ;
49461   }
49462   arg2 = *argp2;
49463   {
49464     try {
49465       (arg1)->SetTitle(arg2);
49466     } CALL_CATCH_EXCEPTION();
49467   }
49468
49469 }
49470
49471
49472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49473   void * jresult ;
49474   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49475   Dali::Actor result;
49476
49477   arg1 = (Dali::Toolkit::Popup *)jarg1;
49478   {
49479     try {
49480       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49481     } CALL_CATCH_EXCEPTION(0);
49482   }
49483
49484   jresult = new Dali::Actor((const Dali::Actor &)result);
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49490   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49491   Dali::Actor arg2 ;
49492   Dali::Actor *argp2 ;
49493
49494   arg1 = (Dali::Toolkit::Popup *)jarg1;
49495   argp2 = (Dali::Actor *)jarg2;
49496   if (!argp2) {
49497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49498     return ;
49499   }
49500   arg2 = *argp2;
49501   {
49502     try {
49503       (arg1)->SetContent(arg2);
49504     } CALL_CATCH_EXCEPTION();
49505   }
49506
49507 }
49508
49509
49510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49511   void * jresult ;
49512   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49513   Dali::Actor result;
49514
49515   arg1 = (Dali::Toolkit::Popup *)jarg1;
49516   {
49517     try {
49518       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49519     } CALL_CATCH_EXCEPTION(0);
49520   }
49521
49522   jresult = new Dali::Actor((const Dali::Actor &)result);
49523   return jresult;
49524 }
49525
49526
49527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49528   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49529   Dali::Actor arg2 ;
49530   Dali::Actor *argp2 ;
49531
49532   arg1 = (Dali::Toolkit::Popup *)jarg1;
49533   argp2 = (Dali::Actor *)jarg2;
49534   if (!argp2) {
49535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49536     return ;
49537   }
49538   arg2 = *argp2;
49539   {
49540     try {
49541       (arg1)->SetFooter(arg2);
49542     } CALL_CATCH_EXCEPTION();
49543   }
49544
49545 }
49546
49547
49548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49549   void * jresult ;
49550   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49551   Dali::Actor result;
49552
49553   arg1 = (Dali::Toolkit::Popup *)jarg1;
49554   {
49555     try {
49556       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49557     } CALL_CATCH_EXCEPTION(0);
49558   }
49559
49560   jresult = new Dali::Actor((const Dali::Actor &)result);
49561   return jresult;
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49566   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49567   Dali::Toolkit::Popup::DisplayState arg2 ;
49568
49569   arg1 = (Dali::Toolkit::Popup *)jarg1;
49570   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49571   {
49572     try {
49573       (arg1)->SetDisplayState(arg2);
49574     } CALL_CATCH_EXCEPTION();
49575   }
49576
49577 }
49578
49579
49580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49581   int jresult ;
49582   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49583   Dali::Toolkit::Popup::DisplayState result;
49584
49585   arg1 = (Dali::Toolkit::Popup *)jarg1;
49586   {
49587     try {
49588       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49589     } CALL_CATCH_EXCEPTION(0);
49590   }
49591
49592   jresult = (int)result;
49593   return jresult;
49594 }
49595
49596
49597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49598   void * jresult ;
49599   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49600   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49601
49602   arg1 = (Dali::Toolkit::Popup *)jarg1;
49603   {
49604     try {
49605       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49606     } CALL_CATCH_EXCEPTION(0);
49607   }
49608
49609   jresult = (void *)result;
49610   return jresult;
49611 }
49612
49613
49614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49615   void * jresult ;
49616   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49617   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49618
49619   arg1 = (Dali::Toolkit::Popup *)jarg1;
49620   {
49621     try {
49622       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49623     } CALL_CATCH_EXCEPTION(0);
49624   }
49625
49626   jresult = (void *)result;
49627   return jresult;
49628 }
49629
49630
49631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
49632   void * jresult ;
49633   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49634   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49635
49636   arg1 = (Dali::Toolkit::Popup *)jarg1;
49637   {
49638     try {
49639       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
49640     } CALL_CATCH_EXCEPTION(0);
49641   }
49642
49643   jresult = (void *)result;
49644   return jresult;
49645 }
49646
49647
49648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
49649   void * jresult ;
49650   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49651   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49652
49653   arg1 = (Dali::Toolkit::Popup *)jarg1;
49654   {
49655     try {
49656       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
49657     } CALL_CATCH_EXCEPTION(0);
49658   }
49659
49660   jresult = (void *)result;
49661   return jresult;
49662 }
49663
49664
49665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
49666   void * jresult ;
49667   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49668   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49669
49670   arg1 = (Dali::Toolkit::Popup *)jarg1;
49671   {
49672     try {
49673       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
49674     } CALL_CATCH_EXCEPTION(0);
49675   }
49676
49677   jresult = (void *)result;
49678   return jresult;
49679 }
49680
49681
49682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49683   int jresult ;
49684   int result;
49685
49686   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49687   jresult = (int)result;
49688   return jresult;
49689 }
49690
49691
49692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49693   int jresult ;
49694   int result;
49695
49696   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49697   jresult = (int)result;
49698   return jresult;
49699 }
49700
49701
49702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49703   int jresult ;
49704   int result;
49705
49706   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49707   jresult = (int)result;
49708   return jresult;
49709 }
49710
49711
49712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49713   int jresult ;
49714   int result;
49715
49716   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49717   jresult = (int)result;
49718   return jresult;
49719 }
49720
49721
49722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49723   int jresult ;
49724   int result;
49725
49726   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49727   jresult = (int)result;
49728   return jresult;
49729 }
49730
49731
49732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49733   int jresult ;
49734   int result;
49735
49736   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49737   jresult = (int)result;
49738   return jresult;
49739 }
49740
49741
49742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49743   int jresult ;
49744   int result;
49745
49746   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49747   jresult = (int)result;
49748   return jresult;
49749 }
49750
49751
49752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49753   int jresult ;
49754   int result;
49755
49756   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49757   jresult = (int)result;
49758   return jresult;
49759 }
49760
49761
49762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49763   int jresult ;
49764   int result;
49765
49766   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49767   jresult = (int)result;
49768   return jresult;
49769 }
49770
49771
49772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49773   void * jresult ;
49774   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49775
49776   {
49777     try {
49778       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49779     } CALL_CATCH_EXCEPTION(0);
49780   }
49781
49782   jresult = (void *)result;
49783   return jresult;
49784 }
49785
49786
49787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49788   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49789
49790   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49791   {
49792     try {
49793       delete arg1;
49794     } CALL_CATCH_EXCEPTION();
49795   }
49796
49797 }
49798
49799
49800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49801   void * jresult ;
49802   Dali::Toolkit::ProgressBar result;
49803
49804   {
49805     try {
49806       result = Dali::Toolkit::ProgressBar::New();
49807     } CALL_CATCH_EXCEPTION(0);
49808   }
49809
49810   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49811   return jresult;
49812 }
49813
49814
49815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49816   void * jresult ;
49817   Dali::Toolkit::ProgressBar *result = 0 ;
49818
49819   {
49820     try {
49821       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49822     } CALL_CATCH_EXCEPTION(0);
49823   }
49824
49825   jresult = (void *)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49831   void * jresult ;
49832   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49833   Dali::Toolkit::ProgressBar *result = 0 ;
49834
49835   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49836   if (!arg1) {
49837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49838     return 0;
49839   }
49840   {
49841     try {
49842       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49843     } CALL_CATCH_EXCEPTION(0);
49844   }
49845
49846   jresult = (void *)result;
49847   return jresult;
49848 }
49849
49850
49851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49852   void * jresult ;
49853   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49854   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49855   Dali::Toolkit::ProgressBar *result = 0 ;
49856
49857   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49858   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49859   if (!arg2) {
49860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49861     return 0;
49862   }
49863   {
49864     try {
49865       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49866     } CALL_CATCH_EXCEPTION(0);
49867   }
49868
49869   jresult = (void *)result;
49870   return jresult;
49871 }
49872
49873
49874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49875   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49876
49877   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49878   {
49879     try {
49880       delete arg1;
49881     } CALL_CATCH_EXCEPTION();
49882   }
49883
49884 }
49885
49886
49887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49888   void * jresult ;
49889   Dali::BaseHandle arg1 ;
49890   Dali::BaseHandle *argp1 ;
49891   Dali::Toolkit::ProgressBar result;
49892
49893   argp1 = (Dali::BaseHandle *)jarg1;
49894   if (!argp1) {
49895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49896     return 0;
49897   }
49898   arg1 = *argp1;
49899   {
49900     try {
49901       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49902     } CALL_CATCH_EXCEPTION(0);
49903   }
49904
49905   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49906   return jresult;
49907 }
49908
49909
49910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49911   void * jresult ;
49912   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49913   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49914
49915   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49916   {
49917     try {
49918       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49919     } CALL_CATCH_EXCEPTION(0);
49920   }
49921
49922   jresult = (void *)result;
49923   return jresult;
49924 }
49925
49926
49927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49928   void * jresult ;
49929   Dali::Toolkit::GaussianBlurView *result = 0 ;
49930
49931   {
49932     try {
49933       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49934     } CALL_CATCH_EXCEPTION(0);
49935   }
49936
49937   jresult = (void *)result;
49938   return jresult;
49939 }
49940
49941
49942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49943   void * jresult ;
49944   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
49945   Dali::Toolkit::GaussianBlurView *result = 0 ;
49946
49947   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49948   if (!arg1) {
49949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49950     return 0;
49951   }
49952   {
49953     try {
49954       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
49955     } CALL_CATCH_EXCEPTION(0);
49956   }
49957
49958   jresult = (void *)result;
49959   return jresult;
49960 }
49961
49962
49963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
49964   void * jresult ;
49965   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49966   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
49967   Dali::Toolkit::GaussianBlurView *result = 0 ;
49968
49969   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49970   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
49971   if (!arg2) {
49972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49973     return 0;
49974   }
49975   {
49976     try {
49977       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
49978     } CALL_CATCH_EXCEPTION(0);
49979   }
49980
49981   jresult = (void *)result;
49982   return jresult;
49983 }
49984
49985
49986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
49987   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49988
49989   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49990   {
49991     try {
49992       delete arg1;
49993     } CALL_CATCH_EXCEPTION();
49994   }
49995
49996 }
49997
49998
49999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
50000   void * jresult ;
50001   Dali::BaseHandle arg1 ;
50002   Dali::BaseHandle *argp1 ;
50003   Dali::Toolkit::GaussianBlurView result;
50004
50005   argp1 = (Dali::BaseHandle *)jarg1;
50006   if (!argp1) {
50007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50008     return 0;
50009   }
50010   arg1 = *argp1;
50011   {
50012     try {
50013       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
50014     } CALL_CATCH_EXCEPTION(0);
50015   }
50016
50017   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50018   return jresult;
50019 }
50020
50021
50022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
50023   void * jresult ;
50024   Dali::Toolkit::GaussianBlurView result;
50025
50026   {
50027     try {
50028       result = Dali::Toolkit::GaussianBlurView::New();
50029     } CALL_CATCH_EXCEPTION(0);
50030   }
50031
50032   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50033   return jresult;
50034 }
50035
50036
50037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
50038   void * jresult ;
50039   unsigned int arg1 ;
50040   float arg2 ;
50041   Dali::Pixel::Format arg3 ;
50042   float arg4 ;
50043   float arg5 ;
50044   bool arg6 ;
50045   Dali::Toolkit::GaussianBlurView result;
50046
50047   arg1 = (unsigned int)jarg1;
50048   arg2 = (float)jarg2;
50049   arg3 = (Dali::Pixel::Format)jarg3;
50050   arg4 = (float)jarg4;
50051   arg5 = (float)jarg5;
50052   arg6 = jarg6 ? true : false;
50053   {
50054     try {
50055       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
50056     } CALL_CATCH_EXCEPTION(0);
50057   }
50058
50059   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50060   return jresult;
50061 }
50062
50063
50064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
50065   void * jresult ;
50066   unsigned int arg1 ;
50067   float arg2 ;
50068   Dali::Pixel::Format arg3 ;
50069   float arg4 ;
50070   float arg5 ;
50071   Dali::Toolkit::GaussianBlurView result;
50072
50073   arg1 = (unsigned int)jarg1;
50074   arg2 = (float)jarg2;
50075   arg3 = (Dali::Pixel::Format)jarg3;
50076   arg4 = (float)jarg4;
50077   arg5 = (float)jarg5;
50078   {
50079     try {
50080       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
50081     } CALL_CATCH_EXCEPTION(0);
50082   }
50083
50084   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50085   return jresult;
50086 }
50087
50088
50089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
50090   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50091   Dali::Actor arg2 ;
50092   Dali::Actor *argp2 ;
50093
50094   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50095   argp2 = (Dali::Actor *)jarg2;
50096   if (!argp2) {
50097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50098     return ;
50099   }
50100   arg2 = *argp2;
50101   {
50102     try {
50103       (arg1)->Add(arg2);
50104     } CALL_CATCH_EXCEPTION();
50105   }
50106
50107 }
50108
50109
50110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
50111   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50112   Dali::Actor arg2 ;
50113   Dali::Actor *argp2 ;
50114
50115   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50116   argp2 = (Dali::Actor *)jarg2;
50117   if (!argp2) {
50118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50119     return ;
50120   }
50121   arg2 = *argp2;
50122   {
50123     try {
50124       (arg1)->Remove(arg2);
50125     } CALL_CATCH_EXCEPTION();
50126   }
50127
50128 }
50129
50130
50131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
50132   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50133
50134   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50135   {
50136     try {
50137       (arg1)->Activate();
50138     } CALL_CATCH_EXCEPTION();
50139   }
50140
50141 }
50142
50143
50144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
50145   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50146
50147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50148   {
50149     try {
50150       (arg1)->ActivateOnce();
50151     } CALL_CATCH_EXCEPTION();
50152   }
50153
50154 }
50155
50156
50157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
50158   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50159
50160   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50161   {
50162     try {
50163       (arg1)->Deactivate();
50164     } CALL_CATCH_EXCEPTION();
50165   }
50166
50167 }
50168
50169
50170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
50171   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50172   Dali::Texture arg2 ;
50173   Dali::FrameBuffer arg3 ;
50174   Dali::Texture *argp2 ;
50175   Dali::FrameBuffer *argp3 ;
50176
50177   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50178   argp2 = (Dali::Texture *)jarg2;
50179   if (!argp2) {
50180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
50181     return ;
50182   }
50183   arg2 = *argp2;
50184   argp3 = (Dali::FrameBuffer *)jarg3;
50185   if (!argp3) {
50186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50187     return ;
50188   }
50189   arg3 = *argp3;
50190   {
50191     try {
50192       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50193     } CALL_CATCH_EXCEPTION();
50194   }
50195
50196 }
50197
50198
50199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50200   int jresult ;
50201   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50202   Dali::Property::Index result;
50203
50204   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50205   {
50206     try {
50207       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50208     } CALL_CATCH_EXCEPTION(0);
50209   }
50210
50211   jresult = result;
50212   return jresult;
50213 }
50214
50215
50216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50217   void * jresult ;
50218   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50219   Dali::FrameBuffer result;
50220
50221   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50222   {
50223     try {
50224       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50225     } CALL_CATCH_EXCEPTION(0);
50226   }
50227
50228   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50229   return jresult;
50230 }
50231
50232
50233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50234   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50235   Dali::Vector4 *arg2 = 0 ;
50236
50237   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50238   arg2 = (Dali::Vector4 *)jarg2;
50239   if (!arg2) {
50240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50241     return ;
50242   }
50243   {
50244     try {
50245       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50246     } CALL_CATCH_EXCEPTION();
50247   }
50248
50249 }
50250
50251
50252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50253   void * jresult ;
50254   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50255   Dali::Vector4 result;
50256
50257   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50258   {
50259     try {
50260       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50261     } CALL_CATCH_EXCEPTION(0);
50262   }
50263
50264   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50265   return jresult;
50266 }
50267
50268
50269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50270   void * jresult ;
50271   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50272   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50273
50274   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50275   {
50276     try {
50277       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50278     } CALL_CATCH_EXCEPTION(0);
50279   }
50280
50281   jresult = (void *)result;
50282   return jresult;
50283 }
50284
50285
50286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50287   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50288
50289   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50290   {
50291     try {
50292       delete arg1;
50293     } CALL_CATCH_EXCEPTION();
50294   }
50295
50296 }
50297
50298
50299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50300   unsigned int jresult ;
50301   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50302   unsigned int result;
50303
50304   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50305   {
50306     try {
50307       result = (unsigned int)(arg1)->GetNumberOfPages();
50308     } CALL_CATCH_EXCEPTION(0);
50309   }
50310
50311   jresult = result;
50312   return jresult;
50313 }
50314
50315
50316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50317   void * jresult ;
50318   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50319   unsigned int arg2 ;
50320   Dali::Texture result;
50321
50322   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50323   arg2 = (unsigned int)jarg2;
50324   {
50325     try {
50326       result = (arg1)->NewPage(arg2);
50327     } CALL_CATCH_EXCEPTION(0);
50328   }
50329
50330   jresult = new Dali::Texture((const Dali::Texture &)result);
50331   return jresult;
50332 }
50333
50334
50335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50336   int jresult ;
50337   int result;
50338
50339   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50340   jresult = (int)result;
50341   return jresult;
50342 }
50343
50344
50345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50346   int jresult ;
50347   int result;
50348
50349   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50350   jresult = (int)result;
50351   return jresult;
50352 }
50353
50354
50355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50356   int jresult ;
50357   int result;
50358
50359   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50360   jresult = (int)result;
50361   return jresult;
50362 }
50363
50364
50365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50366   void * jresult ;
50367   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50368
50369   {
50370     try {
50371       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50372     } CALL_CATCH_EXCEPTION(0);
50373   }
50374
50375   jresult = (void *)result;
50376   return jresult;
50377 }
50378
50379
50380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50381   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50382
50383   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50384   {
50385     try {
50386       delete arg1;
50387     } CALL_CATCH_EXCEPTION();
50388   }
50389
50390 }
50391
50392
50393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50394   void * jresult ;
50395   Dali::Toolkit::PageTurnView *result = 0 ;
50396
50397   {
50398     try {
50399       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50400     } CALL_CATCH_EXCEPTION(0);
50401   }
50402
50403   jresult = (void *)result;
50404   return jresult;
50405 }
50406
50407
50408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50409   void * jresult ;
50410   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50411   Dali::Toolkit::PageTurnView *result = 0 ;
50412
50413   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50414   if (!arg1) {
50415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50416     return 0;
50417   }
50418   {
50419     try {
50420       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50421     } CALL_CATCH_EXCEPTION(0);
50422   }
50423
50424   jresult = (void *)result;
50425   return jresult;
50426 }
50427
50428
50429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50430   void * jresult ;
50431   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50432   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50433   Dali::Toolkit::PageTurnView *result = 0 ;
50434
50435   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50436   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50437   if (!arg2) {
50438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50439     return 0;
50440   }
50441   {
50442     try {
50443       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50444     } CALL_CATCH_EXCEPTION(0);
50445   }
50446
50447   jresult = (void *)result;
50448   return jresult;
50449 }
50450
50451
50452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50453   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50454
50455   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50456   {
50457     try {
50458       delete arg1;
50459     } CALL_CATCH_EXCEPTION();
50460   }
50461
50462 }
50463
50464
50465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50466   void * jresult ;
50467   Dali::BaseHandle arg1 ;
50468   Dali::BaseHandle *argp1 ;
50469   Dali::Toolkit::PageTurnView result;
50470
50471   argp1 = (Dali::BaseHandle *)jarg1;
50472   if (!argp1) {
50473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50474     return 0;
50475   }
50476   arg1 = *argp1;
50477   {
50478     try {
50479       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50480     } CALL_CATCH_EXCEPTION(0);
50481   }
50482
50483   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50484   return jresult;
50485 }
50486
50487
50488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50489   void * jresult ;
50490   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50491   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50492
50493   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50494   {
50495     try {
50496       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50497     } CALL_CATCH_EXCEPTION(0);
50498   }
50499
50500   jresult = (void *)result;
50501   return jresult;
50502 }
50503
50504
50505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
50506   void * jresult ;
50507   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50508   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50509
50510   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50511   {
50512     try {
50513       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
50514     } CALL_CATCH_EXCEPTION(0);
50515   }
50516
50517   jresult = (void *)result;
50518   return jresult;
50519 }
50520
50521
50522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50523   void * jresult ;
50524   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50525   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50526
50527   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50528   {
50529     try {
50530       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50531     } CALL_CATCH_EXCEPTION(0);
50532   }
50533
50534   jresult = (void *)result;
50535   return jresult;
50536 }
50537
50538
50539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
50540   void * jresult ;
50541   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50542   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50543
50544   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50545   {
50546     try {
50547       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
50548     } CALL_CATCH_EXCEPTION(0);
50549   }
50550
50551   jresult = (void *)result;
50552   return jresult;
50553 }
50554
50555
50556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50557   void * jresult ;
50558   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50559
50560   {
50561     try {
50562       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50563     } CALL_CATCH_EXCEPTION(0);
50564   }
50565
50566   jresult = (void *)result;
50567   return jresult;
50568 }
50569
50570
50571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50572   void * jresult ;
50573   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50574   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50575
50576   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50577   if (!arg1) {
50578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50579     return 0;
50580   }
50581   {
50582     try {
50583       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50584     } CALL_CATCH_EXCEPTION(0);
50585   }
50586
50587   jresult = (void *)result;
50588   return jresult;
50589 }
50590
50591
50592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50593   void * jresult ;
50594   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50595   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50596   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50597
50598   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50599   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50600   if (!arg2) {
50601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50602     return 0;
50603   }
50604   {
50605     try {
50606       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50607     } CALL_CATCH_EXCEPTION(0);
50608   }
50609
50610   jresult = (void *)result;
50611   return jresult;
50612 }
50613
50614
50615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50616   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50617
50618   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50619   {
50620     try {
50621       delete arg1;
50622     } CALL_CATCH_EXCEPTION();
50623   }
50624
50625 }
50626
50627
50628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50629   void * jresult ;
50630   Dali::Toolkit::PageFactory *arg1 = 0 ;
50631   Dali::Vector2 *arg2 = 0 ;
50632   Dali::Toolkit::PageTurnLandscapeView result;
50633
50634   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50635   if (!arg1) {
50636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50637     return 0;
50638   }
50639   arg2 = (Dali::Vector2 *)jarg2;
50640   if (!arg2) {
50641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50642     return 0;
50643   }
50644   {
50645     try {
50646       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50647     } CALL_CATCH_EXCEPTION(0);
50648   }
50649
50650   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50651   return jresult;
50652 }
50653
50654
50655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50656   void * jresult ;
50657   Dali::BaseHandle arg1 ;
50658   Dali::BaseHandle *argp1 ;
50659   Dali::Toolkit::PageTurnLandscapeView result;
50660
50661   argp1 = (Dali::BaseHandle *)jarg1;
50662   if (!argp1) {
50663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50664     return 0;
50665   }
50666   arg1 = *argp1;
50667   {
50668     try {
50669       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50670     } CALL_CATCH_EXCEPTION(0);
50671   }
50672
50673   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50674   return jresult;
50675 }
50676
50677
50678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50679   void * jresult ;
50680   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50681
50682   {
50683     try {
50684       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50685     } CALL_CATCH_EXCEPTION(0);
50686   }
50687
50688   jresult = (void *)result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50694   void * jresult ;
50695   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50696   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50697
50698   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50699   if (!arg1) {
50700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50701     return 0;
50702   }
50703   {
50704     try {
50705       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50706     } CALL_CATCH_EXCEPTION(0);
50707   }
50708
50709   jresult = (void *)result;
50710   return jresult;
50711 }
50712
50713
50714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50715   void * jresult ;
50716   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50717   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50718   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50719
50720   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50721   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50722   if (!arg2) {
50723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50724     return 0;
50725   }
50726   {
50727     try {
50728       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50729     } CALL_CATCH_EXCEPTION(0);
50730   }
50731
50732   jresult = (void *)result;
50733   return jresult;
50734 }
50735
50736
50737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50738   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50739
50740   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50741   {
50742     try {
50743       delete arg1;
50744     } CALL_CATCH_EXCEPTION();
50745   }
50746
50747 }
50748
50749
50750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50751   void * jresult ;
50752   Dali::Toolkit::PageFactory *arg1 = 0 ;
50753   Dali::Vector2 *arg2 = 0 ;
50754   Dali::Toolkit::PageTurnPortraitView result;
50755
50756   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50757   if (!arg1) {
50758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50759     return 0;
50760   }
50761   arg2 = (Dali::Vector2 *)jarg2;
50762   if (!arg2) {
50763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50764     return 0;
50765   }
50766   {
50767     try {
50768       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50769     } CALL_CATCH_EXCEPTION(0);
50770   }
50771
50772   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50773   return jresult;
50774 }
50775
50776
50777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50778   void * jresult ;
50779   Dali::BaseHandle arg1 ;
50780   Dali::BaseHandle *argp1 ;
50781   Dali::Toolkit::PageTurnPortraitView result;
50782
50783   argp1 = (Dali::BaseHandle *)jarg1;
50784   if (!argp1) {
50785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50786     return 0;
50787   }
50788   arg1 = *argp1;
50789   {
50790     try {
50791       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50792     } CALL_CATCH_EXCEPTION(0);
50793   }
50794
50795   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50796   return jresult;
50797 }
50798
50799
50800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50801   int jresult ;
50802   int result;
50803
50804   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50805   jresult = (int)result;
50806   return jresult;
50807 }
50808
50809
50810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50811   int jresult ;
50812   int result;
50813
50814   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50815   jresult = (int)result;
50816   return jresult;
50817 }
50818
50819
50820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50821   int jresult ;
50822   int result;
50823
50824   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50825   jresult = (int)result;
50826   return jresult;
50827 }
50828
50829
50830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50831   void * jresult ;
50832   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50833
50834   {
50835     try {
50836       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50837     } CALL_CATCH_EXCEPTION(0);
50838   }
50839
50840   jresult = (void *)result;
50841   return jresult;
50842 }
50843
50844
50845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50846   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50847
50848   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50849   {
50850     try {
50851       delete arg1;
50852     } CALL_CATCH_EXCEPTION();
50853   }
50854
50855 }
50856
50857
50858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50859   void * jresult ;
50860   Dali::Toolkit::ToggleButton *result = 0 ;
50861
50862   {
50863     try {
50864       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50865     } CALL_CATCH_EXCEPTION(0);
50866   }
50867
50868   jresult = (void *)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50874   void * jresult ;
50875   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50876   Dali::Toolkit::ToggleButton *result = 0 ;
50877
50878   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50879   if (!arg1) {
50880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50881     return 0;
50882   }
50883   {
50884     try {
50885       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50886     } CALL_CATCH_EXCEPTION(0);
50887   }
50888
50889   jresult = (void *)result;
50890   return jresult;
50891 }
50892
50893
50894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50895   void * jresult ;
50896   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50897   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50898   Dali::Toolkit::ToggleButton *result = 0 ;
50899
50900   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50901   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50902   if (!arg2) {
50903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50904     return 0;
50905   }
50906   {
50907     try {
50908       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50909     } CALL_CATCH_EXCEPTION(0);
50910   }
50911
50912   jresult = (void *)result;
50913   return jresult;
50914 }
50915
50916
50917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50918   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50919
50920   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50921   {
50922     try {
50923       delete arg1;
50924     } CALL_CATCH_EXCEPTION();
50925   }
50926
50927 }
50928
50929
50930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50931   void * jresult ;
50932   Dali::Toolkit::ToggleButton result;
50933
50934   {
50935     try {
50936       result = Dali::Toolkit::ToggleButton::New();
50937     } CALL_CATCH_EXCEPTION(0);
50938   }
50939
50940   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
50946   void * jresult ;
50947   Dali::BaseHandle arg1 ;
50948   Dali::BaseHandle *argp1 ;
50949   Dali::Toolkit::ToggleButton result;
50950
50951   argp1 = (Dali::BaseHandle *)jarg1;
50952   if (!argp1) {
50953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50954     return 0;
50955   }
50956   arg1 = *argp1;
50957   {
50958     try {
50959       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
50960     } CALL_CATCH_EXCEPTION(0);
50961   }
50962
50963   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50964   return jresult;
50965 }
50966
50967
50968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
50969   void * jresult ;
50970   Dali::Toolkit::Visual::Base *result = 0 ;
50971
50972   {
50973     try {
50974       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
50975     } CALL_CATCH_EXCEPTION(0);
50976   }
50977
50978   jresult = (void *)result;
50979   return jresult;
50980 }
50981
50982
50983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
50984   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50985
50986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50987   {
50988     try {
50989       delete arg1;
50990     } CALL_CATCH_EXCEPTION();
50991   }
50992
50993 }
50994
50995
50996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
50997   void * jresult ;
50998   Dali::Toolkit::Visual::Base *arg1 = 0 ;
50999   Dali::Toolkit::Visual::Base *result = 0 ;
51000
51001   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51002   if (!arg1) {
51003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51004     return 0;
51005   }
51006   {
51007     try {
51008       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
51009     } CALL_CATCH_EXCEPTION(0);
51010   }
51011
51012   jresult = (void *)result;
51013   return jresult;
51014 }
51015
51016
51017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
51018   void * jresult ;
51019   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51020   Dali::Toolkit::Visual::Base *arg2 = 0 ;
51021   Dali::Toolkit::Visual::Base *result = 0 ;
51022
51023   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51024   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
51025   if (!arg2) {
51026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51027     return 0;
51028   }
51029   {
51030     try {
51031       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
51032     } CALL_CATCH_EXCEPTION(0);
51033   }
51034
51035   jresult = (void *)result;
51036   return jresult;
51037 }
51038
51039
51040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
51041   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51042   std::string *arg2 = 0 ;
51043
51044   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51045   if (!jarg2) {
51046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51047     return ;
51048   }
51049   std::string arg2_str(jarg2);
51050   arg2 = &arg2_str;
51051   {
51052     try {
51053       (arg1)->SetName((std::string const &)*arg2);
51054     } CALL_CATCH_EXCEPTION();
51055   }
51056
51057
51058   //argout typemap for const std::string&
51059
51060 }
51061
51062
51063 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
51064   char * jresult ;
51065   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51066   std::string *result = 0 ;
51067
51068   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51069   {
51070     try {
51071       result = (std::string *) &(arg1)->GetName();
51072     } CALL_CATCH_EXCEPTION(0);
51073   }
51074
51075   jresult = SWIG_csharp_string_callback(result->c_str());
51076   return jresult;
51077 }
51078
51079
51080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
51081   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51082   Dali::Property::Map *arg2 = 0 ;
51083   Dali::Size arg3 ;
51084   Dali::Size *argp3 ;
51085
51086   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51087   arg2 = (Dali::Property::Map *)jarg2;
51088   if (!arg2) {
51089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51090     return ;
51091   }
51092   argp3 = (Dali::Size *)jarg3;
51093   if (!argp3) {
51094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
51095     return ;
51096   }
51097   arg3 = *argp3;
51098   {
51099     try {
51100       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
51101     } CALL_CATCH_EXCEPTION();
51102   }
51103
51104 }
51105
51106
51107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
51108   float jresult ;
51109   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51110   float arg2 ;
51111   float result;
51112
51113   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51114   arg2 = (float)jarg2;
51115   {
51116     try {
51117       result = (float)(arg1)->GetHeightForWidth(arg2);
51118     } CALL_CATCH_EXCEPTION(0);
51119   }
51120
51121   jresult = result;
51122   return jresult;
51123 }
51124
51125
51126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
51127   float jresult ;
51128   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51129   float arg2 ;
51130   float result;
51131
51132   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51133   arg2 = (float)jarg2;
51134   {
51135     try {
51136       result = (float)(arg1)->GetWidthForHeight(arg2);
51137     } CALL_CATCH_EXCEPTION(0);
51138   }
51139
51140   jresult = result;
51141   return jresult;
51142 }
51143
51144
51145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
51146   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51147   Dali::Vector2 *arg2 = 0 ;
51148
51149   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51150   arg2 = (Dali::Vector2 *)jarg2;
51151   if (!arg2) {
51152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
51153     return ;
51154   }
51155   {
51156     try {
51157       (arg1)->GetNaturalSize(*arg2);
51158     } CALL_CATCH_EXCEPTION();
51159   }
51160
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
51165   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51166   float arg2 ;
51167
51168   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51169   arg2 = (int)jarg2;
51170   {
51171     try {
51172       (arg1)->SetDepthIndex(arg2);
51173     } CALL_CATCH_EXCEPTION();
51174   }
51175
51176 }
51177
51178
51179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
51180   int jresult ;
51181   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51182   int result;
51183
51184   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51185   {
51186     try {
51187       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51188     } CALL_CATCH_EXCEPTION(0);
51189   }
51190
51191   jresult = result;
51192   return jresult;
51193 }
51194
51195
51196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51197   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51198   Dali::Property::Map *arg2 = 0 ;
51199
51200   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51201   arg2 = (Dali::Property::Map *)jarg2;
51202   if (!arg2) {
51203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51204     return ;
51205   }
51206   {
51207     try {
51208       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51209     } CALL_CATCH_EXCEPTION();
51210   }
51211
51212 }
51213
51214
51215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51216   void * jresult ;
51217   Dali::Toolkit::VisualFactory result;
51218
51219   {
51220     try {
51221       result = Dali::Toolkit::VisualFactory::Get();
51222     } CALL_CATCH_EXCEPTION(0);
51223   }
51224
51225   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51226   return jresult;
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51231   void * jresult ;
51232   Dali::Toolkit::VisualFactory *result = 0 ;
51233
51234   {
51235     try {
51236       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51237     } CALL_CATCH_EXCEPTION(0);
51238   }
51239
51240   jresult = (void *)result;
51241   return jresult;
51242 }
51243
51244
51245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51246   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51247
51248   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51249   {
51250     try {
51251       delete arg1;
51252     } CALL_CATCH_EXCEPTION();
51253   }
51254
51255 }
51256
51257
51258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51259   void * jresult ;
51260   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51261   Dali::Toolkit::VisualFactory *result = 0 ;
51262
51263   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51264   if (!arg1) {
51265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51266     return 0;
51267   }
51268   {
51269     try {
51270       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51271     } CALL_CATCH_EXCEPTION(0);
51272   }
51273
51274   jresult = (void *)result;
51275   return jresult;
51276 }
51277
51278
51279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51280   void * jresult ;
51281   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51282   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51283   Dali::Toolkit::VisualFactory *result = 0 ;
51284
51285   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51286   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51287   if (!arg2) {
51288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51289     return 0;
51290   }
51291   {
51292     try {
51293       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51294     } CALL_CATCH_EXCEPTION(0);
51295   }
51296
51297   jresult = (void *)result;
51298   return jresult;
51299 }
51300
51301
51302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51303   void * jresult ;
51304   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51305   Dali::Property::Map *arg2 = 0 ;
51306   Dali::Toolkit::Visual::Base result;
51307
51308   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51309   arg2 = (Dali::Property::Map *)jarg2;
51310   if (!arg2) {
51311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51312     return 0;
51313   }
51314   {
51315     try {
51316       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51317     } CALL_CATCH_EXCEPTION(0);
51318   }
51319
51320   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51321   return jresult;
51322 }
51323
51324
51325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51326   void * jresult ;
51327   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51328   std::string *arg2 = 0 ;
51329   Dali::ImageDimensions arg3 ;
51330   Dali::ImageDimensions *argp3 ;
51331   Dali::Toolkit::Visual::Base result;
51332
51333   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51334   if (!jarg2) {
51335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51336     return 0;
51337   }
51338   std::string arg2_str(jarg2);
51339   arg2 = &arg2_str;
51340   argp3 = (Dali::ImageDimensions *)jarg3;
51341   if (!argp3) {
51342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51343     return 0;
51344   }
51345   arg3 = *argp3;
51346   {
51347     try {
51348       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51349     } CALL_CATCH_EXCEPTION(0);
51350   }
51351
51352   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51353
51354   //argout typemap for const std::string&
51355
51356   return jresult;
51357 }
51358
51359
51360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51361   void * jresult ;
51362   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51363
51364   {
51365     try {
51366       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51367     } CALL_CATCH_EXCEPTION(0);
51368   }
51369
51370   jresult = (void *)result;
51371   return jresult;
51372 }
51373
51374
51375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51376   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51377
51378   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51379   {
51380     try {
51381       delete arg1;
51382     } CALL_CATCH_EXCEPTION();
51383   }
51384
51385 }
51386
51387
51388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51389   void * jresult ;
51390   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51391   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51392
51393   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51394   if (!arg1) {
51395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51396     return 0;
51397   }
51398   {
51399     try {
51400       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51401     } CALL_CATCH_EXCEPTION(0);
51402   }
51403
51404   jresult = (void *)result;
51405   return jresult;
51406 }
51407
51408
51409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51410   void * jresult ;
51411   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51412   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51413   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51414
51415   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51416   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51417   if (!arg2) {
51418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51419     return 0;
51420   }
51421   {
51422     try {
51423       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51424     } CALL_CATCH_EXCEPTION(0);
51425   }
51426
51427   jresult = (void *)result;
51428   return jresult;
51429 }
51430
51431
51432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51433   void * jresult ;
51434   Dali::Toolkit::AsyncImageLoader result;
51435
51436   {
51437     try {
51438       result = Dali::Toolkit::AsyncImageLoader::New();
51439     } CALL_CATCH_EXCEPTION(0);
51440   }
51441
51442   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51443   return jresult;
51444 }
51445
51446
51447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51448   void * jresult ;
51449   Dali::BaseHandle arg1 ;
51450   Dali::BaseHandle *argp1 ;
51451   Dali::Toolkit::AsyncImageLoader result;
51452
51453   argp1 = (Dali::BaseHandle *)jarg1;
51454   if (!argp1) {
51455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51456     return 0;
51457   }
51458   arg1 = *argp1;
51459   {
51460     try {
51461       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51462     } CALL_CATCH_EXCEPTION(0);
51463   }
51464
51465   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51466   return jresult;
51467 }
51468
51469
51470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51471   unsigned int jresult ;
51472   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51473   std::string *arg2 = 0 ;
51474   uint32_t result;
51475
51476   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51477   if (!jarg2) {
51478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51479     return 0;
51480   }
51481   std::string arg2_str(jarg2);
51482   arg2 = &arg2_str;
51483   {
51484     try {
51485       result = (arg1)->Load((std::string const &)*arg2);
51486     } CALL_CATCH_EXCEPTION(0);
51487   }
51488
51489   jresult = result;
51490
51491   //argout typemap for const std::string&
51492
51493   return jresult;
51494 }
51495
51496
51497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51498   unsigned int jresult ;
51499   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51500   std::string *arg2 = 0 ;
51501   Dali::ImageDimensions arg3 ;
51502   Dali::ImageDimensions *argp3 ;
51503   uint32_t result;
51504
51505   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51506   if (!jarg2) {
51507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51508     return 0;
51509   }
51510   std::string arg2_str(jarg2);
51511   arg2 = &arg2_str;
51512   argp3 = (Dali::ImageDimensions *)jarg3;
51513   if (!argp3) {
51514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51515     return 0;
51516   }
51517   arg3 = *argp3;
51518   {
51519     try {
51520       result = (arg1)->Load((std::string const &)*arg2,arg3);
51521     } CALL_CATCH_EXCEPTION(0);
51522   }
51523
51524   jresult = result;
51525
51526   //argout typemap for const std::string&
51527
51528   return jresult;
51529 }
51530
51531
51532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51533   unsigned int jresult ;
51534   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51535   std::string *arg2 = 0 ;
51536   Dali::ImageDimensions arg3 ;
51537   Dali::FittingMode::Type arg4 ;
51538   Dali::SamplingMode::Type arg5 ;
51539   bool arg6 ;
51540   Dali::ImageDimensions *argp3 ;
51541   uint32_t result;
51542
51543   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51544   if (!jarg2) {
51545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51546     return 0;
51547   }
51548   std::string arg2_str(jarg2);
51549   arg2 = &arg2_str;
51550   argp3 = (Dali::ImageDimensions *)jarg3;
51551   if (!argp3) {
51552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51553     return 0;
51554   }
51555   arg3 = *argp3;
51556   arg4 = (Dali::FittingMode::Type)jarg4;
51557   arg5 = (Dali::SamplingMode::Type)jarg5;
51558   arg6 = jarg6 ? true : false;
51559   {
51560     try {
51561       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51562     } CALL_CATCH_EXCEPTION(0);
51563   }
51564
51565   jresult = result;
51566
51567   //argout typemap for const std::string&
51568
51569   return jresult;
51570 }
51571
51572
51573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51574   unsigned int jresult ;
51575   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51576   uint32_t arg2 ;
51577   bool result;
51578
51579   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51580   arg2 = (uint32_t)jarg2;
51581   {
51582     try {
51583       result = (bool)(arg1)->Cancel(arg2);
51584     } CALL_CATCH_EXCEPTION(0);
51585   }
51586
51587   jresult = result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51593   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51594
51595   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51596   {
51597     try {
51598       (arg1)->CancelAll();
51599     } CALL_CATCH_EXCEPTION();
51600   }
51601
51602 }
51603
51604
51605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51606   void * jresult ;
51607   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51608   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51609
51610   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51611   {
51612     try {
51613       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51614     } CALL_CATCH_EXCEPTION(0);
51615   }
51616
51617   jresult = (void *)result;
51618   return jresult;
51619 }
51620
51621
51622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51623   void * jresult ;
51624   std::string *arg1 = 0 ;
51625   Dali::PixelData result;
51626
51627   if (!jarg1) {
51628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51629     return 0;
51630   }
51631   std::string arg1_str(jarg1);
51632   arg1 = &arg1_str;
51633   {
51634     try {
51635       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51636     } CALL_CATCH_EXCEPTION(0);
51637   }
51638
51639   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51640
51641   //argout typemap for const std::string&
51642
51643   return jresult;
51644 }
51645
51646
51647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51648   void * jresult ;
51649   std::string *arg1 = 0 ;
51650   Dali::ImageDimensions arg2 ;
51651   Dali::ImageDimensions *argp2 ;
51652   Dali::PixelData result;
51653
51654   if (!jarg1) {
51655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51656     return 0;
51657   }
51658   std::string arg1_str(jarg1);
51659   arg1 = &arg1_str;
51660   argp2 = (Dali::ImageDimensions *)jarg2;
51661   if (!argp2) {
51662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51663     return 0;
51664   }
51665   arg2 = *argp2;
51666   {
51667     try {
51668       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51669     } CALL_CATCH_EXCEPTION(0);
51670   }
51671
51672   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51673
51674   //argout typemap for const std::string&
51675
51676   return jresult;
51677 }
51678
51679
51680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51681   void * jresult ;
51682   std::string *arg1 = 0 ;
51683   Dali::ImageDimensions arg2 ;
51684   Dali::FittingMode::Type arg3 ;
51685   Dali::SamplingMode::Type arg4 ;
51686   bool arg5 ;
51687   Dali::ImageDimensions *argp2 ;
51688   Dali::PixelData result;
51689
51690   if (!jarg1) {
51691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51692     return 0;
51693   }
51694   std::string arg1_str(jarg1);
51695   arg1 = &arg1_str;
51696   argp2 = (Dali::ImageDimensions *)jarg2;
51697   if (!argp2) {
51698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51699     return 0;
51700   }
51701   arg2 = *argp2;
51702   arg3 = (Dali::FittingMode::Type)jarg3;
51703   arg4 = (Dali::SamplingMode::Type)jarg4;
51704   arg5 = jarg5 ? true : false;
51705   {
51706     try {
51707       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51708     } CALL_CATCH_EXCEPTION(0);
51709   }
51710
51711   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51712
51713   //argout typemap for const std::string&
51714
51715   return jresult;
51716 }
51717
51718
51719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51720   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51721
51722   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51723   {
51724     try {
51725       delete arg1;
51726     } CALL_CATCH_EXCEPTION();
51727   }
51728
51729 }
51730
51731
51732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51733   void * jresult ;
51734   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51735   Dali::Actor arg2 ;
51736   Dali::Actor arg3 ;
51737   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51738   Dali::Actor *argp2 ;
51739   Dali::Actor *argp3 ;
51740   Dali::Actor result;
51741
51742   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51743   argp2 = (Dali::Actor *)jarg2;
51744   if (!argp2) {
51745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51746     return 0;
51747   }
51748   arg2 = *argp2;
51749   argp3 = (Dali::Actor *)jarg3;
51750   if (!argp3) {
51751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51752     return 0;
51753   }
51754   arg3 = *argp3;
51755   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51756   {
51757     try {
51758       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51759     } CALL_CATCH_EXCEPTION(0);
51760   }
51761
51762   jresult = new Dali::Actor((const Dali::Actor &)result);
51763   return jresult;
51764 }
51765
51766
51767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51768   void * jresult ;
51769   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51770
51771   {
51772     try {
51773       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51774     } CALL_CATCH_EXCEPTION(0);
51775   }
51776
51777   jresult = (void *)result;
51778   return jresult;
51779 }
51780
51781
51782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51783   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51784   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51785   if (director) {
51786     director->swig_connect_director(callback0);
51787   }
51788 }
51789
51790
51791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51792   void * jresult ;
51793   Dali::FrameCallbackInterface *result = 0 ;
51794
51795   {
51796     try {
51797       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51798     } CALL_CATCH_EXCEPTION(0);
51799   }
51800
51801   jresult = (void *)result;
51802   return jresult;
51803 }
51804
51805 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51806   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51807   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51808   return proxy->GetPosition(id, *vector3);
51809 }
51810
51811 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51812   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51813   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51814   return proxy->SetPosition(id, *vector3);
51815 }
51816
51817 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51818   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51819   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51820   return proxy->BakePosition(id, *vector3);
51821 }
51822
51823 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51824   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51825   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51826   return proxy->GetSize(id, *vector3);
51827 }
51828
51829 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51830   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51831   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51832   return proxy->SetSize(id, *vector3);
51833 }
51834 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51835   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51836   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51837   return proxy->BakeSize(id, *vector3);
51838 }
51839
51840 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51841   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51842   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51843   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51844   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51845 }
51846
51847 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51848   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51849   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51850   return proxy->GetScale(id,* vector3);
51851 }
51852
51853 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51854   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51855   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51856   return proxy->SetScale(id, *vector3);
51857 }
51858
51859 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51860   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51861   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51862   return proxy->BakeScale(id, *vector3);
51863 }
51864
51865 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51866   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51867   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51868   return proxy->GetColor(id, *vector4);
51869 }
51870
51871 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51872   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51873   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51874   return proxy->SetColor(id, *vector4);
51875 }
51876
51877 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51878   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51879   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51880   return proxy->BakeColor(id, *vector4);
51881 }
51882
51883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51884   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51885   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51886
51887   Dali::Stage *arg1 = (Dali::Stage *) 0;
51888   Dali::Actor *arg3 = 0;
51889
51890   arg1 = (Dali::Stage *)jarg1;
51891   arg3 = (Dali::Actor *)jarg3;
51892
51893   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51894   return;
51895 }
51896
51897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51898
51899   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51900   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51901
51902   Dali::Stage *arg1 = (Dali::Stage *) 0;
51903
51904   arg1 = (Dali::Stage *)jarg1;
51905
51906   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51907   return;
51908 }
51909
51910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51911   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51912   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51913   if (director) {
51914     director->swig_connect_director(callback0);
51915   }
51916 }
51917
51918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51919   KeyboardFocusManager arg1 ;
51920   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51921   KeyboardFocusManager *argp1 ;
51922
51923   argp1 = (KeyboardFocusManager *)jarg1;
51924   if (!argp1) {
51925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51926     return ;
51927   }
51928   arg1 = *argp1;
51929   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51930   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51931   {
51932     try {
51933       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51934     } CALL_CATCH_EXCEPTION();
51935   }
51936
51937 }
51938
51939
51940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51941   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51942
51943   arg1 = (std::vector< unsigned int > *)jarg1;
51944   {
51945     try {
51946       (arg1)->clear();
51947     } CALL_CATCH_EXCEPTION();
51948   }
51949
51950 }
51951
51952
51953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
51954   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51955   unsigned int *arg2 = 0 ;
51956   unsigned int temp2 ;
51957
51958   arg1 = (std::vector< unsigned int > *)jarg1;
51959   temp2 = (unsigned int)jarg2;
51960   arg2 = &temp2;
51961   {
51962     try {
51963       (arg1)->push_back((unsigned int const &)*arg2);
51964     } CALL_CATCH_EXCEPTION();
51965   }
51966
51967 }
51968
51969
51970 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
51971   unsigned long jresult ;
51972   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51973   std::vector< unsigned int >::size_type result;
51974
51975   arg1 = (std::vector< unsigned int > *)jarg1;
51976   {
51977     try {
51978       result = ((std::vector< unsigned int > const *)arg1)->size();
51979     } CALL_CATCH_EXCEPTION(0);
51980   }
51981
51982   jresult = (unsigned long)result;
51983   return jresult;
51984 }
51985
51986
51987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
51988   unsigned long jresult ;
51989   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51990   std::vector< unsigned int >::size_type result;
51991
51992   arg1 = (std::vector< unsigned int > *)jarg1;
51993   {
51994     try {
51995       result = ((std::vector< unsigned int > const *)arg1)->capacity();
51996     } CALL_CATCH_EXCEPTION(0);
51997   }
51998
51999   jresult = (unsigned long)result;
52000   return jresult;
52001 }
52002
52003
52004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
52005   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52006   std::vector< unsigned int >::size_type arg2 ;
52007
52008   arg1 = (std::vector< unsigned int > *)jarg1;
52009   arg2 = (std::vector< unsigned int >::size_type)jarg2;
52010   {
52011     try {
52012       (arg1)->reserve(arg2);
52013     } CALL_CATCH_EXCEPTION();
52014   }
52015
52016 }
52017
52018
52019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
52020   void * jresult ;
52021   std::vector< unsigned int > *result = 0 ;
52022
52023   {
52024     try {
52025       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
52026     } CALL_CATCH_EXCEPTION(0);
52027   }
52028
52029   jresult = (void *)result;
52030   return jresult;
52031 }
52032
52033
52034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
52035   void * jresult ;
52036   std::vector< unsigned int > *arg1 = 0 ;
52037   std::vector< unsigned int > *result = 0 ;
52038
52039   arg1 = (std::vector< unsigned int > *)jarg1;
52040   if (!arg1) {
52041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52042     return 0;
52043   }
52044   {
52045     try {
52046       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
52047     } CALL_CATCH_EXCEPTION(0);
52048   }
52049
52050   jresult = (void *)result;
52051   return jresult;
52052 }
52053
52054
52055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
52056   void * jresult ;
52057   int arg1 ;
52058   std::vector< unsigned int > *result = 0 ;
52059
52060   arg1 = (int)jarg1;
52061   {
52062     try {
52063       try {
52064         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
52065       }
52066       catch(std::out_of_range &_e) {
52067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52068         return 0;
52069       }
52070
52071     } CALL_CATCH_EXCEPTION(0);
52072   }
52073
52074   jresult = (void *)result;
52075   return jresult;
52076 }
52077
52078
52079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
52080   unsigned int jresult ;
52081   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52082   int arg2 ;
52083   unsigned int result;
52084
52085   arg1 = (std::vector< unsigned int > *)jarg1;
52086   arg2 = (int)jarg2;
52087   {
52088     try {
52089       try {
52090         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
52091       }
52092       catch(std::out_of_range &_e) {
52093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52094         return 0;
52095       }
52096
52097     } CALL_CATCH_EXCEPTION(0);
52098   }
52099
52100   jresult = result;
52101   return jresult;
52102 }
52103
52104
52105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
52106   unsigned int jresult ;
52107   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52108   int arg2 ;
52109   unsigned int *result = 0 ;
52110
52111   arg1 = (std::vector< unsigned int > *)jarg1;
52112   arg2 = (int)jarg2;
52113   {
52114     try {
52115       try {
52116         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
52117       }
52118       catch(std::out_of_range &_e) {
52119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52120         return 0;
52121       }
52122
52123     } CALL_CATCH_EXCEPTION(0);
52124   }
52125
52126   jresult = *result;
52127   return jresult;
52128 }
52129
52130
52131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
52132   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52133   int arg2 ;
52134   unsigned int *arg3 = 0 ;
52135   unsigned int temp3 ;
52136
52137   arg1 = (std::vector< unsigned int > *)jarg1;
52138   arg2 = (int)jarg2;
52139   temp3 = (unsigned int)jarg3;
52140   arg3 = &temp3;
52141   {
52142     try {
52143       try {
52144         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
52145       }
52146       catch(std::out_of_range &_e) {
52147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52148         return ;
52149       }
52150
52151     } CALL_CATCH_EXCEPTION();
52152   }
52153
52154 }
52155
52156
52157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
52158   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52159   std::vector< unsigned int > *arg2 = 0 ;
52160
52161   arg1 = (std::vector< unsigned int > *)jarg1;
52162   arg2 = (std::vector< unsigned int > *)jarg2;
52163   if (!arg2) {
52164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52165     return ;
52166   }
52167   {
52168     try {
52169       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
52170     } CALL_CATCH_EXCEPTION();
52171   }
52172
52173 }
52174
52175
52176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52177   void * jresult ;
52178   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52179   int arg2 ;
52180   int arg3 ;
52181   std::vector< unsigned int > *result = 0 ;
52182
52183   arg1 = (std::vector< unsigned int > *)jarg1;
52184   arg2 = (int)jarg2;
52185   arg3 = (int)jarg3;
52186   {
52187     try {
52188       try {
52189         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52190       }
52191       catch(std::out_of_range &_e) {
52192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52193         return 0;
52194       }
52195       catch(std::invalid_argument &_e) {
52196         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52197         return 0;
52198       }
52199
52200     } CALL_CATCH_EXCEPTION(0);
52201   }
52202
52203   jresult = (void *)result;
52204   return jresult;
52205 }
52206
52207
52208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52209   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52210   int arg2 ;
52211   unsigned int *arg3 = 0 ;
52212   unsigned int temp3 ;
52213
52214   arg1 = (std::vector< unsigned int > *)jarg1;
52215   arg2 = (int)jarg2;
52216   temp3 = (unsigned int)jarg3;
52217   arg3 = &temp3;
52218   {
52219     try {
52220       try {
52221         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52222       }
52223       catch(std::out_of_range &_e) {
52224         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52225         return ;
52226       }
52227
52228     } CALL_CATCH_EXCEPTION();
52229   }
52230
52231 }
52232
52233
52234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52235   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52236   int arg2 ;
52237   std::vector< unsigned int > *arg3 = 0 ;
52238
52239   arg1 = (std::vector< unsigned int > *)jarg1;
52240   arg2 = (int)jarg2;
52241   arg3 = (std::vector< unsigned int > *)jarg3;
52242   if (!arg3) {
52243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52244     return ;
52245   }
52246   {
52247     try {
52248       try {
52249         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52250       }
52251       catch(std::out_of_range &_e) {
52252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52253         return ;
52254       }
52255
52256     } CALL_CATCH_EXCEPTION();
52257   }
52258
52259 }
52260
52261
52262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52264   int arg2 ;
52265
52266   arg1 = (std::vector< unsigned int > *)jarg1;
52267   arg2 = (int)jarg2;
52268   {
52269     try {
52270       try {
52271         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52272       }
52273       catch(std::out_of_range &_e) {
52274         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52275         return ;
52276       }
52277
52278     } CALL_CATCH_EXCEPTION();
52279   }
52280
52281 }
52282
52283
52284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52285   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52286   int arg2 ;
52287   int arg3 ;
52288
52289   arg1 = (std::vector< unsigned int > *)jarg1;
52290   arg2 = (int)jarg2;
52291   arg3 = (int)jarg3;
52292   {
52293     try {
52294       try {
52295         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52296       }
52297       catch(std::out_of_range &_e) {
52298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52299         return ;
52300       }
52301       catch(std::invalid_argument &_e) {
52302         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52303         return ;
52304       }
52305
52306     } CALL_CATCH_EXCEPTION();
52307   }
52308
52309 }
52310
52311
52312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52313   void * jresult ;
52314   unsigned int *arg1 = 0 ;
52315   int arg2 ;
52316   unsigned int temp1 ;
52317   std::vector< unsigned int > *result = 0 ;
52318
52319   temp1 = (unsigned int)jarg1;
52320   arg1 = &temp1;
52321   arg2 = (int)jarg2;
52322   {
52323     try {
52324       try {
52325         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52326       }
52327       catch(std::out_of_range &_e) {
52328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52329         return 0;
52330       }
52331
52332     } CALL_CATCH_EXCEPTION(0);
52333   }
52334
52335   jresult = (void *)result;
52336   return jresult;
52337 }
52338
52339
52340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52341   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52342
52343   arg1 = (std::vector< unsigned int > *)jarg1;
52344   {
52345     try {
52346       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52347     } CALL_CATCH_EXCEPTION();
52348   }
52349
52350 }
52351
52352
52353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52354   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52355   int arg2 ;
52356   int arg3 ;
52357
52358   arg1 = (std::vector< unsigned int > *)jarg1;
52359   arg2 = (int)jarg2;
52360   arg3 = (int)jarg3;
52361   {
52362     try {
52363       try {
52364         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52365       }
52366       catch(std::out_of_range &_e) {
52367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52368         return ;
52369       }
52370       catch(std::invalid_argument &_e) {
52371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52372         return ;
52373       }
52374
52375     } CALL_CATCH_EXCEPTION();
52376   }
52377
52378 }
52379
52380
52381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52382   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52383   int arg2 ;
52384   std::vector< unsigned int > *arg3 = 0 ;
52385
52386   arg1 = (std::vector< unsigned int > *)jarg1;
52387   arg2 = (int)jarg2;
52388   arg3 = (std::vector< unsigned int > *)jarg3;
52389   if (!arg3) {
52390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52391     return ;
52392   }
52393   {
52394     try {
52395       try {
52396         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52397       }
52398       catch(std::out_of_range &_e) {
52399         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52400         return ;
52401       }
52402
52403     } CALL_CATCH_EXCEPTION();
52404   }
52405
52406 }
52407
52408
52409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52410   unsigned int jresult ;
52411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52412   unsigned int *arg2 = 0 ;
52413   unsigned int temp2 ;
52414   bool result;
52415
52416   arg1 = (std::vector< unsigned int > *)jarg1;
52417   temp2 = (unsigned int)jarg2;
52418   arg2 = &temp2;
52419   {
52420     try {
52421       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52422     } CALL_CATCH_EXCEPTION(0);
52423   }
52424
52425   jresult = result;
52426   return jresult;
52427 }
52428
52429
52430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52431   int jresult ;
52432   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52433   unsigned int *arg2 = 0 ;
52434   unsigned int temp2 ;
52435   int result;
52436
52437   arg1 = (std::vector< unsigned int > *)jarg1;
52438   temp2 = (unsigned int)jarg2;
52439   arg2 = &temp2;
52440   {
52441     try {
52442       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52443     } CALL_CATCH_EXCEPTION(0);
52444   }
52445
52446   jresult = result;
52447   return jresult;
52448 }
52449
52450
52451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52452   int jresult ;
52453   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52454   unsigned int *arg2 = 0 ;
52455   unsigned int temp2 ;
52456   int result;
52457
52458   arg1 = (std::vector< unsigned int > *)jarg1;
52459   temp2 = (unsigned int)jarg2;
52460   arg2 = &temp2;
52461   {
52462     try {
52463       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52464     } CALL_CATCH_EXCEPTION(0);
52465   }
52466
52467   jresult = result;
52468   return jresult;
52469 }
52470
52471
52472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52473   unsigned int jresult ;
52474   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52475   unsigned int *arg2 = 0 ;
52476   unsigned int temp2 ;
52477   bool result;
52478
52479   arg1 = (std::vector< unsigned int > *)jarg1;
52480   temp2 = (unsigned int)jarg2;
52481   arg2 = &temp2;
52482   {
52483     try {
52484       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52485     } CALL_CATCH_EXCEPTION(0);
52486   }
52487
52488   jresult = result;
52489   return jresult;
52490 }
52491
52492
52493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52494   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52495
52496   arg1 = (std::vector< unsigned int > *)jarg1;
52497   {
52498     try {
52499       delete arg1;
52500     } CALL_CATCH_EXCEPTION();
52501   }
52502
52503 }
52504
52505
52506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52507   void * jresult ;
52508   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52509
52510   {
52511     try {
52512       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52513     } CALL_CATCH_EXCEPTION(0);
52514   }
52515
52516   jresult = (void *)result;
52517   return jresult;
52518 }
52519
52520
52521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52522   void * jresult ;
52523   unsigned int arg1 ;
52524   Dali::Actor arg2 ;
52525   Dali::Actor *argp2 ;
52526   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52527
52528   arg1 = (unsigned int)jarg1;
52529   argp2 = (Dali::Actor *)jarg2;
52530   if (!argp2) {
52531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52532     return 0;
52533   }
52534   arg2 = *argp2;
52535   {
52536     try {
52537       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52538     } CALL_CATCH_EXCEPTION(0);
52539   }
52540
52541   jresult = (void *)result;
52542   return jresult;
52543 }
52544
52545
52546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52547   void * jresult ;
52548   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52549   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52550
52551   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52552   if (!arg1) {
52553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52554     return 0;
52555   }
52556   {
52557     try {
52558       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52559     } CALL_CATCH_EXCEPTION(0);
52560   }
52561
52562   jresult = (void *)result;
52563   return jresult;
52564 }
52565
52566
52567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52568   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52569   unsigned int arg2 ;
52570
52571   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52572   arg2 = (unsigned int)jarg2;
52573   if (arg1) (arg1)->first = arg2;
52574 }
52575
52576
52577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52578   unsigned int jresult ;
52579   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52580   unsigned int result;
52581
52582   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52583   result = (unsigned int) ((arg1)->first);
52584   jresult = result;
52585   return jresult;
52586 }
52587
52588
52589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52590   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52591   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52592
52593   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52594   arg2 = (Dali::Actor *)jarg2;
52595   if (arg1) (arg1)->second = *arg2;
52596 }
52597
52598
52599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52600   void * jresult ;
52601   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52602   Dali::Actor *result = 0 ;
52603
52604   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52605   result = (Dali::Actor *)& ((arg1)->second);
52606   jresult = (void *)result;
52607   return jresult;
52608 }
52609
52610
52611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52612   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52613
52614   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52615   {
52616     try {
52617       delete arg1;
52618     } CALL_CATCH_EXCEPTION();
52619   }
52620
52621 }
52622
52623
52624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52625   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52626
52627   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52628   {
52629     try {
52630       (arg1)->clear();
52631     } CALL_CATCH_EXCEPTION();
52632   }
52633
52634 }
52635
52636
52637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52638   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52639   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52640
52641   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52642   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52643   if (!arg2) {
52644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52645     return ;
52646   }
52647   {
52648     try {
52649       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52650     } CALL_CATCH_EXCEPTION();
52651   }
52652
52653 }
52654
52655
52656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52657   unsigned long jresult ;
52658   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52659   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52660
52661   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52662   {
52663     try {
52664       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52665     } CALL_CATCH_EXCEPTION(0);
52666   }
52667
52668   jresult = (unsigned long)result;
52669   return jresult;
52670 }
52671
52672
52673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
52674   unsigned long jresult ;
52675   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52676   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52677
52678   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52679   {
52680     try {
52681       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
52682     } CALL_CATCH_EXCEPTION(0);
52683   }
52684
52685   jresult = (unsigned long)result;
52686   return jresult;
52687 }
52688
52689
52690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52691   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52692   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52693
52694   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52695   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52696   {
52697     try {
52698       (arg1)->reserve(arg2);
52699     } CALL_CATCH_EXCEPTION();
52700   }
52701
52702 }
52703
52704
52705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52706   void * jresult ;
52707   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52708
52709   {
52710     try {
52711       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52712     } CALL_CATCH_EXCEPTION(0);
52713   }
52714
52715   jresult = (void *)result;
52716   return jresult;
52717 }
52718
52719
52720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52721   void * jresult ;
52722   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52723   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52724
52725   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52726   if (!arg1) {
52727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52728     return 0;
52729   }
52730   {
52731     try {
52732       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);
52733     } CALL_CATCH_EXCEPTION(0);
52734   }
52735
52736   jresult = (void *)result;
52737   return jresult;
52738 }
52739
52740
52741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52742   void * jresult ;
52743   int arg1 ;
52744   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52745
52746   arg1 = (int)jarg1;
52747   {
52748     try {
52749       try {
52750         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);
52751       }
52752       catch(std::out_of_range &_e) {
52753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52754         return 0;
52755       }
52756
52757     } CALL_CATCH_EXCEPTION(0);
52758   }
52759
52760   jresult = (void *)result;
52761   return jresult;
52762 }
52763
52764
52765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52766   void * jresult ;
52767   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52768   int arg2 ;
52769   std::pair< unsigned int,Dali::Actor > result;
52770
52771   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52772   arg2 = (int)jarg2;
52773   {
52774     try {
52775       try {
52776         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52777       }
52778       catch(std::out_of_range &_e) {
52779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52780         return 0;
52781       }
52782
52783     } CALL_CATCH_EXCEPTION(0);
52784   }
52785
52786   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52787   return jresult;
52788 }
52789
52790
52791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52792   void * jresult ;
52793   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52794   int arg2 ;
52795   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52796
52797   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52798   arg2 = (int)jarg2;
52799   {
52800     try {
52801       try {
52802         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52803       }
52804       catch(std::out_of_range &_e) {
52805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52806         return 0;
52807       }
52808
52809     } CALL_CATCH_EXCEPTION(0);
52810   }
52811
52812   jresult = (void *)result;
52813   return jresult;
52814 }
52815
52816
52817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52818   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52819   int arg2 ;
52820   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52821
52822   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52823   arg2 = (int)jarg2;
52824   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52825   if (!arg3) {
52826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52827     return ;
52828   }
52829   {
52830     try {
52831       try {
52832         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);
52833       }
52834       catch(std::out_of_range &_e) {
52835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52836         return ;
52837       }
52838
52839     } CALL_CATCH_EXCEPTION();
52840   }
52841
52842 }
52843
52844
52845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52846   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52847   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52848
52849   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52850   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52851   if (!arg2) {
52852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52853     return ;
52854   }
52855   {
52856     try {
52857       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);
52858     } CALL_CATCH_EXCEPTION();
52859   }
52860
52861 }
52862
52863
52864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52865   void * jresult ;
52866   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52867   int arg2 ;
52868   int arg3 ;
52869   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52870
52871   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52872   arg2 = (int)jarg2;
52873   arg3 = (int)jarg3;
52874   {
52875     try {
52876       try {
52877         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);
52878       }
52879       catch(std::out_of_range &_e) {
52880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52881         return 0;
52882       }
52883       catch(std::invalid_argument &_e) {
52884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52885         return 0;
52886       }
52887
52888     } CALL_CATCH_EXCEPTION(0);
52889   }
52890
52891   jresult = (void *)result;
52892   return jresult;
52893 }
52894
52895
52896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52897   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52898   int arg2 ;
52899   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52900
52901   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52902   arg2 = (int)jarg2;
52903   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52904   if (!arg3) {
52905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52906     return ;
52907   }
52908   {
52909     try {
52910       try {
52911         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);
52912       }
52913       catch(std::out_of_range &_e) {
52914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52915         return ;
52916       }
52917
52918     } CALL_CATCH_EXCEPTION();
52919   }
52920
52921 }
52922
52923
52924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52925   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52926   int arg2 ;
52927   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52928
52929   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52930   arg2 = (int)jarg2;
52931   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52932   if (!arg3) {
52933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52934     return ;
52935   }
52936   {
52937     try {
52938       try {
52939         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);
52940       }
52941       catch(std::out_of_range &_e) {
52942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52943         return ;
52944       }
52945
52946     } CALL_CATCH_EXCEPTION();
52947   }
52948
52949 }
52950
52951
52952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
52953   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52954   int arg2 ;
52955
52956   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52957   arg2 = (int)jarg2;
52958   {
52959     try {
52960       try {
52961         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
52962       }
52963       catch(std::out_of_range &_e) {
52964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52965         return ;
52966       }
52967
52968     } CALL_CATCH_EXCEPTION();
52969   }
52970
52971 }
52972
52973
52974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52975   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52976   int arg2 ;
52977   int arg3 ;
52978
52979   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52980   arg2 = (int)jarg2;
52981   arg3 = (int)jarg3;
52982   {
52983     try {
52984       try {
52985         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
52986       }
52987       catch(std::out_of_range &_e) {
52988         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52989         return ;
52990       }
52991       catch(std::invalid_argument &_e) {
52992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52993         return ;
52994       }
52995
52996     } CALL_CATCH_EXCEPTION();
52997   }
52998
52999 }
53000
53001
53002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
53003   void * jresult ;
53004   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53005   int arg2 ;
53006   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53007
53008   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53009   if (!arg1) {
53010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53011     return 0;
53012   }
53013   arg2 = (int)jarg2;
53014   {
53015     try {
53016       try {
53017         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);
53018       }
53019       catch(std::out_of_range &_e) {
53020         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53021         return 0;
53022       }
53023
53024     } CALL_CATCH_EXCEPTION(0);
53025   }
53026
53027   jresult = (void *)result;
53028   return jresult;
53029 }
53030
53031
53032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
53033   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53034
53035   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53036   {
53037     try {
53038       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
53039     } CALL_CATCH_EXCEPTION();
53040   }
53041
53042 }
53043
53044
53045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53046   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53047   int arg2 ;
53048   int arg3 ;
53049
53050   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53051   arg2 = (int)jarg2;
53052   arg3 = (int)jarg3;
53053   {
53054     try {
53055       try {
53056         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53057       }
53058       catch(std::out_of_range &_e) {
53059         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53060         return ;
53061       }
53062       catch(std::invalid_argument &_e) {
53063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53064         return ;
53065       }
53066
53067     } CALL_CATCH_EXCEPTION();
53068   }
53069
53070 }
53071
53072
53073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53075   int arg2 ;
53076   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53077
53078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53079   arg2 = (int)jarg2;
53080   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53081   if (!arg3) {
53082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53083     return ;
53084   }
53085   {
53086     try {
53087       try {
53088         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);
53089       }
53090       catch(std::out_of_range &_e) {
53091         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53092         return ;
53093       }
53094
53095     } CALL_CATCH_EXCEPTION();
53096   }
53097
53098 }
53099
53100
53101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
53102   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53103
53104   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53105   {
53106     try {
53107       delete arg1;
53108     } CALL_CATCH_EXCEPTION();
53109   }
53110
53111 }
53112
53113
53114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
53115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53116
53117   arg1 = (std::vector< Dali::Actor > *)jarg1;
53118   {
53119     try {
53120       (arg1)->clear();
53121     } CALL_CATCH_EXCEPTION();
53122   }
53123
53124 }
53125
53126
53127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
53128   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53129   Dali::Actor *arg2 = 0 ;
53130
53131   arg1 = (std::vector< Dali::Actor > *)jarg1;
53132   arg2 = (Dali::Actor *)jarg2;
53133   if (!arg2) {
53134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53135     return ;
53136   }
53137   {
53138     try {
53139       (arg1)->push_back((Dali::Actor const &)*arg2);
53140     } CALL_CATCH_EXCEPTION();
53141   }
53142
53143 }
53144
53145
53146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
53147   unsigned long jresult ;
53148   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53149   std::vector< Dali::Actor >::size_type result;
53150
53151   arg1 = (std::vector< Dali::Actor > *)jarg1;
53152   {
53153     try {
53154       result = ((std::vector< Dali::Actor > const *)arg1)->size();
53155     } CALL_CATCH_EXCEPTION(0);
53156   }
53157
53158   jresult = (unsigned long)result;
53159   return jresult;
53160 }
53161
53162
53163 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
53164   unsigned long jresult ;
53165   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53166   std::vector< Dali::Actor >::size_type result;
53167
53168   arg1 = (std::vector< Dali::Actor > *)jarg1;
53169   {
53170     try {
53171       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
53172     } CALL_CATCH_EXCEPTION(0);
53173   }
53174
53175   jresult = (unsigned long)result;
53176   return jresult;
53177 }
53178
53179
53180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
53181   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53182   std::vector< Dali::Actor >::size_type arg2 ;
53183
53184   arg1 = (std::vector< Dali::Actor > *)jarg1;
53185   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53186   {
53187     try {
53188       (arg1)->reserve(arg2);
53189     } CALL_CATCH_EXCEPTION();
53190   }
53191
53192 }
53193
53194
53195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53196   void * jresult ;
53197   std::vector< Dali::Actor > *result = 0 ;
53198
53199   {
53200     try {
53201       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53202     } CALL_CATCH_EXCEPTION(0);
53203   }
53204
53205   jresult = (void *)result;
53206   return jresult;
53207 }
53208
53209
53210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53211   void * jresult ;
53212   std::vector< Dali::Actor > *arg1 = 0 ;
53213   std::vector< Dali::Actor > *result = 0 ;
53214
53215   arg1 = (std::vector< Dali::Actor > *)jarg1;
53216   if (!arg1) {
53217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53218     return 0;
53219   }
53220   {
53221     try {
53222       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53223     } CALL_CATCH_EXCEPTION(0);
53224   }
53225
53226   jresult = (void *)result;
53227   return jresult;
53228 }
53229
53230
53231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53232   void * jresult ;
53233   int arg1 ;
53234   std::vector< Dali::Actor > *result = 0 ;
53235
53236   arg1 = (int)jarg1;
53237   {
53238     try {
53239       try {
53240         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53241       }
53242       catch(std::out_of_range &_e) {
53243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53244         return 0;
53245       }
53246
53247     } CALL_CATCH_EXCEPTION(0);
53248   }
53249
53250   jresult = (void *)result;
53251   return jresult;
53252 }
53253
53254
53255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53256   void * jresult ;
53257   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53258   int arg2 ;
53259   Dali::Actor result;
53260
53261   arg1 = (std::vector< Dali::Actor > *)jarg1;
53262   arg2 = (int)jarg2;
53263   {
53264     try {
53265       try {
53266         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53267       }
53268       catch(std::out_of_range &_e) {
53269         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53270         return 0;
53271       }
53272
53273     } CALL_CATCH_EXCEPTION(0);
53274   }
53275
53276   jresult = new Dali::Actor((const Dali::Actor &)result);
53277   return jresult;
53278 }
53279
53280
53281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53282   void * jresult ;
53283   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53284   int arg2 ;
53285   Dali::Actor *result = 0 ;
53286
53287   arg1 = (std::vector< Dali::Actor > *)jarg1;
53288   arg2 = (int)jarg2;
53289   {
53290     try {
53291       try {
53292         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53293       }
53294       catch(std::out_of_range &_e) {
53295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53296         return 0;
53297       }
53298
53299     } CALL_CATCH_EXCEPTION(0);
53300   }
53301
53302   jresult = (void *)result;
53303   return jresult;
53304 }
53305
53306
53307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53308   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53309   int arg2 ;
53310   Dali::Actor *arg3 = 0 ;
53311
53312   arg1 = (std::vector< Dali::Actor > *)jarg1;
53313   arg2 = (int)jarg2;
53314   arg3 = (Dali::Actor *)jarg3;
53315   if (!arg3) {
53316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53317     return ;
53318   }
53319   {
53320     try {
53321       try {
53322         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53323       }
53324       catch(std::out_of_range &_e) {
53325         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53326         return ;
53327       }
53328
53329     } CALL_CATCH_EXCEPTION();
53330   }
53331
53332 }
53333
53334
53335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53336   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53337   std::vector< Dali::Actor > *arg2 = 0 ;
53338
53339   arg1 = (std::vector< Dali::Actor > *)jarg1;
53340   arg2 = (std::vector< Dali::Actor > *)jarg2;
53341   if (!arg2) {
53342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53343     return ;
53344   }
53345   {
53346     try {
53347       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53348     } CALL_CATCH_EXCEPTION();
53349   }
53350
53351 }
53352
53353
53354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53355   void * jresult ;
53356   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53357   int arg2 ;
53358   int arg3 ;
53359   std::vector< Dali::Actor > *result = 0 ;
53360
53361   arg1 = (std::vector< Dali::Actor > *)jarg1;
53362   arg2 = (int)jarg2;
53363   arg3 = (int)jarg3;
53364   {
53365     try {
53366       try {
53367         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53368       }
53369       catch(std::out_of_range &_e) {
53370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53371         return 0;
53372       }
53373       catch(std::invalid_argument &_e) {
53374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53375         return 0;
53376       }
53377
53378     } CALL_CATCH_EXCEPTION(0);
53379   }
53380
53381   jresult = (void *)result;
53382   return jresult;
53383 }
53384
53385
53386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53387   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53388   int arg2 ;
53389   Dali::Actor *arg3 = 0 ;
53390
53391   arg1 = (std::vector< Dali::Actor > *)jarg1;
53392   arg2 = (int)jarg2;
53393   arg3 = (Dali::Actor *)jarg3;
53394   if (!arg3) {
53395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53396     return ;
53397   }
53398   {
53399     try {
53400       try {
53401         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53402       }
53403       catch(std::out_of_range &_e) {
53404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53405         return ;
53406       }
53407
53408     } CALL_CATCH_EXCEPTION();
53409   }
53410
53411 }
53412
53413
53414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53415   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53416   int arg2 ;
53417   std::vector< Dali::Actor > *arg3 = 0 ;
53418
53419   arg1 = (std::vector< Dali::Actor > *)jarg1;
53420   arg2 = (int)jarg2;
53421   arg3 = (std::vector< Dali::Actor > *)jarg3;
53422   if (!arg3) {
53423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53424     return ;
53425   }
53426   {
53427     try {
53428       try {
53429         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53430       }
53431       catch(std::out_of_range &_e) {
53432         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53433         return ;
53434       }
53435
53436     } CALL_CATCH_EXCEPTION();
53437   }
53438
53439 }
53440
53441
53442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53443   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53444   int arg2 ;
53445
53446   arg1 = (std::vector< Dali::Actor > *)jarg1;
53447   arg2 = (int)jarg2;
53448   {
53449     try {
53450       try {
53451         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53452       }
53453       catch(std::out_of_range &_e) {
53454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53455         return ;
53456       }
53457
53458     } CALL_CATCH_EXCEPTION();
53459   }
53460
53461 }
53462
53463
53464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53465   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53466   int arg2 ;
53467   int arg3 ;
53468
53469   arg1 = (std::vector< Dali::Actor > *)jarg1;
53470   arg2 = (int)jarg2;
53471   arg3 = (int)jarg3;
53472   {
53473     try {
53474       try {
53475         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53476       }
53477       catch(std::out_of_range &_e) {
53478         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53479         return ;
53480       }
53481       catch(std::invalid_argument &_e) {
53482         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53483         return ;
53484       }
53485
53486     } CALL_CATCH_EXCEPTION();
53487   }
53488
53489 }
53490
53491
53492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53493   void * jresult ;
53494   Dali::Actor *arg1 = 0 ;
53495   int arg2 ;
53496   std::vector< Dali::Actor > *result = 0 ;
53497
53498   arg1 = (Dali::Actor *)jarg1;
53499   if (!arg1) {
53500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53501     return 0;
53502   }
53503   arg2 = (int)jarg2;
53504   {
53505     try {
53506       try {
53507         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53508       }
53509       catch(std::out_of_range &_e) {
53510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53511         return 0;
53512       }
53513
53514     } CALL_CATCH_EXCEPTION(0);
53515   }
53516
53517   jresult = (void *)result;
53518   return jresult;
53519 }
53520
53521
53522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53523   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53524
53525   arg1 = (std::vector< Dali::Actor > *)jarg1;
53526   {
53527     try {
53528       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53529     } CALL_CATCH_EXCEPTION();
53530   }
53531
53532 }
53533
53534
53535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53536   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53537   int arg2 ;
53538   int arg3 ;
53539
53540   arg1 = (std::vector< Dali::Actor > *)jarg1;
53541   arg2 = (int)jarg2;
53542   arg3 = (int)jarg3;
53543   {
53544     try {
53545       try {
53546         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53547       }
53548       catch(std::out_of_range &_e) {
53549         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53550         return ;
53551       }
53552       catch(std::invalid_argument &_e) {
53553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53554         return ;
53555       }
53556
53557     } CALL_CATCH_EXCEPTION();
53558   }
53559
53560 }
53561
53562
53563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53564   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53565   int arg2 ;
53566   std::vector< Dali::Actor > *arg3 = 0 ;
53567
53568   arg1 = (std::vector< Dali::Actor > *)jarg1;
53569   arg2 = (int)jarg2;
53570   arg3 = (std::vector< Dali::Actor > *)jarg3;
53571   if (!arg3) {
53572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53573     return ;
53574   }
53575   {
53576     try {
53577       try {
53578         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53579       }
53580       catch(std::out_of_range &_e) {
53581         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53582         return ;
53583       }
53584
53585     } CALL_CATCH_EXCEPTION();
53586   }
53587
53588 }
53589
53590
53591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53592   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53593
53594   arg1 = (std::vector< Dali::Actor > *)jarg1;
53595   {
53596     try {
53597       delete arg1;
53598     } CALL_CATCH_EXCEPTION();
53599   }
53600
53601 }
53602
53603
53604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53605   unsigned int jresult ;
53606   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53607   bool result;
53608
53609   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53610   {
53611     try {
53612       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53613     } CALL_CATCH_EXCEPTION(0);
53614   }
53615
53616   jresult = result;
53617   return jresult;
53618 }
53619
53620
53621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53622   unsigned long jresult ;
53623   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53624   std::size_t result;
53625
53626   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53627   {
53628     try {
53629       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53630     } CALL_CATCH_EXCEPTION(0);
53631   }
53632
53633   jresult = (unsigned long)result;
53634   return jresult;
53635 }
53636
53637
53638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53639   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53640   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53641
53642   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53643   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53644   {
53645     try {
53646       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53647     } CALL_CATCH_EXCEPTION();
53648   }
53649
53650 }
53651
53652
53653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53654   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53655   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53656
53657   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53658   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53659   {
53660     try {
53661       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53662     } CALL_CATCH_EXCEPTION();
53663   }
53664
53665 }
53666
53667
53668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53669   unsigned int jresult ;
53670   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53671   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53672   bool result;
53673
53674   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53675   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53676   if (!arg2) {
53677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53678     return 0;
53679   }
53680   {
53681     try {
53682       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53683     } CALL_CATCH_EXCEPTION(0);
53684   }
53685
53686   jresult = result;
53687   return jresult;
53688 }
53689
53690
53691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53692   void * jresult ;
53693   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53694
53695   {
53696     try {
53697       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53698     } CALL_CATCH_EXCEPTION(0);
53699   }
53700
53701   jresult = (void *)result;
53702   return jresult;
53703 }
53704
53705
53706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53707   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53708
53709   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53710   {
53711     try {
53712       delete arg1;
53713     } CALL_CATCH_EXCEPTION();
53714   }
53715
53716 }
53717
53718
53719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53720   unsigned int jresult ;
53721   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53722   bool result;
53723
53724   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53725   {
53726     try {
53727       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);
53728     } CALL_CATCH_EXCEPTION(0);
53729   }
53730
53731   jresult = result;
53732   return jresult;
53733 }
53734
53735
53736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53737   unsigned long jresult ;
53738   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53739   std::size_t result;
53740
53741   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53742   {
53743     try {
53744       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);
53745     } CALL_CATCH_EXCEPTION(0);
53746   }
53747
53748   jresult = (unsigned long)result;
53749   return jresult;
53750 }
53751
53752
53753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53754   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53755   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53756
53757   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53758   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53759   {
53760     try {
53761       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53762     } CALL_CATCH_EXCEPTION();
53763   }
53764
53765 }
53766
53767
53768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53769   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53770   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53771
53772   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53773   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53774   {
53775     try {
53776       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53777     } CALL_CATCH_EXCEPTION();
53778   }
53779
53780 }
53781
53782
53783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53784   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53785   Dali::Actor arg2 ;
53786   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53787   Dali::Actor *argp2 ;
53788
53789   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53790   argp2 = (Dali::Actor *)jarg2;
53791   if (!argp2) {
53792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53793     return ;
53794   }
53795   arg2 = *argp2;
53796   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53797   {
53798     try {
53799       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53800     } CALL_CATCH_EXCEPTION();
53801   }
53802
53803 }
53804
53805
53806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53807   void * jresult ;
53808   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53809
53810   {
53811     try {
53812       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53813     } CALL_CATCH_EXCEPTION(0);
53814   }
53815
53816   jresult = (void *)result;
53817   return jresult;
53818 }
53819
53820
53821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53822   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53823
53824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53825   {
53826     try {
53827       delete arg1;
53828     } CALL_CATCH_EXCEPTION();
53829   }
53830
53831 }
53832
53833
53834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53835   unsigned int jresult ;
53836   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53837   bool result;
53838
53839   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53840   {
53841     try {
53842       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53843     } CALL_CATCH_EXCEPTION(0);
53844   }
53845
53846   jresult = result;
53847   return jresult;
53848 }
53849
53850
53851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53852   unsigned long jresult ;
53853   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53854   std::size_t result;
53855
53856   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53857   {
53858     try {
53859       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53860     } CALL_CATCH_EXCEPTION(0);
53861   }
53862
53863   jresult = (unsigned long)result;
53864   return jresult;
53865 }
53866
53867
53868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53869   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53870   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53871
53872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53873   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53874   {
53875     try {
53876       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53877     } CALL_CATCH_EXCEPTION();
53878   }
53879
53880 }
53881
53882
53883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53884   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53885   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53886
53887   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53888   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53889   {
53890     try {
53891       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53892     } CALL_CATCH_EXCEPTION();
53893   }
53894
53895 }
53896
53897
53898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53899   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53900   Dali::Actor arg2 ;
53901   Dali::Actor arg3 ;
53902   Dali::Actor *argp2 ;
53903   Dali::Actor *argp3 ;
53904
53905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53906   argp2 = (Dali::Actor *)jarg2;
53907   if (!argp2) {
53908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53909     return ;
53910   }
53911   arg2 = *argp2;
53912   argp3 = (Dali::Actor *)jarg3;
53913   if (!argp3) {
53914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53915     return ;
53916   }
53917   arg3 = *argp3;
53918   {
53919     try {
53920       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53921     } CALL_CATCH_EXCEPTION();
53922   }
53923
53924 }
53925
53926
53927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53928   void * jresult ;
53929   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53930
53931   {
53932     try {
53933       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53934     } CALL_CATCH_EXCEPTION(0);
53935   }
53936
53937   jresult = (void *)result;
53938   return jresult;
53939 }
53940
53941
53942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53943   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53944
53945   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53946   {
53947     try {
53948       delete arg1;
53949     } CALL_CATCH_EXCEPTION();
53950   }
53951
53952 }
53953
53954
53955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
53956   unsigned int jresult ;
53957   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53958   bool result;
53959
53960   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53961   {
53962     try {
53963       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53964     } CALL_CATCH_EXCEPTION(0);
53965   }
53966
53967   jresult = result;
53968   return jresult;
53969 }
53970
53971
53972 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
53973   unsigned long jresult ;
53974   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53975   std::size_t result;
53976
53977   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53978   {
53979     try {
53980       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53981     } CALL_CATCH_EXCEPTION(0);
53982   }
53983
53984   jresult = (unsigned long)result;
53985   return jresult;
53986 }
53987
53988
53989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
53990   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53991   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53992
53993   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53994   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53995   {
53996     try {
53997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
53998     } CALL_CATCH_EXCEPTION();
53999   }
54000
54001 }
54002
54003
54004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54005   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54006   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54007
54008   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54009   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54010   {
54011     try {
54012       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54013     } CALL_CATCH_EXCEPTION();
54014   }
54015
54016 }
54017
54018
54019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
54020   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54021   Dali::Actor arg2 ;
54022   bool arg3 ;
54023   Dali::Actor *argp2 ;
54024
54025   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54026   argp2 = (Dali::Actor *)jarg2;
54027   if (!argp2) {
54028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54029     return ;
54030   }
54031   arg2 = *argp2;
54032   arg3 = jarg3 ? true : false;
54033   {
54034     try {
54035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
54036     } CALL_CATCH_EXCEPTION();
54037   }
54038
54039 }
54040
54041
54042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
54043   void * jresult ;
54044   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
54045
54046   {
54047     try {
54048       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
54049     } CALL_CATCH_EXCEPTION(0);
54050   }
54051
54052   jresult = (void *)result;
54053   return jresult;
54054 }
54055
54056
54057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
54058   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54059
54060   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54061   {
54062     try {
54063       delete arg1;
54064     } CALL_CATCH_EXCEPTION();
54065   }
54066
54067 }
54068
54069
54070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
54071   unsigned int jresult ;
54072   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54073   bool result;
54074
54075   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54076   {
54077     try {
54078       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);
54079     } CALL_CATCH_EXCEPTION(0);
54080   }
54081
54082   jresult = result;
54083   return jresult;
54084 }
54085
54086
54087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
54088   unsigned long jresult ;
54089   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54090   std::size_t result;
54091
54092   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54093   {
54094     try {
54095       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);
54096     } CALL_CATCH_EXCEPTION(0);
54097   }
54098
54099   jresult = (unsigned long)result;
54100   return jresult;
54101 }
54102
54103
54104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
54105   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54106   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54107
54108   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54109   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54110   {
54111     try {
54112       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
54113     } CALL_CATCH_EXCEPTION();
54114   }
54115
54116 }
54117
54118
54119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54120   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54121   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54122
54123   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54124   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54125   {
54126     try {
54127       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
54128     } CALL_CATCH_EXCEPTION();
54129   }
54130
54131 }
54132
54133
54134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54135   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54136   Dali::Toolkit::StyleManager arg2 ;
54137   Dali::StyleChange::Type arg3 ;
54138   Dali::Toolkit::StyleManager *argp2 ;
54139
54140   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54141   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
54142   if (!argp2) {
54143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
54144     return ;
54145   }
54146   arg2 = *argp2;
54147   arg3 = (Dali::StyleChange::Type)jarg3;
54148   {
54149     try {
54150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
54151     } CALL_CATCH_EXCEPTION();
54152   }
54153
54154 }
54155
54156
54157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
54158   void * jresult ;
54159   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
54160
54161   {
54162     try {
54163       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
54164     } CALL_CATCH_EXCEPTION(0);
54165   }
54166
54167   jresult = (void *)result;
54168   return jresult;
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
54173   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54174
54175   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54176   {
54177     try {
54178       delete arg1;
54179     } CALL_CATCH_EXCEPTION();
54180   }
54181
54182 }
54183
54184
54185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54186   unsigned int jresult ;
54187   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54188   bool result;
54189
54190   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54191   {
54192     try {
54193       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54194     } CALL_CATCH_EXCEPTION(0);
54195   }
54196
54197   jresult = result;
54198   return jresult;
54199 }
54200
54201
54202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54203   unsigned long jresult ;
54204   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54205   std::size_t result;
54206
54207   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54208   {
54209     try {
54210       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54211     } CALL_CATCH_EXCEPTION(0);
54212   }
54213
54214   jresult = (unsigned long)result;
54215   return jresult;
54216 }
54217
54218
54219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54220   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54221   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54222
54223   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54224   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54225   {
54226     try {
54227       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54228     } CALL_CATCH_EXCEPTION();
54229   }
54230
54231 }
54232
54233
54234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54235   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54236   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54237
54238   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54239   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54240   {
54241     try {
54242       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54243     } CALL_CATCH_EXCEPTION();
54244   }
54245
54246 }
54247
54248
54249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54250   unsigned int jresult ;
54251   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54252   Dali::Toolkit::Button arg2 ;
54253   Dali::Toolkit::Button *argp2 ;
54254   bool result;
54255
54256   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54257   argp2 = (Dali::Toolkit::Button *)jarg2;
54258   if (!argp2) {
54259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54260     return 0;
54261   }
54262   arg2 = *argp2;
54263   {
54264     try {
54265       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54266     } CALL_CATCH_EXCEPTION(0);
54267   }
54268
54269   jresult = result;
54270   return jresult;
54271 }
54272
54273
54274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54275   void * jresult ;
54276   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54277
54278   {
54279     try {
54280       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54281     } CALL_CATCH_EXCEPTION(0);
54282   }
54283
54284   jresult = (void *)result;
54285   return jresult;
54286 }
54287
54288
54289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54290   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54291
54292   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54293   {
54294     try {
54295       delete arg1;
54296     } CALL_CATCH_EXCEPTION();
54297   }
54298
54299 }
54300
54301
54302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54303   unsigned int jresult ;
54304   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54305   bool result;
54306
54307   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54308   {
54309     try {
54310       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54311     } CALL_CATCH_EXCEPTION(0);
54312   }
54313
54314   jresult = result;
54315   return jresult;
54316 }
54317
54318
54319 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54320   unsigned long jresult ;
54321   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54322   std::size_t result;
54323
54324   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54325   {
54326     try {
54327       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54328     } CALL_CATCH_EXCEPTION(0);
54329   }
54330
54331   jresult = (unsigned long)result;
54332   return jresult;
54333 }
54334
54335
54336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54337   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54338   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54339
54340   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54341   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54342   {
54343     try {
54344       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54345     } CALL_CATCH_EXCEPTION();
54346   }
54347
54348 }
54349
54350
54351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54352   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54353   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54354
54355   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54356   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54357   {
54358     try {
54359       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54360     } CALL_CATCH_EXCEPTION();
54361   }
54362
54363 }
54364
54365
54366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54367   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54368   Dali::Toolkit::GaussianBlurView arg2 ;
54369   Dali::Toolkit::GaussianBlurView *argp2 ;
54370
54371   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54372   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54373   if (!argp2) {
54374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54375     return ;
54376   }
54377   arg2 = *argp2;
54378   {
54379     try {
54380       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54381     } CALL_CATCH_EXCEPTION();
54382   }
54383
54384 }
54385
54386
54387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54388   void * jresult ;
54389   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54390
54391   {
54392     try {
54393       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54394     } CALL_CATCH_EXCEPTION(0);
54395   }
54396
54397   jresult = (void *)result;
54398   return jresult;
54399 }
54400
54401
54402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54403   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54404
54405   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54406   {
54407     try {
54408       delete arg1;
54409     } CALL_CATCH_EXCEPTION();
54410   }
54411
54412 }
54413
54414
54415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54416   unsigned int jresult ;
54417   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54418   bool result;
54419
54420   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54421   {
54422     try {
54423       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);
54424     } CALL_CATCH_EXCEPTION(0);
54425   }
54426
54427   jresult = result;
54428   return jresult;
54429 }
54430
54431
54432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54433   unsigned long jresult ;
54434   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54435   std::size_t result;
54436
54437   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54438   {
54439     try {
54440       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);
54441     } CALL_CATCH_EXCEPTION(0);
54442   }
54443
54444   jresult = (unsigned long)result;
54445   return jresult;
54446 }
54447
54448
54449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54450   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54451   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54452
54453   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54454   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54455   {
54456     try {
54457       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54458     } CALL_CATCH_EXCEPTION();
54459   }
54460
54461 }
54462
54463
54464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54465   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54466   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54467
54468   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54469   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54470   {
54471     try {
54472       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54473     } CALL_CATCH_EXCEPTION();
54474   }
54475
54476 }
54477
54478
54479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54480   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54481   Dali::Toolkit::PageTurnView arg2 ;
54482   unsigned int arg3 ;
54483   bool arg4 ;
54484   Dali::Toolkit::PageTurnView *argp2 ;
54485
54486   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54487   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54488   if (!argp2) {
54489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54490     return ;
54491   }
54492   arg2 = *argp2;
54493   arg3 = (unsigned int)jarg3;
54494   arg4 = jarg4 ? true : false;
54495   {
54496     try {
54497       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54498     } CALL_CATCH_EXCEPTION();
54499   }
54500
54501 }
54502
54503
54504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54505   void * jresult ;
54506   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54507
54508   {
54509     try {
54510       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54511     } CALL_CATCH_EXCEPTION(0);
54512   }
54513
54514   jresult = (void *)result;
54515   return jresult;
54516 }
54517
54518
54519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54520   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54521
54522   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54523   {
54524     try {
54525       delete arg1;
54526     } CALL_CATCH_EXCEPTION();
54527   }
54528
54529 }
54530
54531
54532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54533   unsigned int jresult ;
54534   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54535   bool result;
54536
54537   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54538   {
54539     try {
54540       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54541     } CALL_CATCH_EXCEPTION(0);
54542   }
54543
54544   jresult = result;
54545   return jresult;
54546 }
54547
54548
54549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54550   unsigned long jresult ;
54551   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54552   std::size_t result;
54553
54554   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54555   {
54556     try {
54557       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54558     } CALL_CATCH_EXCEPTION(0);
54559   }
54560
54561   jresult = (unsigned long)result;
54562   return jresult;
54563 }
54564
54565
54566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54567   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54568   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54569
54570   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54571   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54572   {
54573     try {
54574       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54575     } CALL_CATCH_EXCEPTION();
54576   }
54577 }
54578
54579
54580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54581   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54582   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54583
54584   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54585   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54586   {
54587     try {
54588       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54589     } CALL_CATCH_EXCEPTION();
54590   }
54591 }
54592
54593
54594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54595   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54596   Dali::Toolkit::PageTurnView arg2 ;
54597   Dali::Toolkit::PageTurnView *argp2 ;
54598
54599   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54600   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54601   if (!argp2) {
54602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54603     return ;
54604   }
54605   arg2 = *argp2;
54606   {
54607     try {
54608       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54609     } CALL_CATCH_EXCEPTION();
54610   }
54611 }
54612
54613
54614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54615   void * jresult ;
54616   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54617
54618   {
54619     try {
54620       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54621     } CALL_CATCH_EXCEPTION(0);
54622   }
54623
54624   jresult = (void *)result;
54625   return jresult;
54626 }
54627
54628
54629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54630   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54631
54632   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54633   {
54634     try {
54635       delete arg1;
54636     } CALL_CATCH_EXCEPTION();
54637   }
54638
54639 }
54640
54641
54642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54643   unsigned int jresult ;
54644   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54645   bool result;
54646
54647   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54648   {
54649     try {
54650       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);
54651     } CALL_CATCH_EXCEPTION(0);
54652   }
54653
54654   jresult = result;
54655   return jresult;
54656 }
54657
54658
54659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54660   unsigned long jresult ;
54661   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54662   std::size_t result;
54663
54664   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54665   {
54666     try {
54667       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);
54668     } CALL_CATCH_EXCEPTION(0);
54669   }
54670
54671   jresult = (unsigned long)result;
54672   return jresult;
54673 }
54674
54675
54676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54677   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54678   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54679
54680   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54681   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54682   {
54683     try {
54684       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54685     } CALL_CATCH_EXCEPTION();
54686   }
54687
54688 }
54689
54690
54691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54692   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54693   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54694
54695   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54696   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54697   {
54698     try {
54699       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54700     } CALL_CATCH_EXCEPTION();
54701   }
54702
54703 }
54704
54705
54706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54707   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54708   Dali::Toolkit::ProgressBar arg2 ;
54709   float arg3 ;
54710   float arg4 ;
54711   Dali::Toolkit::ProgressBar *argp2 ;
54712
54713   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54714   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54715   if (!argp2) {
54716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54717     return ;
54718   }
54719   arg2 = *argp2;
54720   arg3 = (float)jarg3;
54721   arg4 = (float)jarg4;
54722   {
54723     try {
54724       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54725     } CALL_CATCH_EXCEPTION();
54726   }
54727
54728 }
54729
54730
54731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54732   void * jresult ;
54733   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54734
54735   {
54736     try {
54737       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54738     } CALL_CATCH_EXCEPTION(0);
54739   }
54740
54741   jresult = (void *)result;
54742   return jresult;
54743 }
54744
54745
54746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54747   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54748
54749   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54750   {
54751     try {
54752       delete arg1;
54753     } CALL_CATCH_EXCEPTION();
54754   }
54755
54756 }
54757
54758
54759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54760   unsigned int jresult ;
54761   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54762   bool result;
54763
54764   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54765   {
54766     try {
54767       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);
54768     } CALL_CATCH_EXCEPTION(0);
54769   }
54770
54771   jresult = result;
54772   return jresult;
54773 }
54774
54775
54776 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54777   unsigned long jresult ;
54778   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54779   std::size_t result;
54780
54781   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54782   {
54783     try {
54784       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);
54785     } CALL_CATCH_EXCEPTION(0);
54786   }
54787
54788   jresult = (unsigned long)result;
54789   return jresult;
54790 }
54791
54792
54793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54794   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54795   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54796
54797   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54798   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54799   {
54800     try {
54801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54802     } CALL_CATCH_EXCEPTION();
54803   }
54804
54805 }
54806
54807
54808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54809   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54810   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54813   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54814   {
54815     try {
54816       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54817     } CALL_CATCH_EXCEPTION();
54818   }
54819
54820 }
54821
54822
54823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54824   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54825   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54826
54827   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54828   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54829   if (!arg2) {
54830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54831     return ;
54832   }
54833   {
54834     try {
54835       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54836     } CALL_CATCH_EXCEPTION();
54837   }
54838
54839 }
54840
54841
54842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54843   void * jresult ;
54844   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54845
54846   {
54847     try {
54848       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54849     } CALL_CATCH_EXCEPTION(0);
54850   }
54851
54852   jresult = (void *)result;
54853   return jresult;
54854 }
54855
54856
54857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54858   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54859
54860   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54861   {
54862     try {
54863       delete arg1;
54864     } CALL_CATCH_EXCEPTION();
54865   }
54866
54867 }
54868
54869
54870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54871   unsigned int jresult ;
54872   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54873   bool result;
54874
54875   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54876   {
54877     try {
54878       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54879     } CALL_CATCH_EXCEPTION(0);
54880   }
54881
54882   jresult = result;
54883   return jresult;
54884 }
54885
54886
54887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54888   unsigned long jresult ;
54889   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54890   std::size_t result;
54891
54892   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54893   {
54894     try {
54895       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54896     } CALL_CATCH_EXCEPTION(0);
54897   }
54898
54899   jresult = (unsigned long)result;
54900   return jresult;
54901 }
54902
54903
54904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54905   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54906   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54907
54908   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54909   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54910   {
54911     try {
54912       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54913     } CALL_CATCH_EXCEPTION();
54914   }
54915
54916 }
54917
54918
54919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54920   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54921   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54922
54923   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54924   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54925   {
54926     try {
54927       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54928     } CALL_CATCH_EXCEPTION();
54929   }
54930
54931 }
54932
54933
54934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54935   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54936   Dali::Vector2 *arg2 = 0 ;
54937
54938   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54939   arg2 = (Dali::Vector2 *)jarg2;
54940   if (!arg2) {
54941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54942     return ;
54943   }
54944   {
54945     try {
54946       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
54947     } CALL_CATCH_EXCEPTION();
54948   }
54949
54950 }
54951
54952
54953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
54954   void * jresult ;
54955   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
54956
54957   {
54958     try {
54959       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
54960     } CALL_CATCH_EXCEPTION(0);
54961   }
54962
54963   jresult = (void *)result;
54964   return jresult;
54965 }
54966
54967
54968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
54969   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54970
54971   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54972   {
54973     try {
54974       delete arg1;
54975     } CALL_CATCH_EXCEPTION();
54976   }
54977
54978 }
54979
54980
54981
54982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
54983   unsigned int jresult ;
54984   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54985   bool result;
54986
54987   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54988   {
54989     try {
54990       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);
54991     } CALL_CATCH_EXCEPTION(0);
54992   }
54993
54994   jresult = result;
54995   return jresult;
54996 }
54997
54998
54999 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
55000   unsigned long jresult ;
55001   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55002   std::size_t result;
55003
55004   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55005   {
55006     try {
55007       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);
55008     } CALL_CATCH_EXCEPTION(0);
55009   }
55010
55011   jresult = (unsigned long)result;
55012   return jresult;
55013 }
55014
55015
55016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
55017   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55018   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55019
55020   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55021   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55022   {
55023     try {
55024       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55025     } CALL_CATCH_EXCEPTION();
55026   }
55027
55028 }
55029
55030
55031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
55032   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55033   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55034
55035   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55036   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55037   {
55038     try {
55039       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55040     } CALL_CATCH_EXCEPTION();
55041   }
55042
55043 }
55044
55045
55046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55047   unsigned int jresult ;
55048   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55049   Dali::Toolkit::Control arg2 ;
55050   Dali::KeyEvent *arg3 = 0 ;
55051   Dali::Toolkit::Control *argp2 ;
55052   bool result;
55053
55054   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55055   argp2 = (Dali::Toolkit::Control *)jarg2;
55056   if (!argp2) {
55057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55058     return 0;
55059   }
55060   arg2 = *argp2;
55061   arg3 = (Dali::KeyEvent *)jarg3;
55062   if (!arg3) {
55063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55064     return 0;
55065   }
55066   {
55067     try {
55068       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);
55069     } CALL_CATCH_EXCEPTION(0);
55070   }
55071
55072   jresult = result;
55073   return jresult;
55074 }
55075
55076
55077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
55078   void * jresult ;
55079   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
55080
55081   {
55082     try {
55083       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
55084     } CALL_CATCH_EXCEPTION(0);
55085   }
55086
55087   jresult = (void *)result;
55088   return jresult;
55089 }
55090
55091
55092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
55093   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55094
55095   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55096   {
55097     try {
55098       delete arg1;
55099     } CALL_CATCH_EXCEPTION();
55100   }
55101
55102 }
55103
55104
55105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
55106   unsigned int jresult ;
55107   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55108   bool result;
55109
55110   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55111   {
55112     try {
55113       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55114     } CALL_CATCH_EXCEPTION(0);
55115   }
55116
55117   jresult = result;
55118   return jresult;
55119 }
55120
55121
55122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
55123   unsigned long jresult ;
55124   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55125   std::size_t result;
55126
55127   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55128   {
55129     try {
55130       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55131     } CALL_CATCH_EXCEPTION(0);
55132   }
55133
55134   jresult = (unsigned long)result;
55135   return jresult;
55136 }
55137
55138
55139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
55140   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55141   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55142
55143   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55144   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55145   {
55146     try {
55147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
55148     } CALL_CATCH_EXCEPTION();
55149   }
55150
55151 }
55152
55153
55154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
55155   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55156   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55157
55158   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55159   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55160   {
55161     try {
55162       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
55163     } CALL_CATCH_EXCEPTION();
55164   }
55165
55166 }
55167
55168
55169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
55170   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55171   Dali::Toolkit::Control arg2 ;
55172   Dali::Toolkit::Control *argp2 ;
55173
55174   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55175   argp2 = (Dali::Toolkit::Control *)jarg2;
55176   if (!argp2) {
55177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55178     return ;
55179   }
55180   arg2 = *argp2;
55181   {
55182     try {
55183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55184     } CALL_CATCH_EXCEPTION();
55185   }
55186
55187 }
55188
55189
55190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55191   void * jresult ;
55192   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55193
55194   {
55195     try {
55196       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55197     } CALL_CATCH_EXCEPTION(0);
55198   }
55199
55200   jresult = (void *)result;
55201   return jresult;
55202 }
55203
55204
55205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55207
55208   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55209   {
55210     try {
55211       delete arg1;
55212     } CALL_CATCH_EXCEPTION();
55213   }
55214
55215 }
55216
55217
55218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55219   unsigned int jresult ;
55220   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55221   bool result;
55222
55223   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55224   {
55225     try {
55226       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55227     } CALL_CATCH_EXCEPTION(0);
55228   }
55229
55230   jresult = result;
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55236   unsigned long jresult ;
55237   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55238   std::size_t result;
55239
55240   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55241   {
55242     try {
55243       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55244     } CALL_CATCH_EXCEPTION(0);
55245   }
55246
55247   jresult = (unsigned long)result;
55248   return jresult;
55249 }
55250
55251
55252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55253   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55254   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55255
55256   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55257   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55258   {
55259     try {
55260       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55261     } CALL_CATCH_EXCEPTION();
55262   }
55263
55264 }
55265
55266
55267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55268   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55269   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55270
55271   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55272   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55273   {
55274     try {
55275       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55276     } CALL_CATCH_EXCEPTION();
55277   }
55278
55279 }
55280
55281
55282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55283   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55284   Dali::Toolkit::VideoView *arg2 = 0 ;
55285
55286   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55287   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55288   if (!arg2) {
55289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55290     return ;
55291   }
55292   {
55293     try {
55294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55295     } CALL_CATCH_EXCEPTION();
55296   }
55297
55298 }
55299
55300
55301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55302   void * jresult ;
55303   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55304
55305   {
55306     try {
55307       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55308     } CALL_CATCH_EXCEPTION(0);
55309   }
55310
55311   jresult = (void *)result;
55312   return jresult;
55313 }
55314
55315
55316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55317   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55318
55319   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55320   {
55321     try {
55322       delete arg1;
55323     } CALL_CATCH_EXCEPTION();
55324   }
55325
55326 }
55327
55328
55329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55330   unsigned int jresult ;
55331   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55332   bool result;
55333
55334   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55335   {
55336     try {
55337       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55338     } CALL_CATCH_EXCEPTION(0);
55339   }
55340
55341   jresult = result;
55342   return jresult;
55343 }
55344
55345
55346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55347   unsigned long jresult ;
55348   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55349   std::size_t result;
55350
55351   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55352   {
55353     try {
55354       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55355     } CALL_CATCH_EXCEPTION(0);
55356   }
55357
55358   jresult = (unsigned long)result;
55359   return jresult;
55360 }
55361
55362
55363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55364   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55365   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55366
55367   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55368   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55369   {
55370     try {
55371       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55372     } CALL_CATCH_EXCEPTION();
55373   }
55374
55375 }
55376
55377
55378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55379   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55380   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55381
55382   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55383   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55384   {
55385     try {
55386       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55387     } CALL_CATCH_EXCEPTION();
55388   }
55389
55390 }
55391
55392
55393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55394   unsigned int jresult ;
55395   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55396   Dali::Toolkit::Slider arg2 ;
55397   float arg3 ;
55398   Dali::Toolkit::Slider *argp2 ;
55399   bool result;
55400
55401   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55402   argp2 = (Dali::Toolkit::Slider *)jarg2;
55403   if (!argp2) {
55404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55405     return 0;
55406   }
55407   arg2 = *argp2;
55408   arg3 = (float)jarg3;
55409   {
55410     try {
55411       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55412     } CALL_CATCH_EXCEPTION(0);
55413   }
55414
55415   jresult = result;
55416   return jresult;
55417 }
55418
55419
55420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55421   void * jresult ;
55422   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55423
55424   {
55425     try {
55426       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55427     } CALL_CATCH_EXCEPTION(0);
55428   }
55429
55430   jresult = (void *)result;
55431   return jresult;
55432 }
55433
55434
55435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55436   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55437
55438   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55439   {
55440     try {
55441       delete arg1;
55442     } CALL_CATCH_EXCEPTION();
55443   }
55444
55445 }
55446
55447
55448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55449   unsigned int jresult ;
55450   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55451   bool result;
55452
55453   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55454   {
55455     try {
55456       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55457     } CALL_CATCH_EXCEPTION(0);
55458   }
55459
55460   jresult = result;
55461   return jresult;
55462 }
55463
55464
55465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55466   unsigned long jresult ;
55467   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55468   std::size_t result;
55469
55470   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55471   {
55472     try {
55473       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55474     } CALL_CATCH_EXCEPTION(0);
55475   }
55476
55477   jresult = (unsigned long)result;
55478   return jresult;
55479 }
55480
55481
55482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55483   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55484   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55485
55486   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55487   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55488   {
55489     try {
55490       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55491     } CALL_CATCH_EXCEPTION();
55492   }
55493
55494 }
55495
55496
55497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55498   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55499   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55500
55501   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55502   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55503   {
55504     try {
55505       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55506     } CALL_CATCH_EXCEPTION();
55507   }
55508
55509 }
55510
55511
55512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55513   unsigned int jresult ;
55514   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55515   Dali::Toolkit::Slider arg2 ;
55516   int arg3 ;
55517   Dali::Toolkit::Slider *argp2 ;
55518   bool result;
55519
55520   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55521   argp2 = (Dali::Toolkit::Slider *)jarg2;
55522   if (!argp2) {
55523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55524     return 0;
55525   }
55526   arg2 = *argp2;
55527   arg3 = (int)jarg3;
55528   {
55529     try {
55530       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55531     } CALL_CATCH_EXCEPTION(0);
55532   }
55533
55534   jresult = result;
55535   return jresult;
55536 }
55537
55538
55539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55540   void * jresult ;
55541   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55542
55543   {
55544     try {
55545       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55546     } CALL_CATCH_EXCEPTION(0);
55547   }
55548
55549   jresult = (void *)result;
55550   return jresult;
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55555   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55556
55557   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55558   {
55559     try {
55560       delete arg1;
55561     } CALL_CATCH_EXCEPTION();
55562   }
55563
55564 }
55565
55566
55567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55568   void * jresult ;
55569   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55570
55571   {
55572     try {
55573       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55574     } CALL_CATCH_EXCEPTION(0);
55575   }
55576
55577   jresult = (void *)result;
55578   return jresult;
55579 }
55580
55581
55582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55583   void * jresult ;
55584   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55585   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55586
55587   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55588   {
55589     try {
55590       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
55591     } CALL_CATCH_EXCEPTION(0);
55592   }
55593
55594   jresult = (void *)result;
55595   return jresult;
55596 }
55597
55598
55599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
55600   void * jresult ;
55601   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55603
55604   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55605   if (!arg1) {
55606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55607     return 0;
55608   }
55609   {
55610     try {
55611       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55612     } CALL_CATCH_EXCEPTION(0);
55613   }
55614
55615   jresult = (void *)result;
55616   return jresult;
55617 }
55618
55619
55620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55621   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55622
55623   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55624   {
55625     try {
55626       delete arg1;
55627     } CALL_CATCH_EXCEPTION();
55628   }
55629
55630 }
55631
55632
55633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55634   void * jresult ;
55635   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55636   Dali::Toolkit::Ruler *result = 0 ;
55637
55638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55639   {
55640     try {
55641       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55642     } CALL_CATCH_EXCEPTION(0);
55643   }
55644
55645   jresult = (void *)result;
55646   return jresult;
55647 }
55648
55649
55650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
55651   void * jresult ;
55652   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55653   Dali::Toolkit::Ruler *result = 0 ;
55654
55655   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55656   {
55657     try {
55658       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
55659     } CALL_CATCH_EXCEPTION(0);
55660   }
55661
55662   jresult = (void *)result;
55663   return jresult;
55664 }
55665
55666
55667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
55668   void * jresult ;
55669   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55670   Dali::Toolkit::Ruler *result = 0 ;
55671
55672   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55673   {
55674     try {
55675       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
55676     } CALL_CATCH_EXCEPTION(0);
55677   }
55678
55679   jresult = (void *)result;
55680   return jresult;
55681 }
55682
55683
55684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
55685   void * jresult ;
55686   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55689
55690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55691   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55692   if (!arg2) {
55693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55694     return 0;
55695   }
55696   {
55697     try {
55698       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55699     } CALL_CATCH_EXCEPTION(0);
55700   }
55701
55702   jresult = (void *)result;
55703   return jresult;
55704 }
55705
55706
55707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55708   void * jresult ;
55709   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55710   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55711   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55712
55713   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55714   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55715   {
55716     try {
55717       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55718     } CALL_CATCH_EXCEPTION(0);
55719   }
55720
55721   jresult = (void *)result;
55722   return jresult;
55723 }
55724
55725
55726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55728
55729   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55730   {
55731     try {
55732       (arg1)->Reset();
55733     } CALL_CATCH_EXCEPTION();
55734   }
55735
55736 }
55737
55738
55739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55741   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55742
55743   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55744   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55745   {
55746     try {
55747       (arg1)->Reset(arg2);
55748     } CALL_CATCH_EXCEPTION();
55749   }
55750
55751 }
55752
55753
55754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55755   void * jresult ;
55756   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55757   Dali::Toolkit::Ruler *result = 0 ;
55758
55759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55760   {
55761     try {
55762       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55763     } CALL_CATCH_EXCEPTION(0);
55764   }
55765
55766   jresult = (void *)result;
55767   return jresult;
55768 }
55769
55770
55771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55772   float jresult ;
55773   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55774   float arg2 ;
55775   float arg3 ;
55776   float result;
55777
55778   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55779   arg2 = (float)jarg2;
55780   arg3 = (float)jarg3;
55781   {
55782     try {
55783       result = (float)(*arg1)->Snap(arg2,arg3);
55784     } CALL_CATCH_EXCEPTION(0);
55785   }
55786
55787   jresult = result;
55788   return jresult;
55789 }
55790
55791
55792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55793   float jresult ;
55794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55795   float arg2 ;
55796   float result;
55797
55798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55799   arg2 = (float)jarg2;
55800   {
55801     try {
55802       result = (float)(*arg1)->Snap(arg2);
55803     } CALL_CATCH_EXCEPTION(0);
55804   }
55805
55806   jresult = result;
55807   return jresult;
55808 }
55809
55810
55811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55812   float jresult ;
55813   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55814   unsigned int arg2 ;
55815   unsigned int *arg3 = 0 ;
55816   bool arg4 ;
55817   float result;
55818
55819   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55820   arg2 = (unsigned int)jarg2;
55821   arg3 = (unsigned int *)jarg3;
55822   arg4 = jarg4 ? true : false;
55823   {
55824     try {
55825       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55826     } CALL_CATCH_EXCEPTION(0);
55827   }
55828
55829   jresult = result;
55830   return jresult;
55831 }
55832
55833
55834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55835   unsigned int jresult ;
55836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55837   float arg2 ;
55838   bool arg3 ;
55839   unsigned int result;
55840
55841   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55842   arg2 = (float)jarg2;
55843   arg3 = jarg3 ? true : false;
55844   {
55845     try {
55846       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55847     } CALL_CATCH_EXCEPTION(0);
55848   }
55849
55850   jresult = result;
55851   return jresult;
55852 }
55853
55854
55855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55856   unsigned int jresult ;
55857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55858   unsigned int result;
55859
55860   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55861   {
55862     try {
55863       result = (unsigned int)(*arg1)->GetTotalPages();
55864     } CALL_CATCH_EXCEPTION(0);
55865   }
55866
55867   jresult = result;
55868   return jresult;
55869 }
55870
55871
55872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55873   int jresult ;
55874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55875   Dali::Toolkit::Ruler::RulerType result;
55876
55877   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55878   {
55879     try {
55880       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55881     } CALL_CATCH_EXCEPTION(0);
55882   }
55883
55884   jresult = (int)result;
55885   return jresult;
55886 }
55887
55888
55889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55890   unsigned int jresult ;
55891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55892   bool result;
55893
55894   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55895   {
55896     try {
55897       result = (bool)(*arg1)->IsEnabled();
55898     } CALL_CATCH_EXCEPTION(0);
55899   }
55900
55901   jresult = result;
55902   return jresult;
55903 }
55904
55905
55906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55908
55909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55910   {
55911     try {
55912       (*arg1)->Enable();
55913     } CALL_CATCH_EXCEPTION();
55914   }
55915
55916 }
55917
55918
55919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55921
55922   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55923   {
55924     try {
55925       (*arg1)->Disable();
55926     } CALL_CATCH_EXCEPTION();
55927   }
55928
55929 }
55930
55931
55932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55934   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55935   Dali::Toolkit::RulerDomain *argp2 ;
55936
55937   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55938   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55939   if (!argp2) {
55940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55941     return ;
55942   }
55943   arg2 = *argp2;
55944   {
55945     try {
55946       (*arg1)->SetDomain(arg2);
55947     } CALL_CATCH_EXCEPTION();
55948   }
55949
55950 }
55951
55952
55953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
55954   void * jresult ;
55955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55956   Dali::Toolkit::RulerDomain *result = 0 ;
55957
55958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55959   {
55960     try {
55961       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
55962     } CALL_CATCH_EXCEPTION(0);
55963   }
55964
55965   jresult = (void *)result;
55966   return jresult;
55967 }
55968
55969
55970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
55971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55972
55973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55974   {
55975     try {
55976       (*arg1)->DisableDomain();
55977     } CALL_CATCH_EXCEPTION();
55978   }
55979
55980 }
55981
55982
55983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
55984   float jresult ;
55985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55986   float arg2 ;
55987   float arg3 ;
55988   float arg4 ;
55989   float result;
55990
55991   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55992   arg2 = (float)jarg2;
55993   arg3 = (float)jarg3;
55994   arg4 = (float)jarg4;
55995   {
55996     try {
55997       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
55998     } CALL_CATCH_EXCEPTION(0);
55999   }
56000
56001   jresult = result;
56002   return jresult;
56003 }
56004
56005
56006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
56007   float jresult ;
56008   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56009   float arg2 ;
56010   float arg3 ;
56011   float result;
56012
56013   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56014   arg2 = (float)jarg2;
56015   arg3 = (float)jarg3;
56016   {
56017     try {
56018       result = (float)(*arg1)->Clamp(arg2,arg3);
56019     } CALL_CATCH_EXCEPTION(0);
56020   }
56021
56022   jresult = result;
56023   return jresult;
56024 }
56025
56026
56027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
56028   float jresult ;
56029   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56030   float arg2 ;
56031   float result;
56032
56033   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56034   arg2 = (float)jarg2;
56035   {
56036     try {
56037       result = (float)(*arg1)->Clamp(arg2);
56038     } CALL_CATCH_EXCEPTION(0);
56039   }
56040
56041   jresult = result;
56042   return jresult;
56043 }
56044
56045
56046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
56047   float jresult ;
56048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56049   float arg2 ;
56050   float arg3 ;
56051   float arg4 ;
56052   Dali::Toolkit::ClampState *arg5 = 0 ;
56053   float result;
56054
56055   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56056   arg2 = (float)jarg2;
56057   arg3 = (float)jarg3;
56058   arg4 = (float)jarg4;
56059   arg5 = (Dali::Toolkit::ClampState *)jarg5;
56060   if (!arg5) {
56061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56062     return 0;
56063   }
56064   {
56065     try {
56066       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
56067     } CALL_CATCH_EXCEPTION(0);
56068   }
56069
56070   jresult = result;
56071   return jresult;
56072 }
56073
56074
56075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
56076   float jresult ;
56077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56078   float arg2 ;
56079   float arg3 ;
56080   float arg4 ;
56081   float arg5 ;
56082   float result;
56083
56084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56085   arg2 = (float)jarg2;
56086   arg3 = (float)jarg3;
56087   arg4 = (float)jarg4;
56088   arg5 = (float)jarg5;
56089   {
56090     try {
56091       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
56092     } CALL_CATCH_EXCEPTION(0);
56093   }
56094
56095   jresult = result;
56096   return jresult;
56097 }
56098
56099
56100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
56101   float jresult ;
56102   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56103   float arg2 ;
56104   float arg3 ;
56105   float arg4 ;
56106   float result;
56107
56108   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56109   arg2 = (float)jarg2;
56110   arg3 = (float)jarg3;
56111   arg4 = (float)jarg4;
56112   {
56113     try {
56114       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
56115     } CALL_CATCH_EXCEPTION(0);
56116   }
56117
56118   jresult = result;
56119   return jresult;
56120 }
56121
56122
56123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
56124   float jresult ;
56125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56126   float arg2 ;
56127   float arg3 ;
56128   float result;
56129
56130   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56131   arg2 = (float)jarg2;
56132   arg3 = (float)jarg3;
56133   {
56134     try {
56135       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
56136     } CALL_CATCH_EXCEPTION(0);
56137   }
56138
56139   jresult = result;
56140   return jresult;
56141 }
56142
56143
56144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
56145   float jresult ;
56146   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56147   float arg2 ;
56148   float result;
56149
56150   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56151   arg2 = (float)jarg2;
56152   {
56153     try {
56154       result = (float)(*arg1)->SnapAndClamp(arg2);
56155     } CALL_CATCH_EXCEPTION(0);
56156   }
56157
56158   jresult = result;
56159   return jresult;
56160 }
56161
56162
56163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
56164   float jresult ;
56165   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56166   float arg2 ;
56167   float arg3 ;
56168   float arg4 ;
56169   float arg5 ;
56170   Dali::Toolkit::ClampState *arg6 = 0 ;
56171   float result;
56172
56173   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56174   arg2 = (float)jarg2;
56175   arg3 = (float)jarg3;
56176   arg4 = (float)jarg4;
56177   arg5 = (float)jarg5;
56178   arg6 = (Dali::Toolkit::ClampState *)jarg6;
56179   if (!arg6) {
56180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56181     return 0;
56182   }
56183   {
56184     try {
56185       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56186     } CALL_CATCH_EXCEPTION(0);
56187   }
56188
56189   jresult = result;
56190   return jresult;
56191 }
56192
56193
56194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56195   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56196
56197   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56198   {
56199     try {
56200       (*arg1)->Reference();
56201     } CALL_CATCH_EXCEPTION();
56202   }
56203
56204 }
56205
56206
56207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56208   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56209
56210   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56211   {
56212     try {
56213       (*arg1)->Unreference();
56214     } CALL_CATCH_EXCEPTION();
56215   }
56216
56217 }
56218
56219
56220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56221   int jresult ;
56222   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56223   int result;
56224
56225   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56226   {
56227     try {
56228       result = (int)(*arg1)->ReferenceCount();
56229     } CALL_CATCH_EXCEPTION(0);
56230   }
56231
56232   jresult = result;
56233   return jresult;
56234 }
56235
56236
56237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56238   unsigned int jresult ;
56239   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56240   bool result;
56241
56242   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56243   {
56244     try {
56245       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56246     } CALL_CATCH_EXCEPTION(0);
56247   }
56248
56249   jresult = result;
56250   return jresult;
56251 }
56252
56253
56254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56255   unsigned long jresult ;
56256   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56257   std::size_t result;
56258
56259   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56260   {
56261     try {
56262       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56263     } CALL_CATCH_EXCEPTION(0);
56264   }
56265
56266   jresult = (unsigned long)result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56272   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56273   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56274
56275   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56276   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56277   {
56278     try {
56279       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56280     } CALL_CATCH_EXCEPTION();
56281   }
56282
56283 }
56284
56285
56286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56287   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56288   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56289
56290   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56291   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56292   {
56293     try {
56294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56295     } CALL_CATCH_EXCEPTION();
56296   }
56297
56298 }
56299
56300
56301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56302   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56303   Dali::Toolkit::Control arg2 ;
56304   Dali::Toolkit::Control *argp2 ;
56305
56306   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56307   argp2 = (Dali::Toolkit::Control *)jarg2;
56308   if (!argp2) {
56309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56310     return ;
56311   }
56312   arg2 = *argp2;
56313   {
56314     try {
56315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56316     } CALL_CATCH_EXCEPTION();
56317   }
56318
56319 }
56320
56321
56322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56323   void * jresult ;
56324   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56325
56326   {
56327     try {
56328       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56329     } CALL_CATCH_EXCEPTION(0);
56330   }
56331
56332   jresult = (void *)result;
56333   return jresult;
56334 }
56335
56336
56337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56338   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56339
56340   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56341   {
56342     try {
56343       delete arg1;
56344     } CALL_CATCH_EXCEPTION();
56345   }
56346
56347 }
56348
56349 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56350   Dali::RefObject *result = NULL;
56351
56352   if (arg1)
56353   {
56354     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56355   }
56356   return result;
56357 }
56358
56359 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56360     return (Dali::RefObject *)jarg1;
56361 }
56362
56363 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56364     return (Dali::SignalObserver *)jarg1;
56365 }
56366
56367 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56368     return (Dali::ConnectionTrackerInterface *)jarg1;
56369 }
56370
56371 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56372     return (Dali::BaseHandle *)jarg1;
56373 }
56374
56375 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56376     return (Dali::BaseHandle *)jarg1;
56377 }
56378
56379 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56380     return (Dali::BaseHandle *)jarg1;
56381 }
56382
56383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56384     return (Dali::BaseHandle *)jarg1;
56385 }
56386
56387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56388     return (Dali::BaseHandle *)jarg1;
56389 }
56390
56391 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56392     return (Dali::BaseHandle *)jarg1;
56393 }
56394
56395 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56396     return (Dali::BaseHandle *)jarg1;
56397 }
56398
56399 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56400     return (Dali::BaseHandle *)jarg1;
56401 }
56402
56403 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56404     return (Dali::BaseHandle *)jarg1;
56405 }
56406
56407 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56408     return (Dali::BaseHandle *)jarg1;
56409 }
56410
56411 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56412     return (Dali::BaseHandle *)jarg1;
56413 }
56414
56415 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56416     return (Dali::BaseHandle *)jarg1;
56417 }
56418
56419 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56420     return (Dali::Handle *)jarg1;
56421 }
56422
56423 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56424     return (Dali::Handle *)jarg1;
56425 }
56426
56427 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56428     return (Dali::BaseHandle *)jarg1;
56429 }
56430
56431 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56432     return (Dali::BaseHandle *)jarg1;
56433 }
56434
56435 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56436     return (Dali::Handle *)jarg1;
56437 }
56438
56439 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56440     return (Dali::BaseHandle *)jarg1;
56441 }
56442
56443 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56444     return (Dali::BaseHandle *)jarg1;
56445 }
56446
56447 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56448     return (Dali::BaseHandle *)jarg1;
56449 }
56450
56451 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56452     return (Dali::BaseHandle *)jarg1;
56453 }
56454
56455 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56456     return (Dali::Handle *)jarg1;
56457 }
56458
56459 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56460     return (Dali::GestureDetector *)jarg1;
56461 }
56462
56463 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56464     return (Dali::Gesture *)jarg1;
56465 }
56466
56467 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56468     return (Dali::Handle *)jarg1;
56469 }
56470
56471 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56472     return (Dali::Actor *)jarg1;
56473 }
56474
56475 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56476     return (Dali::RefObject *)jarg1;
56477 }
56478
56479 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56480     return (Dali::Actor *)jarg1;
56481 }
56482
56483 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56484     return (Dali::GestureDetector *)jarg1;
56485 }
56486
56487 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56488     return (Dali::Gesture *)jarg1;
56489 }
56490
56491 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56492     return (Dali::GestureDetector *)jarg1;
56493 }
56494
56495 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56496     return (Dali::Gesture *)jarg1;
56497 }
56498
56499 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56500     return (Dali::GestureDetector *)jarg1;
56501 }
56502
56503 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56504     return (Dali::Gesture *)jarg1;
56505 }
56506
56507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56508     return (Dali::BaseHandle *)jarg1;
56509 }
56510
56511 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56512     return (Dali::Handle *)jarg1;
56513 }
56514
56515 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56516     return (Dali::Handle *)jarg1;
56517 }
56518
56519 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56520     return (Dali::Handle *)jarg1;
56521 }
56522
56523 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56524     return (Dali::RefObject *)jarg1;
56525 }
56526
56527 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56528     return (Dali::Actor *)jarg1;
56529 }
56530
56531 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56532     return (Dali::BaseHandle *)jarg1;
56533 }
56534
56535 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56536     return (Dali::BaseHandle *)jarg1;
56537 }
56538
56539 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56540     return (Dali::BaseHandle *)jarg1;
56541 }
56542
56543 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56544     return (Dali::CustomActorImpl *)jarg1;
56545 }
56546
56547 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56548     return (Dali::CustomActor *)jarg1;
56549 }
56550
56551 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56552     return (Dali::BaseHandle *)jarg1;
56553 }
56554
56555 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56556     return (Dali::Toolkit::Control *)jarg1;
56557 }
56558
56559 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56560     return (Dali::Toolkit::Control *)jarg1;
56561 }
56562
56563 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56564     return (Dali::Toolkit::Button *)jarg1;
56565 }
56566
56567 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56568     return (Dali::Toolkit::Button *)jarg1;
56569 }
56570
56571 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56572     return (Dali::Toolkit::Button *)jarg1;
56573 }
56574
56575 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56576     return (Dali::Toolkit::Control *)jarg1;
56577 }
56578
56579 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56580     return (Dali::Toolkit::Control *)jarg1;
56581 }
56582
56583 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56584     return (Dali::Toolkit::Control *)jarg1;
56585 }
56586
56587 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56588     return (Dali::Toolkit::Control *)jarg1;
56589 }
56590
56591 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56592     return (Dali::Toolkit::Control *)jarg1;
56593 }
56594
56595 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56596     return (Dali::RefObject *)jarg1;
56597 }
56598
56599 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56600     return (Dali::Toolkit::Scrollable *)jarg1;
56601 }
56602
56603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56604     return (Dali::BaseHandle *)jarg1;
56605 }
56606
56607 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56608     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56609 }
56610
56611 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56612     return (Dali::RefObject *)jarg1;
56613 }
56614
56615 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56616     return (Dali::Toolkit::Ruler *)jarg1;
56617 }
56618
56619 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56620     return (Dali::Toolkit::Ruler *)jarg1;
56621 }
56622
56623 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56624     return (Dali::Toolkit::Scrollable *)jarg1;
56625 }
56626
56627 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56628     return (Dali::Toolkit::Control *)jarg1;
56629 }
56630
56631
56632 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56633     return (Dali::Toolkit::Control *)jarg1;
56634 }
56635
56636 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56637     return (Dali::BaseHandle *)jarg1;
56638 }
56639
56640 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56641     return (Dali::BaseHandle *)jarg1;
56642 }
56643
56644 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56645     return (Dali::Toolkit::Control *)jarg1;
56646 }
56647
56648 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56649     return (Dali::Toolkit::Control *)jarg1;
56650 }
56651
56652 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56653     return (Dali::Toolkit::Control *)jarg1;
56654 }
56655
56656 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56657     return (Dali::Toolkit::Control *)jarg1;
56658 }
56659
56660 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56661     return (Dali::Toolkit::Control *)jarg1;
56662 }
56663
56664 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56665     return (Dali::Toolkit::Control *)jarg1;
56666 }
56667
56668 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56669     return (Dali::Toolkit::PageTurnView *)jarg1;
56670 }
56671
56672 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56673     return (Dali::Toolkit::PageTurnView *)jarg1;
56674 }
56675
56676 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56677     return (Dali::Toolkit::Button *)jarg1;
56678 }
56679
56680 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56681     return (Dali::BaseHandle *)jarg1;
56682 }
56683
56684 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56685     return (Dali::BaseHandle *)jarg1;
56686 }
56687
56688 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56689     return (Dali::BaseHandle *)jarg1;
56690 }
56691
56692 /*
56693  * Widget binding
56694  */
56695 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56696     return (Dali::BaseHandle *)jarg1;
56697 }
56698
56699 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56700     return (Dali::BaseObject *)jarg1;
56701 }
56702
56703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56704   void * jresult ;
56705   Dali::Widget result;
56706
56707   {
56708     try {
56709       result = Dali::Widget::New();
56710     } CALL_CATCH_EXCEPTION(0);
56711   }
56712
56713   jresult = new Dali::Widget((const Dali::Widget &)result);
56714   return jresult;
56715 }
56716
56717
56718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56719   void * jresult ;
56720   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56721   Dali::Widget result;
56722
56723   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56724
56725   if (!arg1) {
56726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56727     return 0;
56728   }
56729   {
56730     try {
56731       jresult = new Dali::Widget(arg1);
56732     } CALL_CATCH_EXCEPTION(0);
56733   }
56734   return jresult;
56735 }
56736
56737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56738   void * jresult ;
56739   Dali::Widget *result = 0 ;
56740
56741   {
56742     try {
56743       result = (Dali::Widget *)new Dali::Widget();
56744     } CALL_CATCH_EXCEPTION(0);
56745   }
56746   jresult = (void *)result;
56747   return jresult;
56748 }
56749
56750
56751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56752   void * jresult ;
56753   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56754   Dali::Widget *arg2 = 0 ;
56755   Dali::Widget *result = 0 ;
56756
56757   arg1 = (Dali::Widget *)jarg1;
56758   arg2 = (Dali::Widget *)jarg2;
56759   if (!arg2) {
56760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56761     return 0;
56762   }
56763   {
56764     try {
56765       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56766     } CALL_CATCH_EXCEPTION(0);
56767   }
56768   jresult = (void *)result;
56769   return jresult;
56770 }
56771
56772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56773   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56774
56775   arg1 = (Dali::Widget *)jarg1;
56776   {
56777     try {
56778       delete arg1;
56779     } CALL_CATCH_EXCEPTION();
56780   }
56781 }
56782
56783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56784   void * jresult ;
56785   SwigDirector_WidgetImpl* result;
56786   {
56787     try {
56788       result = new SwigDirector_WidgetImpl();
56789     } CALL_CATCH_EXCEPTION(0);
56790   }
56791   jresult = result;
56792   return jresult;
56793 }
56794
56795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56796   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56797   std::string *arg2 = 0 ;
56798   Dali::Window arg3 ;
56799   Dali::Window *argp3 ;
56800
56801   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56802   if (!jarg2) {
56803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56804     return ;
56805   }
56806   std::string arg2_str(jarg2);
56807   arg2 = &arg2_str;
56808   argp3 = (Dali::Window *)jarg3;
56809   if (!argp3) {
56810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56811     return ;
56812   }
56813   arg3 = *argp3;
56814   {
56815     try {
56816       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56817     } CALL_CATCH_EXCEPTION();
56818   }
56819 }
56820
56821
56822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56823   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56824   std::string *arg2 = 0 ;
56825   Dali::Window arg3 ;
56826   Dali::Window *argp3 ;
56827
56828   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56829   if (!jarg2) {
56830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56831     return ;
56832   }
56833   std::string arg2_str(jarg2);
56834   arg2 = &arg2_str;
56835   argp3 = (Dali::Window *)jarg3;
56836   if (!argp3) {
56837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56838     return ;
56839   }
56840   arg3 = *argp3;
56841   {
56842     try {
56843       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56844     } CALL_CATCH_EXCEPTION();
56845   }
56846 }
56847
56848
56849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56850   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56851   std::string *arg2 = 0 ;
56852   Dali::Widget::Termination arg3 ;
56853
56854   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56855   if (!jarg2) {
56856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56857     return ;
56858   }
56859   std::string arg2_str(jarg2);
56860   arg2 = &arg2_str;
56861   arg3 = (Dali::Widget::Termination)jarg3;
56862   {
56863     try {
56864       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56865     } CALL_CATCH_EXCEPTION();
56866   }
56867 }
56868
56869
56870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56871   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56872   std::string *arg2 = 0 ;
56873   Dali::Widget::Termination arg3 ;
56874
56875   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56876   if (!jarg2) {
56877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56878     return ;
56879   }
56880   std::string arg2_str(jarg2);
56881   arg2 = &arg2_str;
56882   arg3 = (Dali::Widget::Termination)jarg3;
56883   {
56884     try {
56885       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56886     } CALL_CATCH_EXCEPTION();
56887   }
56888 }
56889
56890
56891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56892   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56893
56894   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56895   {
56896     try {
56897       (arg1)->OnPause();
56898     } CALL_CATCH_EXCEPTION();
56899   }
56900 }
56901
56902
56903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56904   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56905
56906   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56907   {
56908     try {
56909       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56910     } CALL_CATCH_EXCEPTION();
56911   }
56912 }
56913
56914
56915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56916   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56917
56918   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56919   {
56920     try {
56921       (arg1)->OnResume();
56922     } CALL_CATCH_EXCEPTION();
56923   }
56924 }
56925
56926
56927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
56928   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56929
56930   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56931   {
56932     try {
56933       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
56934     } CALL_CATCH_EXCEPTION();
56935   }
56936 }
56937
56938
56939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56940   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56941   Dali::Window arg2 ;
56942   Dali::Window *argp2 ;
56943
56944   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56945   argp2 = (Dali::Window *)jarg2;
56946   if (!argp2) {
56947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56948     return ;
56949   }
56950   arg2 = *argp2;
56951   {
56952     try {
56953       (arg1)->OnResize(arg2);
56954     } CALL_CATCH_EXCEPTION();
56955   }
56956 }
56957
56958
56959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
56960   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56961   Dali::Window arg2 ;
56962   Dali::Window *argp2 ;
56963
56964   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56965   argp2 = (Dali::Window *)jarg2;
56966   if (!argp2) {
56967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56968     return ;
56969   }
56970   arg2 = *argp2;
56971   {
56972     try {
56973       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
56974     } CALL_CATCH_EXCEPTION();
56975   }
56976 }
56977
56978
56979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
56980   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56981   std::string *arg2 = 0 ;
56982   int arg3 ;
56983
56984   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56985   if (!jarg2) {
56986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56987     return ;
56988   }
56989   std::string arg2_str(jarg2);
56990   arg2 = &arg2_str;
56991   arg3 = (int)jarg3;
56992   {
56993     try {
56994       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
56995     } CALL_CATCH_EXCEPTION();
56996   }
56997 }
56998
56999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57000   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57001   std::string *arg2 = 0 ;
57002   int arg3 ;
57003
57004   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57005   if (!jarg2) {
57006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57007     return ;
57008   }
57009   std::string arg2_str(jarg2);
57010   arg2 = &arg2_str;
57011   arg3 = (int)jarg3;
57012   {
57013     try {
57014       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
57015     } CALL_CATCH_EXCEPTION();
57016   }
57017 }
57018
57019
57020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57021   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57022   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57023   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57024
57025   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57026   arg2 = (Dali::SlotObserver *)jarg2;
57027   arg3 = (Dali::CallbackBase *)jarg3;
57028   {
57029     try {
57030       (arg1)->SignalConnected(arg2,arg3);
57031     } CALL_CATCH_EXCEPTION();
57032   }
57033 }
57034
57035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57036   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57037   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57038   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57039
57040   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57041   arg2 = (Dali::SlotObserver *)jarg2;
57042   arg3 = (Dali::CallbackBase *)jarg3;
57043   {
57044     try {
57045       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
57046     } CALL_CATCH_EXCEPTION();
57047   }
57048 }
57049
57050
57051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
57052   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57053   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57054   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57055
57056   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57057   arg2 = (Dali::SlotObserver *)jarg2;
57058   arg3 = (Dali::CallbackBase *)jarg3;
57059   {
57060     try {
57061       (arg1)->SignalDisconnected(arg2,arg3);
57062     } CALL_CATCH_EXCEPTION();
57063   }
57064 }
57065
57066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57067   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57068   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57069   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57070
57071   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57072   arg2 = (Dali::SlotObserver *)jarg2;
57073   arg3 = (Dali::CallbackBase *)jarg3;
57074   {
57075     try {
57076       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
57077     } CALL_CATCH_EXCEPTION();
57078   }
57079 }
57080
57081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
57082   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57083   std::string *arg2 = 0 ;
57084
57085   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57086   if (!jarg2) {
57087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57088     return ;
57089   }
57090   std::string arg2_str(jarg2);
57091   arg2 = &arg2_str;
57092   {
57093     try {
57094       (arg1)->SetContentInfo((std::string const &)*arg2);
57095     } CALL_CATCH_EXCEPTION();
57096   }
57097 }
57098
57099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
57100   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57101   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
57102
57103   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57104   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
57105   {
57106     try {
57107       (arg1)->SetImpl(arg2);
57108     } CALL_CATCH_EXCEPTION();
57109   }
57110 }
57111
57112
57113 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) {
57114   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
57115   if (director) {
57116     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
57117   }
57118 }
57119
57120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
57121   void * jresult ;
57122   Dali::Widget *arg1 = 0 ;
57123   SwigDirector_WidgetImpl *result = 0 ;
57124
57125   arg1 = (Dali::Widget *)jarg1;
57126   if (!arg1) {
57127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
57128     return 0;
57129   }
57130   {
57131     try {
57132       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
57133     } CALL_CATCH_EXCEPTION(0);
57134   }
57135   jresult = (void*) result;
57136   return jresult;
57137 }
57138
57139
57140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
57141   void * jresult ;
57142   int *arg1 = (int *) 0 ;
57143   char ***arg2 ;
57144   std::string *arg3 = 0 ;
57145   Dali::WidgetApplication result;
57146   {
57147     int index = 0;
57148     int length = 0;
57149     char *retPtr;
57150     char *nextPtr;
57151     argWidgetC = jarg1;
57152     argWidgetV = new char*[jarg1 + 1];
57153
57154     retPtr = strtok_r( jarg2, " ", &nextPtr);
57155     if( retPtr )
57156     {
57157       length = strlen(retPtr);
57158     }
57159     argWidgetV[index] = new char[length + 1];
57160     if( retPtr )
57161     {
57162       strncpy(argWidgetV[index], retPtr, length);
57163     }
57164     argWidgetV[index][length] = '\0';
57165     index++;
57166
57167     while (index < jarg1)
57168     {
57169       length = 0;
57170       retPtr = strtok_r(NULL, " ", &nextPtr);
57171       if( retPtr )
57172       {
57173         length = strlen(retPtr);
57174       }
57175       argWidgetV[index] = new char[length + 1];
57176       if( retPtr )
57177       {
57178         strncpy(argWidgetV[index], retPtr, length);
57179       }
57180       argWidgetV[index][length] = '\0';
57181       index++;
57182     }
57183
57184     argWidgetV[jarg1] = NULL;
57185     argWidgetC = jarg1;
57186
57187     arg1 = &argWidgetC;
57188     arg2 = &argWidgetV;
57189   }
57190
57191   if (!jarg3) {
57192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57193     return 0;
57194   }
57195   std::string arg3_str(jarg3);
57196   arg3 = &arg3_str;
57197   {
57198     try {
57199       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
57200     } CALL_CATCH_EXCEPTION(0);
57201   }
57202   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
57208   void * jresult ;
57209   Dali::WidgetApplication *result = 0 ;
57210
57211   {
57212     try {
57213       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
57214     } CALL_CATCH_EXCEPTION(0);
57215   }
57216   jresult = (void *)result;
57217   return jresult;
57218 }
57219
57220
57221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57222   void * jresult ;
57223   Dali::WidgetApplication *arg1 = 0 ;
57224   Dali::WidgetApplication *result = 0 ;
57225
57226   arg1 = (Dali::WidgetApplication *)jarg1;
57227   if (!arg1) {
57228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57229     return 0;
57230   }
57231   {
57232     try {
57233       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57234     } CALL_CATCH_EXCEPTION(0);
57235   }
57236   jresult = (void *)result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57242   void * jresult ;
57243   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57244   Dali::WidgetApplication *arg2 = 0 ;
57245   Dali::WidgetApplication *result = 0 ;
57246
57247   arg1 = (Dali::WidgetApplication *)jarg1;
57248   arg2 = (Dali::WidgetApplication *)jarg2;
57249   if (!arg2) {
57250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57251     return 0;
57252   }
57253   {
57254     try {
57255       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57256     } CALL_CATCH_EXCEPTION(0);
57257   }
57258   jresult = (void *)result;
57259   return jresult;
57260 }
57261
57262
57263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57264   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57265
57266   arg1 = (Dali::WidgetApplication *)jarg1;
57267   {
57268     try {
57269       delete arg1;
57270       if( argWidgetV )
57271       {
57272         // free string data
57273         for( int i=0; i < argWidgetC+1; i++)
57274         {
57275           delete [] argWidgetV[i];
57276         }
57277         delete [] argWidgetV;
57278       }
57279     } CALL_CATCH_EXCEPTION();
57280   }
57281 }
57282
57283
57284 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57285 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57286
57287 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57288 {
57289   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57290   return *widget;
57291 }
57292
57293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57294   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57295   std::string *arg2 = 0 ;
57296
57297   arg1 = (Dali::WidgetApplication *)jarg1;
57298   if (!jarg2) {
57299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57300     return ;
57301   }
57302   std::string arg2_str(*jarg2);
57303   arg2 = &arg2_str;
57304
57305   if(!_CSharpCreateWidgetFunction)
57306   {
57307     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57308   }
57309
57310   {
57311     try {
57312       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57313     } CALL_CATCH_EXCEPTION();
57314   }
57315   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57316 }
57317
57318
57319 //for PixelBuffer and ImageLoading
57320
57321 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57322     return (Dali::BaseHandle *)jarg1;
57323 }
57324
57325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57326   void * jresult ;
57327   unsigned int arg1 ;
57328   unsigned int arg2 ;
57329   Dali::Pixel::Format arg3 ;
57330   Dali::Devel::PixelBuffer result;
57331
57332   arg1 = (unsigned int)jarg1;
57333   arg2 = (unsigned int)jarg2;
57334   arg3 = (Dali::Pixel::Format)jarg3;
57335   {
57336     try {
57337       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57338     } CALL_CATCH_EXCEPTION(0);
57339   }
57340   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57341   return jresult;
57342 }
57343
57344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57345   void * jresult ;
57346   Dali::Devel::PixelBuffer *result = 0 ;
57347
57348   {
57349     try {
57350       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57351     } CALL_CATCH_EXCEPTION(0);
57352   }
57353   jresult = (void *)result;
57354   return jresult;
57355 }
57356
57357
57358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57359   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57360
57361   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57362   {
57363     try {
57364       delete arg1;
57365     } CALL_CATCH_EXCEPTION();
57366   }
57367 }
57368
57369
57370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57371   void * jresult ;
57372   Dali::Devel::PixelBuffer *arg1 = 0 ;
57373   Dali::Devel::PixelBuffer *result = 0 ;
57374
57375   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57376   if (!arg1) {
57377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57378     return 0;
57379   }
57380   {
57381     try {
57382       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57383     } CALL_CATCH_EXCEPTION(0);
57384   }
57385   jresult = (void *)result;
57386   return jresult;
57387 }
57388
57389
57390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57391   void * jresult ;
57392   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57393   Dali::Devel::PixelBuffer *arg2 = 0 ;
57394   Dali::Devel::PixelBuffer *result = 0 ;
57395
57396   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57397   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57398   if (!arg2) {
57399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57400     return 0;
57401   }
57402   {
57403     try {
57404       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57405     } CALL_CATCH_EXCEPTION(0);
57406   }
57407   jresult = (void *)result;
57408   return jresult;
57409 }
57410
57411
57412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57413   void * jresult ;
57414   Dali::Devel::PixelBuffer *arg1 = 0 ;
57415   Dali::PixelData result;
57416
57417   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57418   if (!arg1) {
57419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57420     return 0;
57421   }
57422   {
57423     try {
57424       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57425     } CALL_CATCH_EXCEPTION(0);
57426   }
57427   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57428   return jresult;
57429 }
57430
57431
57432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57433   void * jresult ;
57434   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57435   Dali::PixelData result;
57436
57437   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57438   {
57439     try {
57440       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57441     } CALL_CATCH_EXCEPTION(0);
57442   }
57443   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57444   return jresult;
57445 }
57446
57447
57448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57449   void * jresult ;
57450   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57451   unsigned char *result = 0 ;
57452
57453   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57454   {
57455     try {
57456       result = (unsigned char *)(arg1)->GetBuffer();
57457     } CALL_CATCH_EXCEPTION(0);
57458   }
57459    jresult = (void *)result;
57460    return jresult;
57461 }
57462
57463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57464   unsigned int jresult ;
57465   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57466   unsigned int result;
57467
57468   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57469   {
57470     try {
57471       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57472     } CALL_CATCH_EXCEPTION(0);
57473   }
57474   jresult = result;
57475   return jresult;
57476 }
57477
57478
57479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57480   unsigned int jresult ;
57481   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57482   unsigned int result;
57483
57484   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57485   {
57486     try {
57487       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57488     } CALL_CATCH_EXCEPTION(0);
57489   }
57490   jresult = result;
57491   return jresult;
57492 }
57493
57494
57495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57496   int jresult ;
57497   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57498   Dali::Pixel::Format result;
57499
57500   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57501   {
57502     try {
57503       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57504     } CALL_CATCH_EXCEPTION(0);
57505   }
57506   jresult = (int)result;
57507   return jresult;
57508 }
57509
57510
57511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57512   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57513   Dali::Devel::PixelBuffer arg2 ;
57514   float arg3 ;
57515   bool arg4 ;
57516   Dali::Devel::PixelBuffer *argp2 ;
57517
57518   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57519   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57520   if (!argp2) {
57521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57522     return ;
57523   }
57524   arg2 = *argp2;
57525   arg3 = (float)jarg3;
57526   arg4 = jarg4 ? true : false;
57527   {
57528     try {
57529       (arg1)->ApplyMask(arg2,arg3,arg4);
57530     } CALL_CATCH_EXCEPTION();
57531   }
57532 }
57533
57534
57535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57536   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57537   Dali::Devel::PixelBuffer arg2 ;
57538   float arg3 ;
57539   Dali::Devel::PixelBuffer *argp2 ;
57540
57541   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57542   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57543   if (!argp2) {
57544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57545     return ;
57546   }
57547   arg2 = *argp2;
57548   arg3 = (float)jarg3;
57549   {
57550     try {
57551       (arg1)->ApplyMask(arg2,arg3);
57552     } CALL_CATCH_EXCEPTION();
57553   }
57554 }
57555
57556
57557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57558   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57559   Dali::Devel::PixelBuffer arg2 ;
57560   Dali::Devel::PixelBuffer *argp2 ;
57561
57562   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57563   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57564   if (!argp2) {
57565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57566     return ;
57567   }
57568   arg2 = *argp2;
57569   {
57570     try {
57571       (arg1)->ApplyMask(arg2);
57572     } CALL_CATCH_EXCEPTION();
57573   }
57574 }
57575
57576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57577   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57578   float arg2 ;
57579
57580   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57581   arg2 = (float)jarg2;
57582   {
57583     try {
57584       (arg1)->ApplyGaussianBlur(arg2);
57585     } CALL_CATCH_EXCEPTION();
57586   }
57587 }
57588
57589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57590   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57591   uint16_t arg2 ;
57592   uint16_t arg3 ;
57593   uint16_t arg4 ;
57594   uint16_t arg5 ;
57595
57596   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57597   arg2 = (uint16_t)jarg2;
57598   arg3 = (uint16_t)jarg3;
57599   arg4 = (uint16_t)jarg4;
57600   arg5 = (uint16_t)jarg5;
57601   {
57602     try {
57603       (arg1)->Crop(arg2,arg3,arg4,arg5);
57604     } CALL_CATCH_EXCEPTION();
57605   }
57606 }
57607
57608
57609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57610   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57611   uint16_t arg2 ;
57612   uint16_t arg3 ;
57613
57614   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57615   arg2 = (uint16_t)jarg2;
57616   arg3 = (uint16_t)jarg3;
57617   {
57618     try {
57619       (arg1)->Resize(arg2,arg3);
57620     } CALL_CATCH_EXCEPTION();
57621   }
57622 }
57623
57624 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57625   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57626   Dali::Degree * arg2 ;
57627
57628   bool result = false;
57629
57630   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57631   arg2 = (Dali::Degree *)jarg2;
57632   {
57633     try {
57634       result = (arg1)->Rotate(*arg2);
57635     } CALL_CATCH_EXCEPTION(false);
57636   }
57637   return result;
57638 }
57639
57640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57641   void * jresult ;
57642   std::string *arg1 = 0 ;
57643   Dali::ImageDimensions arg2 ;
57644   Dali::FittingMode::Type arg3 ;
57645   Dali::SamplingMode::Type arg4 ;
57646   bool arg5 ;
57647   Dali::ImageDimensions *argp2 ;
57648   Dali::Devel::PixelBuffer result;
57649
57650   if (!jarg1) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57652     return 0;
57653   }
57654   std::string arg1_str(jarg1);
57655   arg1 = &arg1_str;
57656   argp2 = (Dali::ImageDimensions *)jarg2;
57657   if (!argp2) {
57658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57659     return 0;
57660   }
57661   arg2 = *argp2;
57662   arg3 = (Dali::FittingMode::Type)jarg3;
57663   arg4 = (Dali::SamplingMode::Type)jarg4;
57664   arg5 = jarg5 ? true : false;
57665   {
57666     try {
57667       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57668     } CALL_CATCH_EXCEPTION(0);
57669   }
57670   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57671   return jresult;
57672 }
57673
57674
57675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57676   void * jresult ;
57677   std::string *arg1 = 0 ;
57678   Dali::ImageDimensions arg2 ;
57679   Dali::FittingMode::Type arg3 ;
57680   Dali::SamplingMode::Type arg4 ;
57681   Dali::ImageDimensions *argp2 ;
57682   Dali::Devel::PixelBuffer result;
57683
57684   if (!jarg1) {
57685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57686     return 0;
57687   }
57688   std::string arg1_str(jarg1);
57689   arg1 = &arg1_str;
57690   argp2 = (Dali::ImageDimensions *)jarg2;
57691   if (!argp2) {
57692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57693     return 0;
57694   }
57695   arg2 = *argp2;
57696   arg3 = (Dali::FittingMode::Type)jarg3;
57697   arg4 = (Dali::SamplingMode::Type)jarg4;
57698   {
57699     try {
57700       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57701     } CALL_CATCH_EXCEPTION(0);
57702   }
57703   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57704   return jresult;
57705 }
57706
57707
57708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57709   void * jresult ;
57710   std::string *arg1 = 0 ;
57711   Dali::ImageDimensions arg2 ;
57712   Dali::FittingMode::Type arg3 ;
57713   Dali::ImageDimensions *argp2 ;
57714   Dali::Devel::PixelBuffer result;
57715
57716   if (!jarg1) {
57717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57718     return 0;
57719   }
57720   std::string arg1_str(jarg1);
57721   arg1 = &arg1_str;
57722   argp2 = (Dali::ImageDimensions *)jarg2;
57723   if (!argp2) {
57724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57725     return 0;
57726   }
57727   arg2 = *argp2;
57728   arg3 = (Dali::FittingMode::Type)jarg3;
57729   {
57730     try {
57731       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57732     } CALL_CATCH_EXCEPTION(0);
57733   }
57734   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57735   return jresult;
57736 }
57737
57738
57739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57740   void * jresult ;
57741   std::string *arg1 = 0 ;
57742   Dali::ImageDimensions arg2 ;
57743   Dali::ImageDimensions *argp2 ;
57744   Dali::Devel::PixelBuffer result;
57745
57746   if (!jarg1) {
57747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57748     return 0;
57749   }
57750   std::string arg1_str(jarg1);
57751   arg1 = &arg1_str;
57752   argp2 = (Dali::ImageDimensions *)jarg2;
57753   if (!argp2) {
57754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57755     return 0;
57756   }
57757   arg2 = *argp2;
57758   {
57759     try {
57760       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57761     } CALL_CATCH_EXCEPTION(0);
57762   }
57763   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57764   return jresult;
57765 }
57766
57767
57768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57769   void * jresult ;
57770   std::string *arg1 = 0 ;
57771   Dali::Devel::PixelBuffer result;
57772
57773   if (!jarg1) {
57774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57775     return 0;
57776   }
57777   std::string arg1_str(jarg1);
57778   arg1 = &arg1_str;
57779   {
57780     try {
57781       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57782     } CALL_CATCH_EXCEPTION(0);
57783   }
57784   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57785   return jresult;
57786 }
57787
57788
57789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57790   void * jresult ;
57791   std::string *arg1 = 0 ;
57792   Dali::ImageDimensions arg2 ;
57793   Dali::FittingMode::Type arg3 ;
57794   Dali::SamplingMode::Type arg4 ;
57795   bool arg5 ;
57796   Dali::ImageDimensions *argp2 ;
57797   Dali::ImageDimensions result;
57798
57799   if (!jarg1) {
57800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57801     return 0;
57802   }
57803   std::string arg1_str(jarg1);
57804   arg1 = &arg1_str;
57805   argp2 = (Dali::ImageDimensions *)jarg2;
57806   if (!argp2) {
57807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57808     return 0;
57809   }
57810   arg2 = *argp2;
57811   arg3 = (Dali::FittingMode::Type)jarg3;
57812   arg4 = (Dali::SamplingMode::Type)jarg4;
57813   arg5 = jarg5 ? true : false;
57814   {
57815     try {
57816       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57817     } CALL_CATCH_EXCEPTION(0);
57818   }
57819   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57820   return jresult;
57821 }
57822
57823
57824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57825   void * jresult ;
57826   std::string *arg1 = 0 ;
57827   Dali::ImageDimensions arg2 ;
57828   Dali::FittingMode::Type arg3 ;
57829   Dali::SamplingMode::Type arg4 ;
57830   Dali::ImageDimensions *argp2 ;
57831   Dali::ImageDimensions result;
57832
57833   if (!jarg1) {
57834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57835     return 0;
57836   }
57837   std::string arg1_str(jarg1);
57838   arg1 = &arg1_str;
57839   argp2 = (Dali::ImageDimensions *)jarg2;
57840   if (!argp2) {
57841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57842     return 0;
57843   }
57844   arg2 = *argp2;
57845   arg3 = (Dali::FittingMode::Type)jarg3;
57846   arg4 = (Dali::SamplingMode::Type)jarg4;
57847   {
57848     try {
57849       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57850     } CALL_CATCH_EXCEPTION(0);
57851   }
57852   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57853   return jresult;
57854 }
57855
57856
57857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57858   void * jresult ;
57859   std::string *arg1 = 0 ;
57860   Dali::ImageDimensions arg2 ;
57861   Dali::FittingMode::Type arg3 ;
57862   Dali::ImageDimensions *argp2 ;
57863   Dali::ImageDimensions result;
57864
57865   if (!jarg1) {
57866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57867     return 0;
57868   }
57869   std::string arg1_str(jarg1);
57870   arg1 = &arg1_str;
57871   argp2 = (Dali::ImageDimensions *)jarg2;
57872   if (!argp2) {
57873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57874     return 0;
57875   }
57876   arg2 = *argp2;
57877   arg3 = (Dali::FittingMode::Type)jarg3;
57878   {
57879     try {
57880       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57881     } CALL_CATCH_EXCEPTION(0);
57882   }
57883   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57884   return jresult;
57885 }
57886
57887
57888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57889   void * jresult ;
57890   std::string *arg1 = 0 ;
57891   Dali::ImageDimensions arg2 ;
57892   Dali::ImageDimensions *argp2 ;
57893   Dali::ImageDimensions result;
57894
57895   if (!jarg1) {
57896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57897     return 0;
57898   }
57899   std::string arg1_str(jarg1);
57900   arg1 = &arg1_str;
57901   argp2 = (Dali::ImageDimensions *)jarg2;
57902   if (!argp2) {
57903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57904     return 0;
57905   }
57906   arg2 = *argp2;
57907   {
57908     try {
57909       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57910     } CALL_CATCH_EXCEPTION(0);
57911   }
57912   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57913   return jresult;
57914 }
57915
57916
57917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57918   void * jresult ;
57919   std::string *arg1 = 0 ;
57920   Dali::ImageDimensions result;
57921
57922   if (!jarg1) {
57923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57924     return 0;
57925   }
57926   std::string arg1_str(jarg1);
57927   arg1 = &arg1_str;
57928   {
57929     try {
57930       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57931     } CALL_CATCH_EXCEPTION(0);
57932   }
57933   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57934   return jresult;
57935 }
57936
57937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57938   void * jresult ;
57939   std::string *arg1 = 0 ;
57940   Dali::ImageDimensions result;
57941
57942   if (!jarg1) {
57943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57944     return 0;
57945   }
57946   std::string arg1_str(jarg1);
57947   arg1 = &arg1_str;
57948   {
57949     try {
57950       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
57951     } CALL_CATCH_EXCEPTION(0);
57952   }
57953   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57954   return jresult;
57955 }
57956
57957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57958   void * jresult ;
57959   std::string *arg1 = 0 ;
57960   Dali::ImageDimensions arg2 ;
57961   Dali::FittingMode::Type arg3 ;
57962   Dali::SamplingMode::Type arg4 ;
57963   bool arg5 ;
57964   Dali::ImageDimensions *argp2 ;
57965   Dali::Devel::PixelBuffer result;
57966
57967   if (!jarg1) {
57968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57969     return 0;
57970   }
57971   std::string arg1_str(jarg1);
57972   arg1 = &arg1_str;
57973   argp2 = (Dali::ImageDimensions *)jarg2;
57974   if (!argp2) {
57975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57976     return 0;
57977   }
57978   arg2 = *argp2;
57979   arg3 = (Dali::FittingMode::Type)jarg3;
57980   arg4 = (Dali::SamplingMode::Type)jarg4;
57981   arg5 = jarg5 ? true : false;
57982   {
57983     try {
57984       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57985     } CALL_CATCH_EXCEPTION(0);
57986   }
57987   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57988   return jresult;
57989 }
57990
57991
57992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57993   void * jresult ;
57994   std::string *arg1 = 0 ;
57995   Dali::ImageDimensions arg2 ;
57996   Dali::FittingMode::Type arg3 ;
57997   Dali::SamplingMode::Type arg4 ;
57998   Dali::ImageDimensions *argp2 ;
57999   Dali::Devel::PixelBuffer result;
58000
58001   if (!jarg1) {
58002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58003     return 0;
58004   }
58005   std::string arg1_str(jarg1);
58006   arg1 = &arg1_str;
58007   argp2 = (Dali::ImageDimensions *)jarg2;
58008   if (!argp2) {
58009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58010     return 0;
58011   }
58012   arg2 = *argp2;
58013   arg3 = (Dali::FittingMode::Type)jarg3;
58014   arg4 = (Dali::SamplingMode::Type)jarg4;
58015   {
58016     try {
58017       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
58018     } CALL_CATCH_EXCEPTION(0);
58019   }
58020   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58021   return jresult;
58022 }
58023
58024
58025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58026   void * jresult ;
58027   std::string *arg1 = 0 ;
58028   Dali::ImageDimensions arg2 ;
58029   Dali::FittingMode::Type arg3 ;
58030   Dali::ImageDimensions *argp2 ;
58031   Dali::Devel::PixelBuffer result;
58032
58033   if (!jarg1) {
58034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58035     return 0;
58036   }
58037   std::string arg1_str(jarg1);
58038   arg1 = &arg1_str;
58039   argp2 = (Dali::ImageDimensions *)jarg2;
58040   if (!argp2) {
58041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58042     return 0;
58043   }
58044   arg2 = *argp2;
58045   arg3 = (Dali::FittingMode::Type)jarg3;
58046   {
58047     try {
58048       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
58049     } CALL_CATCH_EXCEPTION(0);
58050   }
58051   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58052   return jresult;
58053 }
58054
58055
58056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
58057   void * jresult ;
58058   std::string *arg1 = 0 ;
58059   Dali::ImageDimensions arg2 ;
58060   Dali::ImageDimensions *argp2 ;
58061   Dali::Devel::PixelBuffer result;
58062
58063   if (!jarg1) {
58064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58065     return 0;
58066   }
58067   std::string arg1_str(jarg1);
58068   arg1 = &arg1_str;
58069   argp2 = (Dali::ImageDimensions *)jarg2;
58070   if (!argp2) {
58071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58072     return 0;
58073   }
58074   arg2 = *argp2;
58075   {
58076     try {
58077       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
58078     } CALL_CATCH_EXCEPTION(0);
58079   }
58080   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58081   return jresult;
58082 }
58083
58084
58085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
58086   void * jresult ;
58087   std::string *arg1 = 0 ;
58088   Dali::Devel::PixelBuffer result;
58089
58090   if (!jarg1) {
58091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58092     return 0;
58093   }
58094   std::string arg1_str(jarg1);
58095   arg1 = &arg1_str;
58096   {
58097     try {
58098       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
58099     } CALL_CATCH_EXCEPTION(0);
58100   }
58101   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58102   return jresult;
58103 }
58104
58105
58106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
58107   void * jresult ;
58108   Dali::Toolkit::WebView result;
58109
58110   {
58111     try {
58112       result = Dali::Toolkit::WebView::New();
58113     } CALL_CATCH_EXCEPTION(0);
58114   }
58115   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58116   return jresult;
58117 }
58118
58119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
58120   void * jresult ;
58121   Dali::Toolkit::WebView result;
58122
58123   std::string *arg1;
58124   std::string *arg2;
58125
58126   if (!jarg1) {
58127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
58128     return 0;
58129   }
58130   if (!jarg2) {
58131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
58132     return 0;
58133   }
58134
58135   std::string jarg1_str = std::string(jarg1);
58136   std::string jarg2_str = std::string(jarg2);
58137
58138   arg1 = &jarg1_str;
58139   arg2 = &jarg2_str;
58140
58141   {
58142     try {
58143       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
58144     } CALL_CATCH_EXCEPTION(0);
58145   }
58146   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58147   return jresult;
58148 }
58149
58150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
58151   void * jresult ;
58152   Dali::Toolkit::WebView *arg1 = 0 ;
58153   Dali::Toolkit::WebView *result = 0 ;
58154
58155   arg1 = (Dali::Toolkit::WebView *)jarg1;
58156   if (!arg1) {
58157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58158     return 0;
58159   }
58160   {
58161     try {
58162       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
58163     } CALL_CATCH_EXCEPTION(0);
58164   }
58165   jresult = (void *)result;
58166   return jresult;
58167 }
58168
58169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
58170   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58171   arg1 = (Dali::Toolkit::WebView *)jarg1;
58172   {
58173     try {
58174       delete arg1;
58175     } CALL_CATCH_EXCEPTION();
58176   }
58177 }
58178
58179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
58180   void * jresult ;
58181   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58182   Dali::Toolkit::WebView *arg2 = 0 ;
58183   Dali::Toolkit::WebView *result = 0 ;
58184
58185   arg1 = (Dali::Toolkit::WebView *)jarg1;
58186   arg2 = (Dali::Toolkit::WebView *)jarg2;
58187   if (!arg2) {
58188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58189     return 0;
58190   }
58191   {
58192     try {
58193       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
58194     } CALL_CATCH_EXCEPTION(0);
58195   }
58196   jresult = (void *)result;
58197   return jresult;
58198 }
58199
58200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
58201   void * jresult ;
58202   Dali::BaseHandle arg1 ;
58203   Dali::BaseHandle *argp1 ;
58204   Dali::Toolkit::WebView result;
58205
58206   argp1 = (Dali::BaseHandle *)jarg1;
58207   if (!argp1) {
58208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58209     return 0;
58210   }
58211   arg1 = *argp1;
58212   {
58213     try {
58214       result = Dali::Toolkit::WebView::DownCast(arg1);
58215     } CALL_CATCH_EXCEPTION(0);
58216   }
58217   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58218   return jresult;
58219 }
58220
58221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58222   return (int) Dali::Toolkit::WebView::Property::URL;
58223 }
58224
58225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58226   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58227 }
58228
58229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58230   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58231 }
58232
58233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58234   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58235 }
58236
58237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58238   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58239 }
58240
58241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58242   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58243 }
58244
58245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58246   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58247 }
58248
58249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58250   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58251 }
58252
58253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58254   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58255   std::string *arg2;
58256
58257   arg1 = (Dali::Toolkit::WebView *)jarg1;
58258
58259   if (!jarg2) {
58260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58261     return;
58262   }
58263
58264   std::string jarg2str = std::string(jarg2);
58265   arg2 = &jarg2str;
58266   {
58267     try {
58268       (arg1)->LoadUrl((std::string const &)*arg2);
58269     } CALL_CATCH_EXCEPTION();
58270   }
58271 }
58272
58273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58274   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58275   std::string *arg2;
58276
58277   arg1 = (Dali::Toolkit::WebView *)jarg1;
58278   if (!jarg2) {
58279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58280     return;
58281   }
58282   std::string jarg2str = std::string(jarg2);
58283   arg2 = &jarg2str;
58284   {
58285     try {
58286       (arg1)->LoadHTMLString((std::string const &)*arg2);
58287     } CALL_CATCH_EXCEPTION();
58288   }
58289 }
58290
58291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58292   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58293
58294   arg1 = (Dali::Toolkit::WebView *)jarg1;
58295   {
58296     try {
58297       (arg1)->Reload();
58298     } CALL_CATCH_EXCEPTION();
58299   }
58300 }
58301
58302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58303   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58304
58305   arg1 = (Dali::Toolkit::WebView *)jarg1;
58306   {
58307     try {
58308       (arg1)->StopLoading();
58309     } CALL_CATCH_EXCEPTION();
58310   }
58311 }
58312
58313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58314   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58315
58316   arg1 = (Dali::Toolkit::WebView *)jarg1;
58317   {
58318     try {
58319       (arg1)->Suspend();
58320     } CALL_CATCH_EXCEPTION();
58321   }
58322 }
58323
58324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58325   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58326
58327   arg1 = (Dali::Toolkit::WebView *)jarg1;
58328   {
58329     try {
58330       (arg1)->Resume();
58331     } CALL_CATCH_EXCEPTION();
58332   }
58333 }
58334
58335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58336   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58337
58338   arg1 = (Dali::Toolkit::WebView *)jarg1;
58339   {
58340     try {
58341       (arg1)->GoBack();
58342     } CALL_CATCH_EXCEPTION();
58343   }
58344 }
58345
58346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58347   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58348
58349   arg1 = (Dali::Toolkit::WebView *)jarg1;
58350   {
58351     try {
58352       (arg1)->GoForward();
58353     } CALL_CATCH_EXCEPTION();
58354   }
58355 }
58356
58357 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58358   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58359   bool ret;
58360
58361   arg1 = (Dali::Toolkit::WebView *)jarg1;
58362   {
58363     try {
58364       ret = (arg1)->CanGoBack();
58365     } CALL_CATCH_EXCEPTION(0);
58366   }
58367   return ret;
58368 }
58369
58370 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58371   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58372   bool ret;
58373
58374   arg1 = (Dali::Toolkit::WebView *)jarg1;
58375   {
58376     try {
58377       ret = (arg1)->CanGoForward();
58378     } CALL_CATCH_EXCEPTION(0);
58379   }
58380   return ret;
58381 }
58382
58383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58384   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58385   std::string *arg2;
58386
58387   arg1 = (Dali::Toolkit::WebView *)jarg1;
58388   if (!jarg2) {
58389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58390     return;
58391   }
58392   std::string jarg2_str = std::string(jarg2);
58393   arg2 = &jarg2_str;
58394
58395   {
58396     try {
58397       if (jarg3) {
58398         void (*handler)(char*) = (void (*)(char*)) jarg3;
58399         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58400           handler(SWIG_csharp_string_callback(result.c_str()));
58401         });
58402       } else {
58403         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58404       }
58405     } CALL_CATCH_EXCEPTION();
58406   }
58407 }
58408
58409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58410 {
58411   if (!jarg2) {
58412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58413     return;
58414   }
58415
58416   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58417   std::string exposedObjectName = jarg2;
58418   void (*handler)(char*) = (void (*)(char*)) jarg3;
58419
58420   {
58421     try {
58422       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58423         handler(SWIG_csharp_string_callback(message.c_str()));
58424       });
58425     } CALL_CATCH_EXCEPTION();
58426   }
58427 }
58428
58429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58430   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58431
58432   arg1 = (Dali::Toolkit::WebView *)jarg1;
58433   {
58434     try {
58435       (arg1)->ClearHistory();
58436     } CALL_CATCH_EXCEPTION();
58437   }
58438 }
58439
58440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58441   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58442
58443   arg1 = (Dali::Toolkit::WebView *)jarg1;
58444   {
58445     try {
58446       (arg1)->ClearCache();
58447     } CALL_CATCH_EXCEPTION();
58448   }
58449 }
58450
58451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58452   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58453
58454   arg1 = (Dali::Toolkit::WebView *)jarg1;
58455   {
58456     try {
58457       (arg1)->ClearCookies();
58458     } CALL_CATCH_EXCEPTION();
58459   }
58460 }
58461
58462 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58463     return (Dali::Toolkit::Control *)jarg1;
58464 }
58465
58466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58467   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58468   SignalConverter::WebViewPageLoadSignal* result = NULL;
58469   {
58470     try {
58471       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58472     } CALL_CATCH_EXCEPTION(0);
58473   }
58474   return (void*) result;
58475 }
58476
58477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58478   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58479   SignalConverter::WebViewPageLoadSignal* result = NULL;
58480   {
58481     try {
58482       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58483     } CALL_CATCH_EXCEPTION(0);
58484   }
58485   return (void*) result;
58486 }
58487
58488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58489 {
58490   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58491   {
58492     try {
58493       delete object;
58494     } CALL_CATCH_EXCEPTION();
58495   }
58496 }
58497
58498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58499 {
58500   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58501   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58502   {
58503     try {
58504       proxy->Connect(callback);
58505     } CALL_CATCH_EXCEPTION();
58506   }
58507 }
58508
58509
58510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58511   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58512   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58513   {
58514     try {
58515       proxy->Disconnect(callback);
58516     } CALL_CATCH_EXCEPTION();
58517   }
58518 }
58519
58520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58521   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58522   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58523   {
58524     try {
58525       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58526     } CALL_CATCH_EXCEPTION(0);
58527   }
58528   return (void*) result;
58529 }
58530
58531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58532 {
58533   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58534   {
58535     try {
58536       delete object;
58537     } CALL_CATCH_EXCEPTION();
58538   }
58539 }
58540
58541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58542 {
58543   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58544   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58545   {
58546     try {
58547       proxy->Connect(callback);
58548     } CALL_CATCH_EXCEPTION();
58549   }
58550 }
58551
58552
58553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58554   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58555   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58556   {
58557     try {
58558       proxy->Disconnect(callback);
58559     } CALL_CATCH_EXCEPTION();
58560   }
58561 }
58562
58563 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58564   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58565   char * jresult = SWIG_csharp_string_callback((const char *)result);
58566   return jresult;
58567 }
58568
58569 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58570   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58571   return result;
58572 }
58573
58574
58575 struct NativeImageSourcePtrHandle
58576 {
58577   NativeImageSourcePtr Ptr;
58578 };
58579
58580 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58581 {
58582   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58583   return (NativeImageInterface*)(arg1);
58584 }
58585
58586 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58587 {
58588   void* jresult;
58589   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58590   {
58591     try {
58592       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58593     }
58594     catch (std::out_of_range & e) {
58595       {
58596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58597       };
58598     }
58599     catch (std::exception & e) {
58600       {
58601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58602       };
58603     }
58604     catch (Dali::DaliException e) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58607       };
58608     }
58609     catch (...) {
58610       {
58611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58612       };
58613     }
58614   }
58615   jresult = (void *)handle;
58616   return jresult;
58617 }
58618
58619 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58620 {
58621   void* jresult;
58622   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58623   jresult = (void*)( handle->Ptr.Get() );
58624   return jresult;
58625 }
58626
58627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58628   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58629   {
58630     try {
58631       delete arg1;
58632     }
58633     catch (std::out_of_range & e) {
58634       {
58635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58636       };
58637     }
58638     catch (std::exception & e) {
58639       {
58640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58641       };
58642     }
58643     catch (Dali::DaliException e) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58646       };
58647     }
58648     catch (...) {
58649       {
58650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58651       };
58652     }
58653   }
58654 }
58655
58656 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58657 {
58658   void* jresult;
58659   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58660   uint16_t* arg2 = (uint16_t*)(jarg2);
58661   uint16_t* arg3 = (uint16_t*)(jarg3);
58662   uint16_t* arg4 = (uint16_t*)(jarg4);
58663   {
58664     try {
58665       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58666     }
58667     catch (std::out_of_range & e) {
58668       {
58669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58670       };
58671     }
58672     catch (std::exception & e) {
58673       {
58674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58675       };
58676     }
58677     catch (Dali::DaliException e) {
58678       {
58679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58680       };
58681     }
58682     catch (...) {
58683       {
58684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58685       };
58686     }
58687   }
58688   return jresult;
58689 }
58690
58691 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58692 {
58693   bool jresult;
58694   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58695
58696   {
58697     try {
58698       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58699     }
58700     catch (std::out_of_range & e) {
58701       {
58702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58703       };
58704     }
58705     catch (std::exception & e) {
58706       {
58707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58708       };
58709     }
58710     catch (Dali::DaliException e) {
58711       {
58712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58713       };
58714     }
58715     catch (...) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58718       };
58719     }
58720   }
58721   return jresult;
58722 }
58723
58724
58725 #ifdef __cplusplus
58726 }
58727 #endif