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
  18 /* -----------------------------------------------------------------------------
  19  *  This section contains generic SWIG labels for method/variable
  20  *  declarations/attributes, and other compiler dependent labels.
  21  * ----------------------------------------------------------------------------- */
  22
  23 /* template workaround for compilers that cannot correctly implement the C++ standard */
  24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  26 #  define SWIGTEMPLATEDISAMBIGUATOR template
  27 # elif defined(__HP_aCC)
  28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  30 #  define SWIGTEMPLATEDISAMBIGUATOR template
  31 # else
  32 #  define SWIGTEMPLATEDISAMBIGUATOR
  33 # endif
  34 #endif
  35
  36 /* inline attribute */
  37 #ifndef SWIGINLINE
  38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  39 #   define SWIGINLINE inline
  40 # else
  41 #   define SWIGINLINE
  42 # endif
  43 #endif
  44
  45 /* attribute recognised by some compilers to avoid 'unused' warnings */
  46 #ifndef SWIGUNUSED
  47 # if defined(__GNUC__)
  48 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  49 #     define SWIGUNUSED __attribute__ ((__unused__))
  50 #   else
  51 #     define SWIGUNUSED
  52 #   endif
  53 # elif defined(__ICC)
  54 #   define SWIGUNUSED __attribute__ ((__unused__))
  55 # else
  56 #   define SWIGUNUSED
  57 # endif
  58 #endif
  59
  60 #ifndef SWIG_MSC_UNSUPPRESS_4505
  61 # if defined(_MSC_VER)
  62 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  63 # endif
  64 #endif
  65
  66 #ifndef SWIGUNUSEDPARM
  67 # ifdef __cplusplus
  68 #   define SWIGUNUSEDPARM(p)
  69 # else
  70 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  71 # endif
  72 #endif
  73
  74 /* internal SWIG method */
  75 #ifndef SWIGINTERN
  76 # define SWIGINTERN static SWIGUNUSED
  77 #endif
  78
  79 /* internal inline SWIG method */
  80 #ifndef SWIGINTERNINLINE
  81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  82 #endif
  83
  84 /* exporting methods */
  85 #if defined(__GNUC__)
  86 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  87 #    ifndef GCC_HASCLASSVISIBILITY
  88 #      define GCC_HASCLASSVISIBILITY
  89 #    endif
  90 #  endif
  91 #endif
  92
  93 #ifndef SWIGEXPORT
  94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  95 #   if defined(STATIC_LINKED)
  96 #     define SWIGEXPORT
  97 #   else
  98 #     define SWIGEXPORT __declspec(dllexport)
  99 #   endif
 100 # else
 101 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 102 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 103 #   else
 104 #     define SWIGEXPORT
 105 #   endif
 106 # endif
 107 #endif
 108
 109 /* calling conventions for Windows */
 110 #ifndef SWIGSTDCALL
 111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 112 #   define SWIGSTDCALL __stdcall
 113 # else
 114 #   define SWIGSTDCALL
 115 # endif
 116 #endif
 117
 118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 120 # define _CRT_SECURE_NO_DEPRECATE
 121 #endif
 122
 123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 125 # define _SCL_SECURE_NO_DEPRECATE
 126 #endif
 127
 128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 131 #endif
 132
 133 /* Intel's compiler complains if a variable which was never initialised is
 134  * cast to void, which is a common idiom which we use to indicate that we
 135  * are aware a variable isn't used.  So we just silence that warning.
 136  * See: https://github.com/swig/swig/issues/192 for more discussion.
 137  */
 138 #ifdef __INTEL_COMPILER
 139 # pragma warning disable 592
 140 #endif
 141
 142
 143 #include <stdlib.h>
 144 #include <string.h>
 145 #include <string_view>
 146 #include <stdio.h>
 147
 148 #include "common.h"
 149 #include "slim-custom-view-impl.h"
 150
 151 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 152   { SWIG_CSharpApplicationException, NULL },
 153   { SWIG_CSharpArithmeticException, NULL },
 154   { SWIG_CSharpDivideByZeroException, NULL },
 155   { SWIG_CSharpIndexOutOfRangeException, NULL },
 156   { SWIG_CSharpInvalidCastException, NULL },
 157   { SWIG_CSharpInvalidOperationException, NULL },
 158   { SWIG_CSharpIOException, NULL },
 159   { SWIG_CSharpNullReferenceException, NULL },
 160   { SWIG_CSharpOutOfMemoryException, NULL },
 161   { SWIG_CSharpOverflowException, NULL },
 162   { SWIG_CSharpSystemException, NULL }
 163 };
 164
 165 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 166   { SWIG_CSharpArgumentException, NULL },
 167   { SWIG_CSharpArgumentNullException, NULL },
 168   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 169 };
 170
 171 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 172   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 173   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 174     callback = SWIG_csharp_exceptions[code].callback;
 175   }
 176   callback(msg);
 177 }
 178
 179 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 180   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 181   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 182     callback = SWIG_csharp_exceptions_argument[code].callback;
 183   }
 184   callback(msg, param_name);
 185 }
 186
 187
 188 #ifdef __cplusplus
 189 extern "C"
 190 #endif
 191 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 192                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 193                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 194                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 195                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 196                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 197                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 198                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 199                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 200                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 201                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 202                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 203   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 204   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 205   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 206   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 207   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 208   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 209   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 210   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 211   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 212   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 213   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 214 }
 215
 216 #ifdef __cplusplus
 217 extern "C"
 218 #endif
 219 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 220                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 221                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 222                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 223   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 224   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 225   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 226 }
 227
 228
 229 /* Callback for returning strings to C# without leaking memory */
 230 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 231 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 232
 233 // keep argWidgetCs and argWidgetV so they're always available to DALi
 234 int argWidgetC = 1;
 235 char **argWidgetV = NULL;
 236
 237 #ifdef __cplusplus
 238 extern "C"
 239 #endif
 240 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 241   SWIG_csharp_string_callback = callback;
 242 }
 243
 244
 245 /* Contract support */
 246 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 247
 248
 249 /* -----------------------------------------------------------------------------
 250  * director_common.swg
 251  *
 252  * This file contains support for director classes which is common between
 253  * languages.
 254  * ----------------------------------------------------------------------------- */
 255
 256 /*
 257   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 258   'Swig' namespace. This could be useful for multi-modules projects.
 259 */
 260 #ifdef SWIG_DIRECTOR_STATIC
 261 /* Force anonymous (static) namespace */
 262 #define Swig
 263 #endif
 264 /* -----------------------------------------------------------------------------
 265  * director.swg
 266  *
 267  * This file contains support for director classes so that C# proxy
 268  * methods can be called from C++.
 269  * ----------------------------------------------------------------------------- */
 270
 271 #if defined(DEBUG_DIRECTOR_OWNED)
 272 #include <iostream>
 273 #endif
 274 #include <string>
 275 #include <exception>
 276
 277 namespace Swig {
 278   /* Director base class - not currently used in C# directors */
 279   class Director {
 280   };
 281
 282   /* Base class for director exceptions */
 283   class DirectorException : public std::exception {
 284   protected:
 285     std::string swig_msg;
 286
 287   public:
 288     DirectorException(const char *msg) : swig_msg(msg) {
 289     }
 290
 291     DirectorException(const std::string &msg) : swig_msg(msg) {
 292     }
 293
 294     virtual ~DirectorException() throw() {
 295     }
 296
 297     const char *what() const throw() {
 298       return swig_msg.c_str();
 299     }
 300   };
 301
 302   /* Pure virtual method exception */
 303   class DirectorPureVirtualException : public DirectorException {
 304   public:
 305     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 306     }
 307   };
 308 }
 309
 310
 311 void SWIG_CSharpException(int code, const char *msg) {
 312   if (code == SWIG_ValueError) {
 313     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 314     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 315   } else {
 316     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 317     switch(code) {
 318     case SWIG_MemoryError:
 319       exception_code = SWIG_CSharpOutOfMemoryException;
 320       break;
 321     case SWIG_IndexError:
 322       exception_code = SWIG_CSharpIndexOutOfRangeException;
 323       break;
 324     case SWIG_DivisionByZero:
 325       exception_code = SWIG_CSharpDivideByZeroException;
 326       break;
 327     case SWIG_IOError:
 328       exception_code = SWIG_CSharpIOException;
 329       break;
 330     case SWIG_OverflowError:
 331       exception_code = SWIG_CSharpOverflowException;
 332       break;
 333     case SWIG_RuntimeError:
 334     case SWIG_TypeError:
 335     case SWIG_SyntaxError:
 336     case SWIG_SystemError:
 337     case SWIG_UnknownError:
 338     default:
 339       exception_code = SWIG_CSharpApplicationException;
 340       break;
 341     }
 342     SWIG_CSharpSetPendingException(exception_code, msg);
 343   }
 344 }
 345
 346
 347 #include <stdexcept>
 348
 349
 350 #define SWIGSTDCALL
 351
 352 #include <time.h>
 353
 354 #include <dali/dali.h>
 355 #include <dali-toolkit/dali-toolkit.h>
 356
 357 #include <dali/devel-api/actors/actor-devel.h>
 358 #include <dali/devel-api/actors/camera-actor-devel.h>
 359 #include <dali/devel-api/animation/key-frames-devel.h>
 360 #include <dali/devel-api/common/stage-devel.h>
 361 #include <dali/devel-api/events/key-event-devel.h>
 362 #include <dali/devel-api/events/wheel-event-devel.h>
 363 #include <dali/devel-api/events/hover-event-devel.h>
 364 #include <dali/devel-api/events/touch-point.h>
 365 #include <dali/devel-api/events/pan-gesture-devel.h>
 366 #include <dali/devel-api/events/pinch-gesture-devel.h>
 367 #include <dali/devel-api/events/long-press-gesture-devel.h>
 368 #include <dali/devel-api/events/tap-gesture-devel.h>
 369
 370 #include <dali/public-api/math/matrix.h>
 371 #include <dali/public-api/math/matrix3.h>
 372 #include <dali/public-api/math/viewport.h>
 373 #include <dali/public-api/object/property-key.h>
 374 #include <dali/devel-api/object/csharp-type-info.h>
 375 #include <dali/devel-api/object/csharp-type-registry.h>
 376
 377 #include <dali/public-api/adaptor-framework/timer.h>
 378 #include <dali/public-api/adaptor-framework/style-change.h>
 379 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 380
 381 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 382
 383 #include <dali-toolkit/devel-api/builder/builder.h>
 384
 385 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 386 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 387
 388 #include <dali-toolkit/devel-api/controls/control-devel.h>
 389 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 390 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 391 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 392 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 393 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 394 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 395 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 396 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 397
 398 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 399 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 400 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 401
 402 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 403 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 404 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 405
 406 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 407 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 408 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 409
 410 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 411
 412 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 413 #include <dali/devel-api/adaptor-framework/image-loading.h>
 414
 415 #include <dali/public-api/events/mouse-button.h>
 416
 417 #include <dali/integration-api/debug.h>
 418
 419 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 420
 421 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 422 #include <dali/devel-api/adaptor-framework/window-system-devel.h>
 423
 424 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 425
 426 #include <dali/devel-api/update/frame-callback-interface.h>
 427 #include <dali/devel-api/update/update-proxy.h>
 428
 429 #include <dali-toolkit/public-api/image-loader/image.h>
 430 #include <dali-toolkit/public-api/image-loader/image-url.h>
 431
 432
 433 // add here SWIG version check
 434
 435 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 436 // disable Swig-dependent warnings
 437
 438 // 'identifier1' has C-linkage specified,
 439 // but returns UDT 'identifier2' which is incompatible with C
 440 #pragma warning(disable: 4190)
 441
 442 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 443 #pragma warning(disable: 4800)
 444
 445 // debug info too long etc etc
 446 #pragma warning(disable: 4786)
 447 #endif
 448
 449
 450 #include <stdexcept>
 451
 452
 453 #include <string>
 454
 455
 456 #include <vector>
 457 #include <algorithm>
 458 #include <stdexcept>
 459
 460
 461 #include <map>
 462 #include <algorithm>
 463 #include <stdexcept>
 464
 465
 466 #include <utility>
 467
 468
 469 typedef float floatp;
 470
 471 SWIGINTERN floatp *new_floatp(){
 472   return new float();
 473 }
 474 SWIGINTERN void delete_floatp(floatp *self){
 475   if (self) delete self;
 476 }
 477 SWIGINTERN void floatp_assign(floatp *self,float value){
 478   *self = value;
 479 }
 480 SWIGINTERN float floatp_value(floatp *self){
 481   return *self;
 482 }
 483 SWIGINTERN float *floatp_cast(floatp *self){
 484   return self;
 485 }
 486 SWIGINTERN floatp *floatp_frompointer(float *t){
 487   return (floatp *) t;
 488 }
 489
 490 typedef int intp;
 491
 492 SWIGINTERN intp *new_intp(){
 493   return new int();
 494 }
 495 SWIGINTERN void delete_intp(intp *self){
 496   if (self) delete self;
 497 }
 498 SWIGINTERN void intp_assign(intp *self,int value){
 499   *self = value;
 500 }
 501 SWIGINTERN int intp_value(intp *self){
 502   return *self;
 503 }
 504 SWIGINTERN int *intp_cast(intp *self){
 505   return self;
 506 }
 507 SWIGINTERN intp *intp_frompointer(int *t){
 508   return (intp *) t;
 509 }
 510
 511 typedef double doublep;
 512
 513 SWIGINTERN doublep *new_doublep(){
 514   return new double();
 515 }
 516 SWIGINTERN void delete_doublep(doublep *self){
 517   if (self) delete self;
 518 }
 519 SWIGINTERN void doublep_assign(doublep *self,double value){
 520   *self = value;
 521 }
 522 SWIGINTERN double doublep_value(doublep *self){
 523   return *self;
 524 }
 525 SWIGINTERN double *doublep_cast(doublep *self){
 526   return self;
 527 }
 528 SWIGINTERN doublep *doublep_frompointer(double *t){
 529   return (doublep *) t;
 530 }
 531
 532 typedef unsigned int uintp;
 533
 534 SWIGINTERN uintp *new_uintp(){
 535   return new unsigned int();
 536 }
 537 SWIGINTERN void delete_uintp(uintp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 541   *self = value;
 542 }
 543 SWIGINTERN unsigned int uintp_value(uintp *self){
 544   return *self;
 545 }
 546 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 547   return self;
 548 }
 549 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 550   return (uintp *) t;
 551 }
 552
 553 typedef unsigned short ushortp;
 554
 555 SWIGINTERN ushortp *new_ushortp(){
 556   return new unsigned short();
 557 }
 558 SWIGINTERN void delete_ushortp(ushortp *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 562   *self = value;
 563 }
 564 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 565   return *self;
 566 }
 567 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 568   return self;
 569 }
 570 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 571   return (ushortp *) t;
 572 }
 573
 574 unsigned int int_to_uint(int x) {
 575    return (unsigned int) x;
 576 }
 577
 578
 579 using namespace Dali;
 580 using namespace Dali::Toolkit;
 581
 582 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 583 {
 584   bool result = false;
 585   try
 586   {
 587     // C++ code. DALi uses Handle <-> Body design pattern.
 588     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 589     // Handles in DALi can be converted into a boolean type
 590     // to check if the handle has a valid body attached to it.
 591     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 592     if( *self )
 593     {
 594       result = true;
 595     }
 596     else
 597     {
 598       result = false;
 599     }
 600   }
 601   CALL_CATCH_EXCEPTION(false);
 602   return result;
 603 }
 604
 605 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 606 {
 607   bool result = false;
 608   try
 609   {
 610     // C++ code. Check if two handles reference the same implemtion
 611     if( *self == rhs)
 612     {
 613       result = true;
 614     }
 615     else
 616     {
 617       result = false;
 618     }
 619   }
 620   CALL_CATCH_EXCEPTION(false);
 621   return result;
 622 }
 623
 624
 625 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 626      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 627    }
 628 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){
 629      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 630    }
 631 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 632         std::vector< Dali::TouchPoint >* pv = 0;
 633         if (capacity >= 0) {
 634           pv = new std::vector< Dali::TouchPoint >();
 635           pv->reserve(capacity);
 636        } else {
 637           throw std::out_of_range("capacity");
 638        }
 639        return pv;
 640       }
 641 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 642         if (index>=0 && index<(int)self->size())
 643           return (*self)[index];
 644         else
 645           throw std::out_of_range("index");
 646       }
 647 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 648         if (index>=0 && index<(int)self->size())
 649           return (*self)[index];
 650         else
 651           throw std::out_of_range("index");
 652       }
 653 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 654         if (index>=0 && index<(int)self->size())
 655           (*self)[index] = val;
 656         else
 657           throw std::out_of_range("index");
 658       }
 659 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 660         self->insert(self->end(), values.begin(), values.end());
 661       }
 662 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 663         if (index < 0)
 664           throw std::out_of_range("index");
 665         if (count < 0)
 666           throw std::out_of_range("count");
 667         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 668           throw std::invalid_argument("invalid range");
 669         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 670       }
 671 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 672         if (index>=0 && index<(int)self->size()+1)
 673           self->insert(self->begin()+index, x);
 674         else
 675           throw std::out_of_range("index");
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 678         if (index>=0 && index<(int)self->size()+1)
 679           self->insert(self->begin()+index, values.begin(), values.end());
 680         else
 681           throw std::out_of_range("index");
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 684         if (index>=0 && index<(int)self->size())
 685           self->erase(self->begin() + index);
 686         else
 687           throw std::out_of_range("index");
 688       }
 689 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 690         if (index < 0)
 691           throw std::out_of_range("index");
 692         if (count < 0)
 693           throw std::out_of_range("count");
 694         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 695           throw std::invalid_argument("invalid range");
 696         self->erase(self->begin()+index, self->begin()+index+count);
 697       }
 698 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 699         if (count < 0)
 700           throw std::out_of_range("count");
 701         return new std::vector< Dali::TouchPoint >(count, value);
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 704         std::reverse(self->begin(), self->end());
 705       }
 706 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 707         if (index < 0)
 708           throw std::out_of_range("index");
 709         if (count < 0)
 710           throw std::out_of_range("count");
 711         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 712           throw std::invalid_argument("invalid range");
 713         std::reverse(self->begin()+index, self->begin()+index+count);
 714       }
 715 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 716         if (index < 0)
 717           throw std::out_of_range("index");
 718         if (index+values.size() > self->size())
 719           throw std::out_of_range("index");
 720         std::copy(values.begin(), values.end(), self->begin()+index);
 721       }
 722 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 723          return self->Empty();
 724       }
 725 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 726         return self->GetConnectionCount();
 727       }
 728 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 729           self->Connect( func );
 730       }
 731 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 732           self->Disconnect( func );
 733       }
 734 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 735           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 736 /*@SWIG@*/ self->Emit( arg );
 737       }
 738 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 739          return self->Empty();
 740       }
 741 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 742         return self->GetConnectionCount();
 743       }
 744 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 745           self->Connect( func );
 746       }
 747 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 748           self->Disconnect( func );
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 751           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 752 /*@SWIG@*/ self->Emit( arg );
 753       }
 754 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 755          return self->Empty();
 756       }
 757 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){
 758         return self->GetConnectionCount();
 759       }
 760 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 *)){
 761           self->Connect( func );
 762       }
 763 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 *)){
 764           self->Disconnect( func );
 765       }
 766 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){
 767           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 768 /*@SWIG@*/ self->Emit( arg );
 769       }
 770 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 771          return self->Empty();
 772       }
 773 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 774         return self->GetConnectionCount();
 775       }
 776 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 777           self->Connect( func );
 778       }
 779 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 780           self->Disconnect( func );
 781       }
 782 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 783           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 784 /*@SWIG@*/ self->Emit( arg );
 785       }
 786 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 787          return self->Empty();
 788       }
 789 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 790         return self->GetConnectionCount();
 791       }
 792 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 793         self->Connect( func );
 794       }
 795 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 796         self->Disconnect( func );
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 799         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 800 /*@SWIG@*/ self->Emit( arg1, arg2 );
 801       }
 802 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 803          return self->Empty();
 804       }
 805 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){
 806         return self->GetConnectionCount();
 807       }
 808 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 &)){
 809           self->Connect( func );
 810       }
 811 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 &)){
 812           self->Disconnect( func );
 813       }
 814 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){
 815           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg );
 817       }
 818 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 819          return self->Empty();
 820       }
 821 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){
 822         return self->GetConnectionCount();
 823       }
 824 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 &)){
 825           self->Connect( func );
 826       }
 827 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 &)){
 828           self->Disconnect( func );
 829       }
 830 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){
 831           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 832 /*@SWIG@*/ self->Emit( arg );
 833       }
 834 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 835          return self->Empty();
 836       }
 837 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){
 838         return self->GetConnectionCount();
 839       }
 840 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 &)){
 841           self->Connect( func );
 842       }
 843 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 &)){
 844           self->Disconnect( func );
 845       }
 846 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){
 847           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 848 /*@SWIG@*/ self->Emit( arg );
 849       }
 850 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){
 851          return self->Empty();
 852       }
 853 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){
 854         return self->GetConnectionCount();
 855       }
 856 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 &)){
 857         self->Connect( func );
 858       }
 859 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 &)){
 860         self->Disconnect( func );
 861       }
 862 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){
 863         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 864 /*@SWIG@*/ self->Emit( arg1, arg2 );
 865       }
 866 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){
 867          return self->Empty();
 868       }
 869 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){
 870         return self->GetConnectionCount();
 871       }
 872 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 &)){
 873         self->Connect( func );
 874       }
 875 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 &)){
 876         self->Disconnect( func );
 877       }
 878 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){
 879         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 880 /*@SWIG@*/ self->Emit( arg1, arg2 );
 881       }
 882 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){
 883          return self->Empty();
 884       }
 885 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){
 886         return self->GetConnectionCount();
 887       }
 888 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 &)){
 889         self->Connect( func );
 890       }
 891 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 &)){
 892         self->Disconnect( func );
 893       }
 894 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){
 895         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 896 /*@SWIG@*/ self->Emit( arg1, arg2 );
 897       }
 898 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){
 899          return self->Empty();
 900       }
 901 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){
 902         return self->GetConnectionCount();
 903       }
 904 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)){
 905           return self->Connect( func );
 906       }
 907 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)){
 908           self->Disconnect( func );
 909       }
 910 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){
 911           self->Emit( arg1, arg3 );
 912       }
 913 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){
 914          return self->Empty();
 915       }
 916 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){
 917         return self->GetConnectionCount();
 918       }
 919 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)){
 920           return self->Connect( func );
 921       }
 922 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)){
 923           self->Disconnect( func );
 924       }
 925 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){
 926           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 927 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
 928       }
 929
 930 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
 931          return self->Empty();
 932       }
 933 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
 934         return self->GetConnectionCount();
 935       }
 936 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
 937           self->Connect( func );
 938       }
 939 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
 940           self->Disconnect( func );
 941       }
 942 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
 943           return self->Emit();
 944       }
 945
 946 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
 947         std::vector< unsigned int >* pv = 0;
 948         if (capacity >= 0) {
 949           pv = new std::vector< unsigned int >();
 950           pv->reserve(capacity);
 951        } else {
 952           throw std::out_of_range("capacity");
 953        }
 954        return pv;
 955       }
 956 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
 957         if (index>=0 && index<(int)self->size())
 958           return (*self)[index];
 959         else
 960           throw std::out_of_range("index");
 961       }
 962 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
 963         if (index>=0 && index<(int)self->size())
 964           return (*self)[index];
 965         else
 966           throw std::out_of_range("index");
 967       }
 968 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
 969         if (index>=0 && index<(int)self->size())
 970           (*self)[index] = val;
 971         else
 972           throw std::out_of_range("index");
 973       }
 974 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
 975         self->insert(self->end(), values.begin(), values.end());
 976       }
 977 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
 978         if (index < 0)
 979           throw std::out_of_range("index");
 980         if (count < 0)
 981           throw std::out_of_range("count");
 982         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 983           throw std::invalid_argument("invalid range");
 984         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
 985       }
 986 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
 987         if (index>=0 && index<(int)self->size()+1)
 988           self->insert(self->begin()+index, x);
 989         else
 990           throw std::out_of_range("index");
 991       }
 992 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
 993         if (index>=0 && index<(int)self->size()+1)
 994           self->insert(self->begin()+index, values.begin(), values.end());
 995         else
 996           throw std::out_of_range("index");
 997       }
 998 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
 999         if (index>=0 && index<(int)self->size())
1000           self->erase(self->begin() + index);
1001         else
1002           throw std::out_of_range("index");
1003       }
1004 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1005         if (index < 0)
1006           throw std::out_of_range("index");
1007         if (count < 0)
1008           throw std::out_of_range("count");
1009         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1010           throw std::invalid_argument("invalid range");
1011         self->erase(self->begin()+index, self->begin()+index+count);
1012       }
1013 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1014         if (count < 0)
1015           throw std::out_of_range("count");
1016         return new std::vector< unsigned int >(count, value);
1017       }
1018 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1019         std::reverse(self->begin(), self->end());
1020       }
1021 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1022         if (index < 0)
1023           throw std::out_of_range("index");
1024         if (count < 0)
1025           throw std::out_of_range("count");
1026         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1027           throw std::invalid_argument("invalid range");
1028         std::reverse(self->begin()+index, self->begin()+index+count);
1029       }
1030 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1031         if (index < 0)
1032           throw std::out_of_range("index");
1033         if (index+values.size() > self->size())
1034           throw std::out_of_range("index");
1035         std::copy(values.begin(), values.end(), self->begin()+index);
1036       }
1037 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1038         return std::find(self->begin(), self->end(), value) != self->end();
1039       }
1040 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1041         int index = -1;
1042         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1043         if (it != self->end())
1044           index = (int)(it - self->begin());
1045         return index;
1046       }
1047 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1048         int index = -1;
1049         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1050         if (rit != self->rend())
1051           index = (int)(self->rend() - 1 - rit);
1052         return index;
1053       }
1054 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1055         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1056         if (it != self->end()) {
1057           self->erase(it);
1058           return true;
1059         }
1060         return false;
1061       }
1062 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){
1063         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1064         if (capacity >= 0) {
1065           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1066           pv->reserve(capacity);
1067        } else {
1068           throw std::out_of_range("capacity");
1069        }
1070        return pv;
1071       }
1072 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){
1073         if (index>=0 && index<(int)self->size())
1074           return (*self)[index];
1075         else
1076           throw std::out_of_range("index");
1077       }
1078 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){
1079         if (index>=0 && index<(int)self->size())
1080           return (*self)[index];
1081         else
1082           throw std::out_of_range("index");
1083       }
1084 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){
1085         if (index>=0 && index<(int)self->size())
1086           (*self)[index] = val;
1087         else
1088           throw std::out_of_range("index");
1089       }
1090 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){
1091         self->insert(self->end(), values.begin(), values.end());
1092       }
1093 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){
1094         if (index < 0)
1095           throw std::out_of_range("index");
1096         if (count < 0)
1097           throw std::out_of_range("count");
1098         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1099           throw std::invalid_argument("invalid range");
1100         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1101       }
1102 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){
1103         if (index>=0 && index<(int)self->size()+1)
1104           self->insert(self->begin()+index, x);
1105         else
1106           throw std::out_of_range("index");
1107       }
1108 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){
1109         if (index>=0 && index<(int)self->size()+1)
1110           self->insert(self->begin()+index, values.begin(), values.end());
1111         else
1112           throw std::out_of_range("index");
1113       }
1114 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){
1115         if (index>=0 && index<(int)self->size())
1116           self->erase(self->begin() + index);
1117         else
1118           throw std::out_of_range("index");
1119       }
1120 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){
1121         if (index < 0)
1122           throw std::out_of_range("index");
1123         if (count < 0)
1124           throw std::out_of_range("count");
1125         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1126           throw std::invalid_argument("invalid range");
1127         self->erase(self->begin()+index, self->begin()+index+count);
1128       }
1129 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){
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1133       }
1134 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){
1135         std::reverse(self->begin(), self->end());
1136       }
1137 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){
1138         if (index < 0)
1139           throw std::out_of_range("index");
1140         if (count < 0)
1141           throw std::out_of_range("count");
1142         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1143           throw std::invalid_argument("invalid range");
1144         std::reverse(self->begin()+index, self->begin()+index+count);
1145       }
1146 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){
1147         if (index < 0)
1148           throw std::out_of_range("index");
1149         if (index+values.size() > self->size())
1150           throw std::out_of_range("index");
1151         std::copy(values.begin(), values.end(), self->begin()+index);
1152       }
1153 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1154         std::vector< Dali::Actor >* pv = 0;
1155         if (capacity >= 0) {
1156           pv = new std::vector< Dali::Actor >();
1157           pv->reserve(capacity);
1158        } else {
1159           throw std::out_of_range("capacity");
1160        }
1161        return pv;
1162       }
1163 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1164         if (index>=0 && index<(int)self->size())
1165           return (*self)[index];
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1170         if (index>=0 && index<(int)self->size())
1171           return (*self)[index];
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1176         if (index>=0 && index<(int)self->size())
1177           (*self)[index] = val;
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1182         self->insert(self->end(), values.begin(), values.end());
1183       }
1184 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1185         if (index < 0)
1186           throw std::out_of_range("index");
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1190           throw std::invalid_argument("invalid range");
1191         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1192       }
1193 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1194         if (index>=0 && index<(int)self->size()+1)
1195           self->insert(self->begin()+index, x);
1196         else
1197           throw std::out_of_range("index");
1198       }
1199 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1200         if (index>=0 && index<(int)self->size()+1)
1201           self->insert(self->begin()+index, values.begin(), values.end());
1202         else
1203           throw std::out_of_range("index");
1204       }
1205 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1206         if (index>=0 && index<(int)self->size())
1207           self->erase(self->begin() + index);
1208         else
1209           throw std::out_of_range("index");
1210       }
1211 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1212         if (index < 0)
1213           throw std::out_of_range("index");
1214         if (count < 0)
1215           throw std::out_of_range("count");
1216         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1217           throw std::invalid_argument("invalid range");
1218         self->erase(self->begin()+index, self->begin()+index+count);
1219       }
1220 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1221         if (count < 0)
1222           throw std::out_of_range("count");
1223         return new std::vector< Dali::Actor >(count, value);
1224       }
1225 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1226         std::reverse(self->begin(), self->end());
1227       }
1228 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1229         if (index < 0)
1230           throw std::out_of_range("index");
1231         if (count < 0)
1232           throw std::out_of_range("count");
1233         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1234           throw std::invalid_argument("invalid range");
1235         std::reverse(self->begin()+index, self->begin()+index+count);
1236       }
1237 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1238         if (index < 0)
1239           throw std::out_of_range("index");
1240         if (index+values.size() > self->size())
1241           throw std::out_of_range("index");
1242         std::copy(values.begin(), values.end(), self->begin()+index);
1243       }
1244 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1245          return self->Empty();
1246       }
1247 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1248         return self->GetConnectionCount();
1249       }
1250 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 &)){
1251           self->Connect( func );
1252       }
1253 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 &)){
1254           self->Disconnect( func );
1255       }
1256 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){
1257           return self->Emit( arg );
1258       }
1259 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){
1260          return self->Empty();
1261       }
1262 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){
1263         return self->GetConnectionCount();
1264       }
1265 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)){
1266         self->Connect( func );
1267       }
1268 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)){
1269         self->Disconnect( func );
1270       }
1271 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){
1272         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1273 /*@SWIG@*/ self->Emit( arg1, arg2 );
1274       }
1275 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1276          return self->Empty();
1277       }
1278 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){
1279         return self->GetConnectionCount();
1280       }
1281 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)){
1282         self->Connect( func );
1283       }
1284 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)){
1285         self->Disconnect( func );
1286       }
1287 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){
1288         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1289 /*@SWIG@*/ self->Emit( arg1, arg2 );
1290       }
1291 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1292          return self->Empty();
1293       }
1294 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1295         return self->GetConnectionCount();
1296       }
1297 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)){
1298         self->Connect( func );
1299       }
1300 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)){
1301         self->Disconnect( func );
1302       }
1303 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){
1304         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1305 /*@SWIG@*/ self->Emit( arg1, arg2 );
1306       }
1307 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){
1308          return self->Empty();
1309       }
1310 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){
1311         return self->GetConnectionCount();
1312       }
1313 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)){
1314         self->Connect( func );
1315       }
1316 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)){
1317         self->Disconnect( func );
1318       }
1319 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){
1320         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1321 /*@SWIG@*/ self->Emit( arg1, arg2 );
1322       }
1323 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1324          return self->Empty();
1325       }
1326 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1327         return self->GetConnectionCount();
1328       }
1329 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)){
1330           self->Connect( func );
1331       }
1332 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)){
1333           self->Disconnect( func );
1334       }
1335 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1336           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1337 /*@SWIG@*/ self->Emit( arg );
1338       }
1339 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){
1340          return self->Empty();
1341       }
1342 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){
1343         return self->GetConnectionCount();
1344       }
1345 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)){
1346           return self->Connect( func );
1347       }
1348 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)){
1349           self->Disconnect( func );
1350       }
1351 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){
1352           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1353 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1354       }
1355 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1356          return self->Empty();
1357       }
1358 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1359         return self->GetConnectionCount();
1360       }
1361 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)){
1362           self->Connect( func );
1363       }
1364 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)){
1365           self->Disconnect( func );
1366       }
1367 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1368           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1369 /*@SWIG@*/ self->Emit( arg );
1370       }
1371 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){
1372          return self->Empty();
1373       }
1374 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){
1375         return self->GetConnectionCount();
1376       }
1377 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 &)){
1378           self->Connect( func );
1379       }
1380 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 &)){
1381           self->Disconnect( func );
1382       }
1383 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){
1384           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1385 /*@SWIG@*/ self->Emit( arg );
1386       }
1387 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1388          return self->Empty();
1389       }
1390 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){
1391         return self->GetConnectionCount();
1392       }
1393 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 &)){
1394           self->Connect( func );
1395       }
1396 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 &)){
1397           self->Disconnect( func );
1398       }
1399 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){
1400           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1401 /*@SWIG@*/ self->Emit( arg );
1402       }
1403
1404
1405 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){
1406          return self->Empty();
1407       }
1408 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){
1409         return self->GetConnectionCount();
1410       }
1411 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 &)){
1412         self->Connect( func );
1413       }
1414 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 &)){
1415         self->Disconnect( func );
1416       }
1417 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){
1418         return self->Emit( arg1, arg2 );
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 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)){
1427           self->Connect( func );
1428       }
1429 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)){
1430           self->Disconnect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1433           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1434 /*@SWIG@*/ self->Emit( arg );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 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 &)){
1443           self->Connect( func );
1444       }
1445 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 &)){
1446           self->Disconnect( func );
1447       }
1448 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){
1449           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg );
1451       }
1452
1453 /* ---------------------------------------------------
1454  * C++ director class methods
1455  * --------------------------------------------------- */
1456
1457 #include "dali-wrap.h"
1458
1459 /*
1460  *  Widget director
1461  */
1462 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1463   swig_init_callbacks();
1464 }
1465
1466 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1467 }
1468
1469 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1470   char * jcontentInfo = 0 ;
1471   void * jwindow  ;
1472
1473   if (!swig_callbackOnCreate) {
1474     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1475     return;
1476   } else {
1477     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1478     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1479     swig_callbackOnCreate(jcontentInfo, jwindow);
1480   }
1481 }
1482
1483 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1484   char * jcontentInfo = 0 ;
1485   int jtype  ;
1486
1487   if (!swig_callbackOnTerminate) {
1488     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1489     return;
1490   } else {
1491     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1492     jtype = (int)type;
1493     swig_callbackOnTerminate(jcontentInfo, jtype);
1494   }
1495 }
1496
1497 void SwigDirector_WidgetImpl::OnPause() {
1498   if (!swig_callbackOnPause) {
1499     Dali::Internal::Adaptor::Widget::OnPause();
1500     return;
1501   } else {
1502     swig_callbackOnPause();
1503   }
1504 }
1505
1506 void SwigDirector_WidgetImpl::OnResume() {
1507   if (!swig_callbackOnResume) {
1508     Dali::Internal::Adaptor::Widget::OnResume();
1509     return;
1510   } else {
1511     swig_callbackOnResume();
1512   }
1513 }
1514
1515 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1516   void * jwindow  ;
1517
1518   if (!swig_callbackOnResize) {
1519     Dali::Internal::Adaptor::Widget::OnResize(window);
1520     return;
1521   } else {
1522     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1523     swig_callbackOnResize(jwindow);
1524   }
1525 }
1526
1527 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1528   char * jcontentInfo = 0 ;
1529   int jforce  ;
1530
1531   if (!swig_callbackOnUpdate) {
1532     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1533     return;
1534   } else {
1535     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1536     jforce = force;
1537     swig_callbackOnUpdate(jcontentInfo, jforce);
1538   }
1539 }
1540
1541 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1542   void * jslotObserver = 0 ;
1543   void * jcallback = 0 ;
1544
1545   if (!swig_callbackSignalConnected) {
1546     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1547     return;
1548   } else {
1549     jslotObserver = (void *) slotObserver;
1550     jcallback = (void *) callback;
1551     swig_callbackSignalConnected(jslotObserver, jcallback);
1552   }
1553 }
1554
1555 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1556   void * jslotObserver = 0 ;
1557   void * jcallback = 0 ;
1558
1559   if (!swig_callbackSignalDisconnected) {
1560     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1561     return;
1562   } else {
1563     jslotObserver = (void *) slotObserver;
1564     jcallback = (void *) callback;
1565     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1566   }
1567 }
1568
1569 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) {
1570
1571   swig_callbackOnCreate = callbackOnCreate;
1572   swig_callbackOnTerminate = callbackOnTerminate;
1573   swig_callbackOnPause = callbackOnPause;
1574   swig_callbackOnResume = callbackOnResume;
1575   swig_callbackOnResize = callbackOnResize;
1576   swig_callbackOnUpdate = callbackOnUpdate;
1577   swig_callbackSignalConnected = callbackSignalConnected;
1578   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1579 }
1580
1581 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1582   swig_callbackOnCreate = 0;
1583   swig_callbackOnTerminate = 0;
1584   swig_callbackOnPause = 0;
1585   swig_callbackOnResume = 0;
1586   swig_callbackOnResize = 0;
1587   swig_callbackOnUpdate = 0;
1588   swig_callbackSignalConnected = 0;
1589   swig_callbackSignalDisconnected = 0;
1590 }
1591
1592
1593 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1594   swig_init_callbacks();
1595 }
1596
1597 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1598
1599 }
1600
1601
1602 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1603   int jdepth  ;
1604
1605   if (!swig_callbackOnSceneConnection) {
1606     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1607     return;
1608   } else {
1609     jdepth = depth;
1610     swig_callbackOnSceneConnection(jdepth);
1611   }
1612 }
1613
1614 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1615   if (!swig_callbackOnSceneDisconnection) {
1616     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1617     return;
1618   } else {
1619     swig_callbackOnSceneDisconnection();
1620   }
1621 }
1622
1623 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1624   void * jchild = 0 ;
1625
1626   if (!swig_callbackOnChildAdd) {
1627     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1628     return;
1629   } else {
1630     jchild = (Dali::Actor *) &child;
1631     swig_callbackOnChildAdd(jchild);
1632   }
1633 }
1634
1635 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1636   void * jchild = 0 ;
1637
1638   if (!swig_callbackOnChildRemove) {
1639     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1640     return;
1641   } else {
1642     jchild = (Dali::Actor *) &child;
1643     swig_callbackOnChildRemove(jchild);
1644   }
1645 }
1646
1647 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1648   int jindex  ;
1649   void * jpropertyValue  ;
1650
1651   if (!swig_callbackOnPropertySet) {
1652     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1653     return;
1654   } else {
1655     jindex = index;
1656     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1657     swig_callbackOnPropertySet(jindex, jpropertyValue);
1658   }
1659 }
1660
1661 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1662   void * jtargetSize = 0 ;
1663
1664   if (!swig_callbackOnSizeSet) {
1665     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1666     return;
1667   } else {
1668     jtargetSize = (Dali::Vector3 *) &targetSize;
1669     swig_callbackOnSizeSet(jtargetSize);
1670   }
1671 }
1672
1673 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1674   void * janimation = 0 ;
1675   void * jtargetSize = 0 ;
1676
1677   if (!swig_callbackOnSizeAnimation) {
1678     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1679     return;
1680   } else {
1681     janimation = (Dali::Animation *) &animation;
1682     jtargetSize = (Dali::Vector3 *) &targetSize;
1683     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1684   }
1685 }
1686
1687 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1688   bool c_result = SwigValueInit< bool >() ;
1689   unsigned int jresult = 0 ;
1690   void * jarg0 = 0 ;
1691
1692   if (!swig_callbackOnKeyEvent) {
1693     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1694   } else {
1695     jarg0 = (Dali::KeyEvent *) &event;
1696     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1697     c_result = jresult ? true : false;
1698   }
1699   return c_result;
1700 }
1701
1702 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1703   void * jsize = 0 ;
1704   void * jcontainer = 0 ;
1705
1706   if (!swig_callbackOnRelayout) {
1707     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1708     return;
1709   } else {
1710     jsize = (Dali::Vector2 *) &size;
1711     jcontainer = (Dali::RelayoutContainer *) &container;
1712     swig_callbackOnRelayout(jsize, jcontainer);
1713   }
1714 }
1715
1716 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1717   int jpolicy  ;
1718   int jdimension  ;
1719
1720   if (!swig_callbackOnSetResizePolicy) {
1721     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1722     return;
1723   } else {
1724     jpolicy = (int)policy;
1725     jdimension = (int)dimension;
1726     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1727   }
1728 }
1729
1730 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1731   Dali::Vector3 c_result ;
1732   void * jresult = 0 ;
1733
1734   if (!swig_callbackGetNaturalSize) {
1735     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1736   } else {
1737     jresult = (void *) swig_callbackGetNaturalSize();
1738     if (!jresult) {
1739       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1740       return c_result;
1741     }
1742     c_result = *(Dali::Vector3 *)jresult;
1743   }
1744   return c_result;
1745 }
1746
1747 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1748   float c_result = SwigValueInit< float >() ;
1749   float jresult = 0 ;
1750   void * jchild = 0 ;
1751   int jdimension  ;
1752
1753   if (!swig_callbackCalculateChildSize) {
1754     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1755   } else {
1756     jchild = (Dali::Actor *) &child;
1757     jdimension = (int)dimension;
1758     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1759     c_result = (float)jresult;
1760   }
1761   return c_result;
1762 }
1763
1764 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1765   float c_result = SwigValueInit< float >() ;
1766   float jresult = 0 ;
1767   float jwidth  ;
1768
1769   if (!swig_callbackGetHeightForWidth) {
1770     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1771   } else {
1772     jwidth = width;
1773     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1774     c_result = (float)jresult;
1775   }
1776   return c_result;
1777 }
1778
1779 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1780   float c_result = SwigValueInit< float >() ;
1781   float jresult = 0 ;
1782   float jheight  ;
1783
1784   if (!swig_callbackGetWidthForHeight) {
1785     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1786   } else {
1787     jheight = height;
1788     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1789     c_result = (float)jresult;
1790   }
1791   return c_result;
1792 }
1793
1794 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1795   bool c_result = SwigValueInit< bool >() ;
1796   unsigned int jresult = 0 ;
1797   int jdimension  ;
1798
1799   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1800     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1801   } else {
1802     jdimension = (int)dimension;
1803     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1804     c_result = jresult ? true : false;
1805   }
1806   return c_result;
1807 }
1808
1809 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1810   int jdimension  ;
1811
1812   if (!swig_callbackOnCalculateRelayoutSize) {
1813     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1814     return;
1815   } else {
1816     jdimension = (int)dimension;
1817     swig_callbackOnCalculateRelayoutSize(jdimension);
1818   }
1819 }
1820
1821 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1822   float jsize  ;
1823   int jdimension  ;
1824
1825   if (!swig_callbackOnLayoutNegotiated) {
1826     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1827     return;
1828   } else {
1829     jsize = size;
1830     jdimension = (int)dimension;
1831     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1832   }
1833 }
1834
1835 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1836   return Dali::CustomActorImpl::GetExtension();
1837 }
1838
1839 void SwigDirector_ViewImpl::OnInitialize() {
1840   if (!swig_callbackOnInitialize) {
1841     Dali::Toolkit::Internal::Control::OnInitialize();
1842     return;
1843   } else {
1844     swig_callbackOnInitialize();
1845   }
1846 }
1847
1848 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1849   void * jstyleManager  ;
1850   int jchange  ;
1851
1852   if (!swig_callbackOnStyleChange) {
1853     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1854     return;
1855   } else {
1856     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1857     jchange = (int)change;
1858     swig_callbackOnStyleChange(jstyleManager, jchange);
1859   }
1860 }
1861
1862 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1863   bool c_result = SwigValueInit< bool >() ;
1864   unsigned int jresult = 0 ;
1865
1866   if (!swig_callbackOnAccessibilityActivated) {
1867     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1868   } else {
1869     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1870     c_result = jresult ? true : false;
1871   }
1872   return c_result;
1873 }
1874
1875 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1876   bool c_result = SwigValueInit< bool >() ;
1877   unsigned int jresult = 0 ;
1878   void * jgesture  ;
1879
1880   if (!swig_callbackOnAccessibilityPan) {
1881     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1882   } else {
1883     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1884     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1885     c_result = jresult ? true : false;
1886   }
1887   return c_result;
1888 }
1889
1890 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
1891   bool c_result = SwigValueInit< bool >() ;
1892   unsigned int jresult = 0 ;
1893   unsigned int jisIncrease  ;
1894
1895   if (!swig_callbackOnAccessibilityValueChange) {
1896     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
1897   } else {
1898     jisIncrease = isIncrease;
1899     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
1900     c_result = jresult ? true : false;
1901   }
1902   return c_result;
1903 }
1904
1905 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
1906   bool c_result = SwigValueInit< bool >() ;
1907   unsigned int jresult = 0 ;
1908
1909   if (!swig_callbackOnAccessibilityZoom) {
1910     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
1911   } else {
1912     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
1913     c_result = jresult ? true : false;
1914   }
1915   return c_result;
1916 }
1917
1918 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
1919   if (!swig_callbackOnKeyInputFocusGained) {
1920     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
1921     return;
1922   } else {
1923     swig_callbackOnKeyInputFocusGained();
1924   }
1925 }
1926
1927 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
1928   if (!swig_callbackOnKeyInputFocusLost) {
1929     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
1930     return;
1931   } else {
1932     swig_callbackOnKeyInputFocusLost();
1933   }
1934 }
1935
1936
1937 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
1938 {
1939   Dali::Actor c_result;
1940   void* jresult = 0;
1941
1942   if(!swig_callbackGetNextKeyboardFocusableActor)
1943   {
1944     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
1945   }
1946   else
1947   {
1948     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
1949
1950     if(!jresult)
1951     {
1952       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
1953       return c_result;
1954     }
1955     c_result = *(Dali::Actor*)jresult;
1956   }
1957   return c_result;
1958 }
1959
1960 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
1961 {
1962   if(!swig_callbackOnKeyboardFocusChangeCommitted)
1963   {
1964     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
1965     return;
1966   }
1967   else
1968   {
1969     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
1970   }
1971 }
1972
1973 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
1974   bool c_result = SwigValueInit< bool >() ;
1975   unsigned int jresult = 0 ;
1976
1977   if (!swig_callbackOnKeyboardEnter) {
1978     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
1979   } else {
1980     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
1981     c_result = jresult ? true : false;
1982   }
1983   return c_result;
1984 }
1985
1986 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
1987   void * jpinch = 0 ;
1988
1989   if (!swig_callbackOnPinch) {
1990     Dali::Toolkit::Internal::Control::OnPinch(pinch);
1991     return;
1992   } else {
1993     jpinch = (Dali::PinchGesture *) &pinch;
1994     swig_callbackOnPinch(jpinch);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
1999   void * jpan = 0 ;
2000
2001   if (!swig_callbackOnPan) {
2002     Dali::Toolkit::Internal::Control::OnPan(pan);
2003     return;
2004   } else {
2005     jpan = (Dali::PanGesture *) &pan;
2006     swig_callbackOnPan(jpan);
2007   }
2008 }
2009
2010 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2011   void * jtap = 0 ;
2012
2013   if (!swig_callbackOnTap) {
2014     Dali::Toolkit::Internal::Control::OnTap(tap);
2015     return;
2016   } else {
2017     jtap = (Dali::TapGesture *) &tap;
2018     swig_callbackOnTap(jtap);
2019   }
2020 }
2021
2022 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2023   void * jlongPress = 0 ;
2024
2025   if (!swig_callbackOnLongPress) {
2026     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2027     return;
2028   } else {
2029     jlongPress = (Dali::LongPressGesture *) &longPress;
2030     swig_callbackOnLongPress(jlongPress);
2031   }
2032 }
2033
2034 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2035   void * jslotObserver = 0 ;
2036   void * jcallback = 0 ;
2037
2038   if (!swig_callbackSignalConnected) {
2039     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2040     return;
2041   } else {
2042     jslotObserver = (void *) slotObserver;
2043     jcallback = (void *) callback;
2044     swig_callbackSignalConnected(jslotObserver, jcallback);
2045   }
2046 }
2047
2048 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2049   void * jslotObserver = 0 ;
2050   void * jcallback = 0 ;
2051
2052   if (!swig_callbackSignalDisconnected) {
2053     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2054     return;
2055   } else {
2056     jslotObserver = (void *) slotObserver;
2057     jcallback = (void *) callback;
2058     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2059   }
2060 }
2061
2062 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2063   return Dali::Toolkit::Internal::Control::GetControlExtension();
2064 }
2065
2066 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2067   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2068   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2069   swig_callbackOnChildAdd = callbackOnChildAdd;
2070   swig_callbackOnChildRemove = callbackOnChildRemove;
2071   swig_callbackOnPropertySet = callbackOnPropertySet;
2072   swig_callbackOnSizeSet = callbackOnSizeSet;
2073   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2074   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2075   swig_callbackOnRelayout = callbackOnRelayout;
2076   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2077   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2078   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2079   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2080   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2081   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2082   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2083   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2084   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2085   swig_callbackOnInitialize = callbackOnInitialize;
2086   swig_callbackOnStyleChange = callbackOnStyleChange;
2087   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2088   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2089   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2090   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2091   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2092   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2093   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2094   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2095   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2096   swig_callbackOnPinch = callbackOnPinch;
2097   swig_callbackOnPan = callbackOnPan;
2098   swig_callbackOnTap = callbackOnTap;
2099   swig_callbackOnLongPress = callbackOnLongPress;
2100   swig_callbackSignalConnected = callbackSignalConnected;
2101   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2102 }
2103
2104 void SwigDirector_ViewImpl::swig_init_callbacks() {
2105   swig_callbackOnSceneConnection = 0;
2106   swig_callbackOnSceneDisconnection = 0;
2107   swig_callbackOnChildAdd = 0;
2108   swig_callbackOnChildRemove = 0;
2109   swig_callbackOnPropertySet = 0;
2110   swig_callbackOnSizeSet = 0;
2111   swig_callbackOnSizeAnimation = 0;
2112   swig_callbackOnKeyEvent = 0;
2113   swig_callbackOnRelayout = 0;
2114   swig_callbackOnSetResizePolicy = 0;
2115   swig_callbackGetNaturalSize = 0;
2116   swig_callbackCalculateChildSize = 0;
2117   swig_callbackGetHeightForWidth = 0;
2118   swig_callbackGetWidthForHeight = 0;
2119   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2120   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2121   swig_callbackOnCalculateRelayoutSize = 0;
2122   swig_callbackOnLayoutNegotiated = 0;
2123   swig_callbackOnInitialize = 0;
2124   swig_callbackOnStyleChange = 0;
2125   swig_callbackOnAccessibilityActivated = 0;
2126   swig_callbackOnAccessibilityPan = 0;
2127   swig_callbackOnAccessibilityValueChange = 0;
2128   swig_callbackOnAccessibilityZoom = 0;
2129   swig_callbackOnKeyInputFocusGained = 0;
2130   swig_callbackOnKeyInputFocusLost = 0;
2131   swig_callbackGetNextKeyboardFocusableActor = 0;
2132   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2133   swig_callbackOnKeyboardEnter = 0;
2134   swig_callbackOnPinch = 0;
2135   swig_callbackOnPan = 0;
2136   swig_callbackOnTap = 0;
2137   swig_callbackOnLongPress = 0;
2138   swig_callbackSignalConnected = 0;
2139   swig_callbackSignalDisconnected = 0;
2140 }
2141
2142 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2143   swig_init_callbacks();
2144 }
2145
2146 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2147
2148 }
2149
2150
2151 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2152   unsigned int c_result = SwigValueInit< unsigned int >() ;
2153   unsigned int jresult = 0 ;
2154
2155   if (!swig_callbackGetNumberOfItems) {
2156     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2157   } else {
2158     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2159     c_result = (unsigned int)jresult;
2160   }
2161   return c_result;
2162 }
2163
2164 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2165   Dali::Actor c_result ;
2166   void * jresult = 0 ;
2167   unsigned int jitemId  ;
2168
2169   if (!swig_callbackNewItem) {
2170     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2171   } else {
2172     jitemId = itemId;
2173     jresult = (void *) swig_callbackNewItem(jitemId);
2174     if (!jresult) {
2175       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2176       return c_result;
2177     }
2178     c_result = *(Dali::Actor *)jresult;
2179   }
2180   return c_result;
2181 }
2182
2183 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
2184 {
2185   if(!swig_callbackItemReleased)
2186   {
2187     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
2188     return;
2189   }
2190   else
2191   {
2192     swig_callbackItemReleased(itemId, (void*)(&actor));
2193   }
2194 }
2195
2196 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2197   return Dali::Toolkit::ItemFactory::GetExtension();
2198 }
2199
2200 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2201   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2202   swig_callbackNewItem = callbackNewItem;
2203   swig_callbackItemReleased = callbackItemReleased;
2204 }
2205
2206 void SwigDirector_ItemFactory::swig_init_callbacks() {
2207   swig_callbackGetNumberOfItems = 0;
2208   swig_callbackNewItem = 0;
2209   swig_callbackItemReleased = 0;
2210 }
2211
2212 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2213   swig_init_callbacks();
2214 }
2215
2216 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2217
2218 }
2219
2220
2221 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
2222 {
2223   Dali::Actor c_result;
2224   void* jresult = 0;
2225
2226   if(!swig_callbackGetNextFocusableActor)
2227   {
2228     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2229   }
2230   else
2231   {
2232     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
2233     if(!jresult)
2234     {
2235       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__);
2236       return c_result;
2237     }
2238     c_result = *(Dali::Actor*)jresult;
2239   }
2240   return c_result;
2241 }
2242
2243 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2244   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2245 }
2246
2247 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2248   swig_callbackGetNextFocusableActor = 0;
2249 }
2250
2251 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2252   swig_callbackOnUpdate = 0;
2253 }
2254
2255 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2256
2257 }
2258
2259 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2260   swig_callbackOnUpdate = callbackUpdate;
2261 }
2262
2263
2264 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2265   void * jcurrent  ;
2266
2267   if (!swig_callbackOnUpdate) {
2268     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2269   } else {
2270     Dali::UpdateProxy* proxy = &updateProxy;
2271     jcurrent = (void *)proxy;
2272     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2273     if (!jcurrent) {
2274       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2275       return;
2276     }
2277   }
2278   return;
2279 }
2280
2281
2282 #ifdef __cplusplus
2283 extern "C" {
2284 #endif
2285
2286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2287   void * jresult ;
2288   floatp *result = 0 ;
2289
2290   {
2291     try {
2292       result = (floatp *)new_floatp();
2293     } CALL_CATCH_EXCEPTION(0);
2294   }
2295   jresult = (void *)result;
2296   return jresult;
2297 }
2298
2299
2300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2301   floatp *arg1 = (floatp *) 0 ;
2302
2303   arg1 = (floatp *)jarg1;
2304   {
2305     try {
2306       delete_floatp(arg1);
2307     } CALL_CATCH_EXCEPTION();
2308   }
2309
2310 }
2311
2312
2313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2314   floatp *arg1 = (floatp *) 0 ;
2315   float arg2 ;
2316
2317   arg1 = (floatp *)jarg1;
2318   arg2 = (float)jarg2;
2319   {
2320     try {
2321       floatp_assign(arg1,arg2);
2322     } CALL_CATCH_EXCEPTION();
2323   }
2324
2325 }
2326
2327
2328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2329   float jresult ;
2330   floatp *arg1 = (floatp *) 0 ;
2331   float result;
2332
2333   arg1 = (floatp *)jarg1;
2334   {
2335     try {
2336       result = (float)floatp_value(arg1);
2337     } CALL_CATCH_EXCEPTION(0);
2338   }
2339   jresult = result;
2340   return jresult;
2341 }
2342
2343
2344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2345   void * jresult ;
2346   floatp *arg1 = (floatp *) 0 ;
2347   float *result = 0 ;
2348
2349   arg1 = (floatp *)jarg1;
2350   {
2351     try {
2352       result = (float *)floatp_cast(arg1);
2353     } CALL_CATCH_EXCEPTION(0);
2354   }
2355
2356   jresult = (void *)result;
2357   return jresult;
2358 }
2359
2360
2361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2362   void * jresult ;
2363   float *arg1 = (float *) 0 ;
2364   floatp *result = 0 ;
2365
2366   arg1 = (float *)jarg1;
2367   {
2368     try {
2369       result = (floatp *)floatp_frompointer(arg1);
2370     } CALL_CATCH_EXCEPTION(0);
2371   }
2372
2373   jresult = (void *)result;
2374   return jresult;
2375 }
2376
2377
2378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2379   void * jresult ;
2380   intp *result = 0 ;
2381
2382   {
2383     try {
2384       result = (intp *)new_intp();
2385     } CALL_CATCH_EXCEPTION(0);
2386   }
2387
2388   jresult = (void *)result;
2389   return jresult;
2390 }
2391
2392
2393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2394   intp *arg1 = (intp *) 0 ;
2395
2396   arg1 = (intp *)jarg1;
2397   {
2398     try {
2399       delete_intp(arg1);
2400     } CALL_CATCH_EXCEPTION();
2401   }
2402
2403 }
2404
2405
2406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2407   intp *arg1 = (intp *) 0 ;
2408   int arg2 ;
2409
2410   arg1 = (intp *)jarg1;
2411   arg2 = (int)jarg2;
2412   {
2413     try {
2414       intp_assign(arg1,arg2);
2415     } CALL_CATCH_EXCEPTION();
2416   }
2417
2418 }
2419
2420
2421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2422   int jresult ;
2423   intp *arg1 = (intp *) 0 ;
2424   int result;
2425
2426   arg1 = (intp *)jarg1;
2427   {
2428     try {
2429       result = (int)intp_value(arg1);
2430     } CALL_CATCH_EXCEPTION(0);
2431   }
2432
2433   jresult = result;
2434   return jresult;
2435 }
2436
2437
2438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2439   void * jresult ;
2440   intp *arg1 = (intp *) 0 ;
2441   int *result = 0 ;
2442
2443   arg1 = (intp *)jarg1;
2444   {
2445     try {
2446       result = (int *)intp_cast(arg1);
2447     } CALL_CATCH_EXCEPTION(0);
2448   }
2449
2450   jresult = (void *)result;
2451   return jresult;
2452 }
2453
2454
2455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2456   void * jresult ;
2457   int *arg1 = (int *) 0 ;
2458   intp *result = 0 ;
2459
2460   arg1 = (int *)jarg1;
2461   {
2462     try {
2463       result = (intp *)intp_frompointer(arg1);
2464     } CALL_CATCH_EXCEPTION(0);
2465   }
2466
2467   jresult = (void *)result;
2468   return jresult;
2469 }
2470
2471
2472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2473   void * jresult ;
2474   doublep *result = 0 ;
2475
2476   {
2477     try {
2478       result = (doublep *)new_doublep();
2479     } CALL_CATCH_EXCEPTION(0);
2480   }
2481
2482   jresult = (void *)result;
2483   return jresult;
2484 }
2485
2486
2487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2488   doublep *arg1 = (doublep *) 0 ;
2489
2490   arg1 = (doublep *)jarg1;
2491   {
2492     try {
2493       delete_doublep(arg1);
2494     } CALL_CATCH_EXCEPTION();
2495   }
2496
2497 }
2498
2499
2500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2501   doublep *arg1 = (doublep *) 0 ;
2502   double arg2 ;
2503
2504   arg1 = (doublep *)jarg1;
2505   arg2 = (double)jarg2;
2506   {
2507     try {
2508       doublep_assign(arg1,arg2);
2509     } CALL_CATCH_EXCEPTION();
2510   }
2511
2512 }
2513
2514
2515 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2516   double jresult ;
2517   doublep *arg1 = (doublep *) 0 ;
2518   double result;
2519
2520   arg1 = (doublep *)jarg1;
2521   {
2522     try {
2523       result = (double)doublep_value(arg1);
2524     } CALL_CATCH_EXCEPTION(0);
2525   }
2526
2527   jresult = result;
2528   return jresult;
2529 }
2530
2531
2532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2533   void * jresult ;
2534   doublep *arg1 = (doublep *) 0 ;
2535   double *result = 0 ;
2536
2537   arg1 = (doublep *)jarg1;
2538   {
2539     try {
2540       result = (double *)doublep_cast(arg1);
2541     } CALL_CATCH_EXCEPTION(0);
2542   }
2543
2544   jresult = (void *)result;
2545   return jresult;
2546 }
2547
2548
2549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2550   void * jresult ;
2551   double *arg1 = (double *) 0 ;
2552   doublep *result = 0 ;
2553
2554   arg1 = (double *)jarg1;
2555   {
2556     try {
2557       result = (doublep *)doublep_frompointer(arg1);
2558     } CALL_CATCH_EXCEPTION(0);
2559   }
2560
2561   jresult = (void *)result;
2562   return jresult;
2563 }
2564
2565
2566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2567   void * jresult ;
2568   uintp *result = 0 ;
2569
2570   {
2571     try {
2572       result = (uintp *)new_uintp();
2573     } CALL_CATCH_EXCEPTION(0);
2574   }
2575
2576   jresult = (void *)result;
2577   return jresult;
2578 }
2579
2580
2581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2582   uintp *arg1 = (uintp *) 0 ;
2583
2584   arg1 = (uintp *)jarg1;
2585   {
2586     try {
2587       delete_uintp(arg1);
2588     } CALL_CATCH_EXCEPTION();
2589   }
2590
2591 }
2592
2593
2594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2595   uintp *arg1 = (uintp *) 0 ;
2596   unsigned int arg2 ;
2597
2598   arg1 = (uintp *)jarg1;
2599   arg2 = (unsigned int)jarg2;
2600   {
2601     try {
2602       uintp_assign(arg1,arg2);
2603     } CALL_CATCH_EXCEPTION();
2604   }
2605
2606 }
2607
2608
2609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2610   unsigned int jresult ;
2611   uintp *arg1 = (uintp *) 0 ;
2612   unsigned int result;
2613
2614   arg1 = (uintp *)jarg1;
2615   {
2616     try {
2617       result = (unsigned int)uintp_value(arg1);
2618     } CALL_CATCH_EXCEPTION(0);
2619   }
2620
2621   jresult = result;
2622   return jresult;
2623 }
2624
2625
2626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2627   void * jresult ;
2628   uintp *arg1 = (uintp *) 0 ;
2629   unsigned int *result = 0 ;
2630
2631   arg1 = (uintp *)jarg1;
2632   {
2633     try {
2634       result = (unsigned int *)uintp_cast(arg1);
2635     } CALL_CATCH_EXCEPTION(0);
2636   }
2637
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2644   void * jresult ;
2645   unsigned int *arg1 = (unsigned int *) 0 ;
2646   uintp *result = 0 ;
2647
2648   arg1 = (unsigned int *)jarg1;
2649   {
2650     try {
2651       result = (uintp *)uintp_frompointer(arg1);
2652     } CALL_CATCH_EXCEPTION(0);
2653   }
2654
2655   jresult = (void *)result;
2656   return jresult;
2657 }
2658
2659
2660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2661   void * jresult ;
2662   ushortp *result = 0 ;
2663
2664   {
2665     try {
2666       result = (ushortp *)new_ushortp();
2667     } CALL_CATCH_EXCEPTION(0);
2668   }
2669
2670   jresult = (void *)result;
2671   return jresult;
2672 }
2673
2674
2675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2676   ushortp *arg1 = (ushortp *) 0 ;
2677
2678   arg1 = (ushortp *)jarg1;
2679   {
2680     try {
2681       delete_ushortp(arg1);
2682     } CALL_CATCH_EXCEPTION();
2683   }
2684
2685 }
2686
2687
2688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2689   ushortp *arg1 = (ushortp *) 0 ;
2690   unsigned short arg2 ;
2691
2692   arg1 = (ushortp *)jarg1;
2693   arg2 = (unsigned short)jarg2;
2694   {
2695     try {
2696       ushortp_assign(arg1,arg2);
2697     } CALL_CATCH_EXCEPTION();
2698   }
2699
2700 }
2701
2702
2703 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2704   unsigned short jresult ;
2705   ushortp *arg1 = (ushortp *) 0 ;
2706   unsigned short result;
2707
2708   arg1 = (ushortp *)jarg1;
2709   {
2710     try {
2711       result = (unsigned short)ushortp_value(arg1);
2712     } CALL_CATCH_EXCEPTION(0);
2713   }
2714
2715   jresult = result;
2716   return jresult;
2717 }
2718
2719
2720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2721   void * jresult ;
2722   ushortp *arg1 = (ushortp *) 0 ;
2723   unsigned short *result = 0 ;
2724
2725   arg1 = (ushortp *)jarg1;
2726   {
2727     try {
2728       result = (unsigned short *)ushortp_cast(arg1);
2729     } CALL_CATCH_EXCEPTION(0);
2730   }
2731
2732   jresult = (void *)result;
2733   return jresult;
2734 }
2735
2736
2737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2738   void * jresult ;
2739   unsigned short *arg1 = (unsigned short *) 0 ;
2740   ushortp *result = 0 ;
2741
2742   arg1 = (unsigned short *)jarg1;
2743   {
2744     try {
2745       result = (ushortp *)ushortp_frompointer(arg1);
2746     } CALL_CATCH_EXCEPTION(0);
2747   }
2748
2749   jresult = (void *)result;
2750   return jresult;
2751 }
2752
2753
2754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2755   unsigned int jresult ;
2756   int arg1 ;
2757   unsigned int result;
2758
2759   arg1 = (int)jarg1;
2760   {
2761     try {
2762       result = (unsigned int)int_to_uint(arg1);
2763     } CALL_CATCH_EXCEPTION(0);
2764   }
2765
2766   jresult = result;
2767   return jresult;
2768 }
2769
2770
2771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2772   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2773
2774   arg1 = (Dali::RefObject *)jarg1;
2775   {
2776     try {
2777       (arg1)->Reference();
2778     } CALL_CATCH_EXCEPTION();
2779   }
2780
2781 }
2782
2783
2784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2785   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2786
2787   arg1 = (Dali::RefObject *)jarg1;
2788   {
2789     try {
2790       (arg1)->Unreference();
2791     } CALL_CATCH_EXCEPTION();
2792   }
2793
2794 }
2795
2796
2797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2798   int jresult ;
2799   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2800   int result;
2801
2802   arg1 = (Dali::RefObject *)jarg1;
2803   {
2804     try {
2805       result = (int)(arg1)->ReferenceCount();
2806     } CALL_CATCH_EXCEPTION(0);
2807   }
2808
2809   jresult = result;
2810   return jresult;
2811 }
2812
2813
2814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2815   void * jresult ;
2816   Dali::Any *result = 0 ;
2817
2818   {
2819     try {
2820       result = (Dali::Any *)new Dali::Any();
2821     } CALL_CATCH_EXCEPTION(0);
2822   }
2823
2824   jresult = (void *)result;
2825   return jresult;
2826 }
2827
2828
2829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2830   Dali::Any *arg1 = (Dali::Any *) 0 ;
2831
2832   arg1 = (Dali::Any *)jarg1;
2833   {
2834     try {
2835       delete arg1;
2836     } CALL_CATCH_EXCEPTION();
2837   }
2838
2839 }
2840
2841
2842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2843   char *arg1 = (char *) 0 ;
2844
2845   arg1 = (char *)jarg1;
2846   {
2847     try {
2848       Dali::Any::AssertAlways((char const *)arg1);
2849     } CALL_CATCH_EXCEPTION();
2850   }
2851
2852 }
2853
2854
2855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2856   void * jresult ;
2857   Dali::Any *arg1 = 0 ;
2858   Dali::Any *result = 0 ;
2859
2860   arg1 = (Dali::Any *)jarg1;
2861   if (!arg1) {
2862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2863     return 0;
2864   }
2865   {
2866     try {
2867       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2868     } CALL_CATCH_EXCEPTION(0);
2869   }
2870
2871   jresult = (void *)result;
2872   return jresult;
2873 }
2874
2875
2876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
2877   void * jresult ;
2878   Dali::Any *arg1 = (Dali::Any *) 0 ;
2879   Dali::Any *arg2 = 0 ;
2880   Dali::Any *result = 0 ;
2881
2882   arg1 = (Dali::Any *)jarg1;
2883   arg2 = (Dali::Any *)jarg2;
2884   if (!arg2) {
2885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2886     return 0;
2887   }
2888   {
2889     try {
2890       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
2891     } CALL_CATCH_EXCEPTION(0);
2892   }
2893
2894   jresult = (void *)result;
2895   return jresult;
2896 }
2897
2898
2899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
2900   void * jresult ;
2901   Dali::Any *arg1 = (Dali::Any *) 0 ;
2902   std::type_info *result = 0 ;
2903
2904   arg1 = (Dali::Any *)jarg1;
2905   {
2906     try {
2907       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
2908     } CALL_CATCH_EXCEPTION(0);
2909   }
2910
2911   jresult = (void *)result;
2912   return jresult;
2913 }
2914
2915
2916 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
2917   bool jresult ;
2918   Dali::Any *arg1 = (Dali::Any *) 0 ;
2919   bool result;
2920
2921   arg1 = (Dali::Any *)jarg1;
2922   {
2923     try {
2924       result = (bool)((Dali::Any const *)arg1)->Empty();
2925     } CALL_CATCH_EXCEPTION(0);
2926   }
2927
2928   jresult = result;
2929   return jresult;
2930 }
2931
2932
2933
2934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
2935   char *arg1 = (char *) 0 ;
2936   char *arg2 = (char *) 0 ;
2937
2938   arg1 = (char *)jarg1;
2939   arg2 = (char *)jarg2;
2940   {
2941     try {
2942       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
2943     } CALL_CATCH_EXCEPTION();
2944   }
2945
2946 }
2947
2948
2949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
2950   void * jresult ;
2951   char *arg1 = (char *) 0 ;
2952   char *arg2 = (char *) 0 ;
2953   Dali::DaliException *result = 0 ;
2954
2955   arg1 = (char *)jarg1;
2956   arg2 = (char *)jarg2;
2957   {
2958     try {
2959       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
2960     } CALL_CATCH_EXCEPTION(0);
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
2969   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2970   std::string arg2 = std::string(jarg2);
2971
2972   arg1 = (Dali::DaliException *)jarg1;
2973   {
2974     if (!arg2.empty()) {
2975       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
2976     } else {
2977       arg1->location = 0;
2978     }
2979   }
2980 }
2981
2982 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
2983   char * jresult ;
2984   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2985   char *result = 0 ;
2986
2987   arg1 = (Dali::DaliException *)jarg1;
2988   result = (char *) ((arg1)->location);
2989   jresult = SWIG_csharp_string_callback((const char *)result);
2990   return jresult;
2991 }
2992
2993
2994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
2995   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2996   std::string arg2 = std::string(jarg2);
2997
2998   arg1 = (Dali::DaliException *)jarg1;
2999   {
3000     if (!arg2.empty()) {
3001       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3002     } else {
3003       arg1->condition = 0;
3004     }
3005   }
3006 }
3007
3008
3009 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3010   char * jresult ;
3011   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3012   char *result = 0 ;
3013
3014   arg1 = (Dali::DaliException *)jarg1;
3015   result = (char *) ((arg1)->condition);
3016   jresult = SWIG_csharp_string_callback((const char *)result);
3017   return jresult;
3018 }
3019
3020
3021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3022   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3023
3024   arg1 = (Dali::DaliException *)jarg1;
3025   {
3026     try {
3027       delete arg1;
3028     } CALL_CATCH_EXCEPTION();
3029   }
3030
3031 }
3032
3033
3034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3035   void * jresult ;
3036   Dali::Vector2 *result = 0 ;
3037
3038   {
3039     try {
3040       result = (Dali::Vector2 *)new Dali::Vector2();
3041     } CALL_CATCH_EXCEPTION(0);
3042   }
3043
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3050   void * jresult ;
3051   float arg1 ;
3052   float arg2 ;
3053   Dali::Vector2 *result = 0 ;
3054
3055   arg1 = (float)jarg1;
3056   arg2 = (float)jarg2;
3057   {
3058     try {
3059       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3060     } CALL_CATCH_EXCEPTION(0);
3061   }
3062
3063   jresult = (void *)result;
3064   return jresult;
3065 }
3066
3067
3068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3069   void * jresult ;
3070   float *arg1 = (float *) 0 ;
3071   Dali::Vector2 *result = 0 ;
3072
3073   arg1 = jarg1;
3074   {
3075     try {
3076       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3077     } CALL_CATCH_EXCEPTION(0);
3078   }
3079
3080   jresult = (void *)result;
3081
3082
3083   return jresult;
3084 }
3085
3086
3087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3088   void * jresult ;
3089   Dali::Vector3 *arg1 = 0 ;
3090   Dali::Vector2 *result = 0 ;
3091
3092   arg1 = (Dali::Vector3 *)jarg1;
3093   if (!arg1) {
3094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3095     return 0;
3096   }
3097   {
3098     try {
3099       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3100     } CALL_CATCH_EXCEPTION(0);
3101   }
3102
3103   jresult = (void *)result;
3104   return jresult;
3105 }
3106
3107
3108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3109   void * jresult ;
3110   Dali::Vector4 *arg1 = 0 ;
3111   Dali::Vector2 *result = 0 ;
3112
3113   arg1 = (Dali::Vector4 *)jarg1;
3114   if (!arg1) {
3115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3116     return 0;
3117   }
3118   {
3119     try {
3120       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3121     } CALL_CATCH_EXCEPTION(0);
3122   }
3123
3124   jresult = (void *)result;
3125   return jresult;
3126 }
3127
3128
3129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3130   void * jresult ;
3131   Dali::Vector2 *result = 0 ;
3132
3133   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3134   jresult = (void *)result;
3135   return jresult;
3136 }
3137
3138
3139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3140   void * jresult ;
3141   Dali::Vector2 *result = 0 ;
3142
3143   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3144   jresult = (void *)result;
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3150   void * jresult ;
3151   Dali::Vector2 *result = 0 ;
3152
3153   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3154   jresult = (void *)result;
3155   return jresult;
3156 }
3157
3158
3159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3160   void * jresult ;
3161   Dali::Vector2 *result = 0 ;
3162
3163   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3164   jresult = (void *)result;
3165   return jresult;
3166 }
3167
3168
3169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3170   void * jresult ;
3171   Dali::Vector2 *result = 0 ;
3172
3173   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3174   jresult = (void *)result;
3175   return jresult;
3176 }
3177
3178
3179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3180   void * jresult ;
3181   Dali::Vector2 *result = 0 ;
3182
3183   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3190   void * jresult ;
3191   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3192   float *arg2 = (float *) 0 ;
3193   Dali::Vector2 *result = 0 ;
3194
3195   arg1 = (Dali::Vector2 *)jarg1;
3196   arg2 = jarg2;
3197   {
3198     try {
3199       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3200     } CALL_CATCH_EXCEPTION(0);
3201   }
3202
3203   jresult = (void *)result;
3204
3205
3206   return jresult;
3207 }
3208
3209
3210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3211   void * jresult ;
3212   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3213   Dali::Vector3 *arg2 = 0 ;
3214   Dali::Vector2 *result = 0 ;
3215
3216   arg1 = (Dali::Vector2 *)jarg1;
3217   arg2 = (Dali::Vector3 *)jarg2;
3218   if (!arg2) {
3219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3220     return 0;
3221   }
3222   {
3223     try {
3224       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3225     } CALL_CATCH_EXCEPTION(0);
3226   }
3227
3228   jresult = (void *)result;
3229   return jresult;
3230 }
3231
3232
3233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3234   void * jresult ;
3235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3236   Dali::Vector4 *arg2 = 0 ;
3237   Dali::Vector2 *result = 0 ;
3238
3239   arg1 = (Dali::Vector2 *)jarg1;
3240   arg2 = (Dali::Vector4 *)jarg2;
3241   if (!arg2) {
3242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3243     return 0;
3244   }
3245   {
3246     try {
3247       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3248     } CALL_CATCH_EXCEPTION(0);
3249   }
3250
3251   jresult = (void *)result;
3252   return jresult;
3253 }
3254
3255
3256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3257   void * jresult ;
3258   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3259   Dali::Vector2 *arg2 = 0 ;
3260   Dali::Vector2 result;
3261
3262   arg1 = (Dali::Vector2 *)jarg1;
3263   arg2 = (Dali::Vector2 *)jarg2;
3264   if (!arg2) {
3265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3266     return 0;
3267   }
3268   {
3269     try {
3270       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3271     } CALL_CATCH_EXCEPTION(0);
3272   }
3273
3274   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3275   return jresult;
3276 }
3277
3278
3279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3280   void * jresult ;
3281   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3282   Dali::Vector2 *arg2 = 0 ;
3283   Dali::Vector2 *result = 0 ;
3284
3285   arg1 = (Dali::Vector2 *)jarg1;
3286   arg2 = (Dali::Vector2 *)jarg2;
3287   if (!arg2) {
3288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3289     return 0;
3290   }
3291   {
3292     try {
3293       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3294     } CALL_CATCH_EXCEPTION(0);
3295   }
3296
3297   jresult = (void *)result;
3298   return jresult;
3299 }
3300
3301
3302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3303   void * jresult ;
3304   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3305   Dali::Vector2 *arg2 = 0 ;
3306   Dali::Vector2 result;
3307
3308   arg1 = (Dali::Vector2 *)jarg1;
3309   arg2 = (Dali::Vector2 *)jarg2;
3310   if (!arg2) {
3311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3312     return 0;
3313   }
3314   {
3315     try {
3316       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3317     } CALL_CATCH_EXCEPTION(0);
3318   }
3319
3320   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3321   return jresult;
3322 }
3323
3324
3325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3326   void * jresult ;
3327   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3328   Dali::Vector2 *arg2 = 0 ;
3329   Dali::Vector2 *result = 0 ;
3330
3331   arg1 = (Dali::Vector2 *)jarg1;
3332   arg2 = (Dali::Vector2 *)jarg2;
3333   if (!arg2) {
3334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3335     return 0;
3336   }
3337   {
3338     try {
3339       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3340     } CALL_CATCH_EXCEPTION(0);
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3349   void * jresult ;
3350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3351   Dali::Vector2 *arg2 = 0 ;
3352   Dali::Vector2 result;
3353
3354   arg1 = (Dali::Vector2 *)jarg1;
3355   arg2 = (Dali::Vector2 *)jarg2;
3356   if (!arg2) {
3357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3358     return 0;
3359   }
3360   {
3361     try {
3362       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3363     } CALL_CATCH_EXCEPTION(0);
3364   }
3365
3366   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3367   return jresult;
3368 }
3369
3370
3371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3372   void * jresult ;
3373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3374   float arg2 ;
3375   Dali::Vector2 result;
3376
3377   arg1 = (Dali::Vector2 *)jarg1;
3378   arg2 = (float)jarg2;
3379   {
3380     try {
3381       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3382     } CALL_CATCH_EXCEPTION(0);
3383   }
3384
3385   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3386   return jresult;
3387 }
3388
3389
3390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3391   void * jresult ;
3392   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3393   Dali::Vector2 *arg2 = 0 ;
3394   Dali::Vector2 *result = 0 ;
3395
3396   arg1 = (Dali::Vector2 *)jarg1;
3397   arg2 = (Dali::Vector2 *)jarg2;
3398   if (!arg2) {
3399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3400     return 0;
3401   }
3402   {
3403     try {
3404       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3405     } CALL_CATCH_EXCEPTION(0);
3406   }
3407
3408   jresult = (void *)result;
3409   return jresult;
3410 }
3411
3412
3413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3414   void * jresult ;
3415   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3416   float arg2 ;
3417   Dali::Vector2 *result = 0 ;
3418
3419   arg1 = (Dali::Vector2 *)jarg1;
3420   arg2 = (float)jarg2;
3421   {
3422     try {
3423       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3424     } CALL_CATCH_EXCEPTION(0);
3425   }
3426
3427   jresult = (void *)result;
3428   return jresult;
3429 }
3430
3431
3432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3433   void * jresult ;
3434   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3435   Dali::Vector2 *arg2 = 0 ;
3436   Dali::Vector2 result;
3437
3438   arg1 = (Dali::Vector2 *)jarg1;
3439   arg2 = (Dali::Vector2 *)jarg2;
3440   if (!arg2) {
3441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3442     return 0;
3443   }
3444   {
3445     try {
3446       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3447     } CALL_CATCH_EXCEPTION(0);
3448   }
3449
3450   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3451   return jresult;
3452 }
3453
3454
3455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3456   void * jresult ;
3457   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3458   float arg2 ;
3459   Dali::Vector2 result;
3460
3461   arg1 = (Dali::Vector2 *)jarg1;
3462   arg2 = (float)jarg2;
3463   {
3464     try {
3465       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3466     } CALL_CATCH_EXCEPTION(0);
3467   }
3468
3469   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3475   void * jresult ;
3476   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3477   Dali::Vector2 *arg2 = 0 ;
3478   Dali::Vector2 *result = 0 ;
3479
3480   arg1 = (Dali::Vector2 *)jarg1;
3481   arg2 = (Dali::Vector2 *)jarg2;
3482   if (!arg2) {
3483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3484     return 0;
3485   }
3486   {
3487     try {
3488       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3489     } CALL_CATCH_EXCEPTION(0);
3490   }
3491
3492   jresult = (void *)result;
3493   return jresult;
3494 }
3495
3496
3497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3498   void * jresult ;
3499   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3500   float arg2 ;
3501   Dali::Vector2 *result = 0 ;
3502
3503   arg1 = (Dali::Vector2 *)jarg1;
3504   arg2 = (float)jarg2;
3505   {
3506     try {
3507       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3508     } CALL_CATCH_EXCEPTION(0);
3509   }
3510
3511   jresult = (void *)result;
3512   return jresult;
3513 }
3514
3515
3516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3517   void * jresult ;
3518   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3519   Dali::Vector2 result;
3520
3521   arg1 = (Dali::Vector2 *)jarg1;
3522   {
3523     try {
3524       result = ((Dali::Vector2 const *)arg1)->operator -();
3525     } CALL_CATCH_EXCEPTION(0);
3526   }
3527
3528   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3529   return jresult;
3530 }
3531
3532
3533 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3534   bool jresult ;
3535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3536   Dali::Vector2 *arg2 = 0 ;
3537   bool result;
3538
3539   arg1 = (Dali::Vector2 *)jarg1;
3540   arg2 = (Dali::Vector2 *)jarg2;
3541   if (!arg2) {
3542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3543     return 0;
3544   }
3545   {
3546     try {
3547       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3548     } CALL_CATCH_EXCEPTION(0);
3549   }
3550
3551   jresult = result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3557   bool jresult ;
3558   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3559   Dali::Vector2 *arg2 = 0 ;
3560   bool result;
3561
3562   arg1 = (Dali::Vector2 *)jarg1;
3563   arg2 = (Dali::Vector2 *)jarg2;
3564   if (!arg2) {
3565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3566     return 0;
3567   }
3568   {
3569     try {
3570       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3571     } CALL_CATCH_EXCEPTION(0);
3572   }
3573
3574   jresult = result;
3575   return jresult;
3576 }
3577
3578
3579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3580   float jresult ;
3581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3582   unsigned int arg2 ;
3583   float *result = 0 ;
3584
3585   arg1 = (Dali::Vector2 *)jarg1;
3586   arg2 = (unsigned int)jarg2;
3587   {
3588     try {
3589       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3590     } CALL_CATCH_EXCEPTION(0);
3591   }
3592
3593   jresult = *result;
3594   return jresult;
3595 }
3596
3597
3598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3599   float jresult ;
3600   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3601   float result;
3602
3603   arg1 = (Dali::Vector2 *)jarg1;
3604   {
3605     try {
3606       result = (float)((Dali::Vector2 const *)arg1)->Length();
3607     } CALL_CATCH_EXCEPTION(0);
3608   }
3609
3610   jresult = result;
3611   return jresult;
3612 }
3613
3614
3615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3616   float jresult ;
3617   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3618   float result;
3619
3620   arg1 = (Dali::Vector2 *)jarg1;
3621   {
3622     try {
3623       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3624     } CALL_CATCH_EXCEPTION(0);
3625   }
3626
3627   jresult = result;
3628   return jresult;
3629 }
3630
3631
3632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3633   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3634
3635   arg1 = (Dali::Vector2 *)jarg1;
3636   {
3637     try {
3638       (arg1)->Normalize();
3639     } CALL_CATCH_EXCEPTION();
3640   }
3641
3642 }
3643
3644
3645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3646   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3647   Dali::Vector2 *arg2 = 0 ;
3648   Dali::Vector2 *arg3 = 0 ;
3649
3650   arg1 = (Dali::Vector2 *)jarg1;
3651   arg2 = (Dali::Vector2 *)jarg2;
3652   if (!arg2) {
3653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3654     return ;
3655   }
3656   arg3 = (Dali::Vector2 *)jarg3;
3657   if (!arg3) {
3658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3659     return ;
3660   }
3661   {
3662     try {
3663       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3664     } CALL_CATCH_EXCEPTION();
3665   }
3666
3667 }
3668
3669
3670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3671   void * jresult ;
3672   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3673   float *result = 0 ;
3674
3675   arg1 = (Dali::Vector2 *)jarg1;
3676   {
3677     try {
3678       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3679     } CALL_CATCH_EXCEPTION(0);
3680   }
3681
3682   jresult = (void *)result;
3683   return jresult;
3684 }
3685
3686
3687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
3688   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3689   float arg2 ;
3690
3691   arg1 = (Dali::Vector2 *)jarg1;
3692   arg2 = (float)jarg2;
3693   if (arg1) (arg1)->x = arg2;
3694 }
3695
3696
3697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
3698   float jresult ;
3699   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3700   float result;
3701
3702   arg1 = (Dali::Vector2 *)jarg1;
3703   result = (float) ((arg1)->x);
3704   jresult = result;
3705   return jresult;
3706 }
3707
3708
3709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
3710   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3711   float arg2 ;
3712
3713   arg1 = (Dali::Vector2 *)jarg1;
3714   arg2 = (float)jarg2;
3715   if (arg1) (arg1)->width = arg2;
3716 }
3717
3718
3719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
3720   float jresult ;
3721   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3722   float result;
3723
3724   arg1 = (Dali::Vector2 *)jarg1;
3725   result = (float) ((arg1)->width);
3726   jresult = result;
3727   return jresult;
3728 }
3729
3730
3731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
3732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3733   float arg2 ;
3734
3735   arg1 = (Dali::Vector2 *)jarg1;
3736   arg2 = (float)jarg2;
3737   if (arg1) (arg1)->y = arg2;
3738 }
3739
3740
3741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
3742   float jresult ;
3743   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3744   float result;
3745
3746   arg1 = (Dali::Vector2 *)jarg1;
3747   result = (float) ((arg1)->y);
3748   jresult = result;
3749   return jresult;
3750 }
3751
3752
3753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
3754   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3755   float arg2 ;
3756
3757   arg1 = (Dali::Vector2 *)jarg1;
3758   arg2 = (float)jarg2;
3759   if (arg1) (arg1)->height = arg2;
3760 }
3761
3762
3763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
3764   float jresult ;
3765   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3766   float result;
3767
3768   arg1 = (Dali::Vector2 *)jarg1;
3769   result = (float) ((arg1)->height);
3770   jresult = result;
3771   return jresult;
3772 }
3773
3774
3775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
3776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3777
3778   arg1 = (Dali::Vector2 *)jarg1;
3779   {
3780     try {
3781       delete arg1;
3782     } CALL_CATCH_EXCEPTION();
3783   }
3784
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
3789   void * jresult ;
3790   Dali::Vector2 *arg1 = 0 ;
3791   Dali::Vector2 *arg2 = 0 ;
3792   Dali::Vector2 result;
3793
3794   arg1 = (Dali::Vector2 *)jarg1;
3795   if (!arg1) {
3796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3797     return 0;
3798   }
3799   arg2 = (Dali::Vector2 *)jarg2;
3800   if (!arg2) {
3801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3802     return 0;
3803   }
3804   {
3805     try {
3806       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3807     } CALL_CATCH_EXCEPTION(0);
3808   }
3809
3810   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3811   return jresult;
3812 }
3813
3814
3815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
3816   void * jresult ;
3817   Dali::Vector2 *arg1 = 0 ;
3818   Dali::Vector2 *arg2 = 0 ;
3819   Dali::Vector2 result;
3820
3821   arg1 = (Dali::Vector2 *)jarg1;
3822   if (!arg1) {
3823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3824     return 0;
3825   }
3826   arg2 = (Dali::Vector2 *)jarg2;
3827   if (!arg2) {
3828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3829     return 0;
3830   }
3831   {
3832     try {
3833       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
3834     } CALL_CATCH_EXCEPTION(0);
3835   }
3836
3837   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3838   return jresult;
3839 }
3840
3841
3842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
3843   void * jresult ;
3844   Dali::Vector2 *arg1 = 0 ;
3845   float *arg2 = 0 ;
3846   float *arg3 = 0 ;
3847   float temp2 ;
3848   float temp3 ;
3849   Dali::Vector2 result;
3850
3851   arg1 = (Dali::Vector2 *)jarg1;
3852   if (!arg1) {
3853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3854     return 0;
3855   }
3856   temp2 = (float)jarg2;
3857   arg2 = &temp2;
3858   temp3 = (float)jarg3;
3859   arg3 = &temp3;
3860   {
3861     try {
3862       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
3863     } CALL_CATCH_EXCEPTION(0);
3864   }
3865
3866   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
3872   void * jresult ;
3873   Dali::Vector3 *result = 0 ;
3874
3875   {
3876     try {
3877       result = (Dali::Vector3 *)new Dali::Vector3();
3878     } CALL_CATCH_EXCEPTION(0);
3879   }
3880
3881   jresult = (void *)result;
3882   return jresult;
3883 }
3884
3885
3886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
3887   void * jresult ;
3888   float arg1 ;
3889   float arg2 ;
3890   float arg3 ;
3891   Dali::Vector3 *result = 0 ;
3892
3893   arg1 = (float)jarg1;
3894   arg2 = (float)jarg2;
3895   arg3 = (float)jarg3;
3896   {
3897     try {
3898       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
3899     } CALL_CATCH_EXCEPTION(0);
3900   }
3901
3902   jresult = (void *)result;
3903   return jresult;
3904 }
3905
3906
3907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
3908   void * jresult ;
3909   float *arg1 = (float *) 0 ;
3910   Dali::Vector3 *result = 0 ;
3911
3912   arg1 = jarg1;
3913   {
3914     try {
3915       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
3916     } CALL_CATCH_EXCEPTION(0);
3917   }
3918
3919   jresult = (void *)result;
3920
3921
3922   return jresult;
3923 }
3924
3925
3926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
3927   void * jresult ;
3928   Dali::Vector2 *arg1 = 0 ;
3929   Dali::Vector3 *result = 0 ;
3930
3931   arg1 = (Dali::Vector2 *)jarg1;
3932   if (!arg1) {
3933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3934     return 0;
3935   }
3936   {
3937     try {
3938       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
3939     } CALL_CATCH_EXCEPTION(0);
3940   }
3941
3942   jresult = (void *)result;
3943   return jresult;
3944 }
3945
3946
3947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
3948   void * jresult ;
3949   Dali::Vector4 *arg1 = 0 ;
3950   Dali::Vector3 *result = 0 ;
3951
3952   arg1 = (Dali::Vector4 *)jarg1;
3953   if (!arg1) {
3954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3955     return 0;
3956   }
3957   {
3958     try {
3959       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
3960     } CALL_CATCH_EXCEPTION(0);
3961   }
3962
3963   jresult = (void *)result;
3964   return jresult;
3965 }
3966
3967
3968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
3969   void * jresult ;
3970   Dali::Vector3 *result = 0 ;
3971
3972   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
3979   void * jresult ;
3980   Dali::Vector3 *result = 0 ;
3981
3982   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
3983   jresult = (void *)result;
3984   return jresult;
3985 }
3986
3987
3988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
3989   void * jresult ;
3990   Dali::Vector3 *result = 0 ;
3991
3992   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
3993   jresult = (void *)result;
3994   return jresult;
3995 }
3996
3997
3998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
3999   void * jresult ;
4000   Dali::Vector3 *result = 0 ;
4001
4002   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4003   jresult = (void *)result;
4004   return jresult;
4005 }
4006
4007
4008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4009   void * jresult ;
4010   Dali::Vector3 *result = 0 ;
4011
4012   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4013   jresult = (void *)result;
4014   return jresult;
4015 }
4016
4017
4018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4019   void * jresult ;
4020   Dali::Vector3 *result = 0 ;
4021
4022   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4023   jresult = (void *)result;
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4029   void * jresult ;
4030   Dali::Vector3 *result = 0 ;
4031
4032   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4033   jresult = (void *)result;
4034   return jresult;
4035 }
4036
4037
4038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4039   void * jresult ;
4040   Dali::Vector3 *result = 0 ;
4041
4042   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4043   jresult = (void *)result;
4044   return jresult;
4045 }
4046
4047
4048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4049   void * jresult ;
4050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4051   float *arg2 = (float *) 0 ;
4052   Dali::Vector3 *result = 0 ;
4053
4054   arg1 = (Dali::Vector3 *)jarg1;
4055   arg2 = jarg2;
4056   {
4057     try {
4058       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4059     } CALL_CATCH_EXCEPTION(0);
4060   }
4061
4062   jresult = (void *)result;
4063
4064
4065   return jresult;
4066 }
4067
4068
4069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4070   void * jresult ;
4071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4072   Dali::Vector2 *arg2 = 0 ;
4073   Dali::Vector3 *result = 0 ;
4074
4075   arg1 = (Dali::Vector3 *)jarg1;
4076   arg2 = (Dali::Vector2 *)jarg2;
4077   if (!arg2) {
4078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4079     return 0;
4080   }
4081   {
4082     try {
4083       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4084     } CALL_CATCH_EXCEPTION(0);
4085   }
4086
4087   jresult = (void *)result;
4088   return jresult;
4089 }
4090
4091
4092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4093   void * jresult ;
4094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4095   Dali::Vector4 *arg2 = 0 ;
4096   Dali::Vector3 *result = 0 ;
4097
4098   arg1 = (Dali::Vector3 *)jarg1;
4099   arg2 = (Dali::Vector4 *)jarg2;
4100   if (!arg2) {
4101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4102     return 0;
4103   }
4104   {
4105     try {
4106       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4107     } CALL_CATCH_EXCEPTION(0);
4108   }
4109
4110   jresult = (void *)result;
4111   return jresult;
4112 }
4113
4114
4115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4116   void * jresult ;
4117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4118   Dali::Vector3 *arg2 = 0 ;
4119   Dali::Vector3 result;
4120
4121   arg1 = (Dali::Vector3 *)jarg1;
4122   arg2 = (Dali::Vector3 *)jarg2;
4123   if (!arg2) {
4124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4125     return 0;
4126   }
4127   {
4128     try {
4129       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4130     } CALL_CATCH_EXCEPTION(0);
4131   }
4132
4133   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4134   return jresult;
4135 }
4136
4137
4138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4139   void * jresult ;
4140   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4141   Dali::Vector3 *arg2 = 0 ;
4142   Dali::Vector3 *result = 0 ;
4143
4144   arg1 = (Dali::Vector3 *)jarg1;
4145   arg2 = (Dali::Vector3 *)jarg2;
4146   if (!arg2) {
4147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4148     return 0;
4149   }
4150   {
4151     try {
4152       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4153     } CALL_CATCH_EXCEPTION(0);
4154   }
4155
4156   jresult = (void *)result;
4157   return jresult;
4158 }
4159
4160
4161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4162   void * jresult ;
4163   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4164   Dali::Vector3 *arg2 = 0 ;
4165   Dali::Vector3 result;
4166
4167   arg1 = (Dali::Vector3 *)jarg1;
4168   arg2 = (Dali::Vector3 *)jarg2;
4169   if (!arg2) {
4170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4171     return 0;
4172   }
4173   {
4174     try {
4175       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4176     } CALL_CATCH_EXCEPTION(0);
4177   }
4178
4179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4180   return jresult;
4181 }
4182
4183
4184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4185   void * jresult ;
4186   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4187   Dali::Vector3 *arg2 = 0 ;
4188   Dali::Vector3 *result = 0 ;
4189
4190   arg1 = (Dali::Vector3 *)jarg1;
4191   arg2 = (Dali::Vector3 *)jarg2;
4192   if (!arg2) {
4193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4194     return 0;
4195   }
4196   {
4197     try {
4198       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4199     } CALL_CATCH_EXCEPTION(0);
4200   }
4201
4202   jresult = (void *)result;
4203   return jresult;
4204 }
4205
4206
4207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4208   void * jresult ;
4209   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4210   Dali::Vector3 *arg2 = 0 ;
4211   Dali::Vector3 result;
4212
4213   arg1 = (Dali::Vector3 *)jarg1;
4214   arg2 = (Dali::Vector3 *)jarg2;
4215   if (!arg2) {
4216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4217     return 0;
4218   }
4219   {
4220     try {
4221       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4222     } CALL_CATCH_EXCEPTION(0);
4223   }
4224
4225   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4226   return jresult;
4227 }
4228
4229
4230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4231   void * jresult ;
4232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4233   float arg2 ;
4234   Dali::Vector3 result;
4235
4236   arg1 = (Dali::Vector3 *)jarg1;
4237   arg2 = (float)jarg2;
4238   {
4239     try {
4240       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4241     } CALL_CATCH_EXCEPTION(0);
4242   }
4243
4244   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4245   return jresult;
4246 }
4247
4248
4249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4250   void * jresult ;
4251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4252   Dali::Vector3 *arg2 = 0 ;
4253   Dali::Vector3 *result = 0 ;
4254
4255   arg1 = (Dali::Vector3 *)jarg1;
4256   arg2 = (Dali::Vector3 *)jarg2;
4257   if (!arg2) {
4258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4259     return 0;
4260   }
4261   {
4262     try {
4263       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4264     } CALL_CATCH_EXCEPTION(0);
4265   }
4266
4267   jresult = (void *)result;
4268   return jresult;
4269 }
4270
4271
4272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4273   void * jresult ;
4274   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4275   float arg2 ;
4276   Dali::Vector3 *result = 0 ;
4277
4278   arg1 = (Dali::Vector3 *)jarg1;
4279   arg2 = (float)jarg2;
4280   {
4281     try {
4282       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4283     } CALL_CATCH_EXCEPTION(0);
4284   }
4285
4286   jresult = (void *)result;
4287   return jresult;
4288 }
4289
4290
4291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4292   void * jresult ;
4293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4294   Dali::Quaternion *arg2 = 0 ;
4295   Dali::Vector3 *result = 0 ;
4296
4297   arg1 = (Dali::Vector3 *)jarg1;
4298   arg2 = (Dali::Quaternion *)jarg2;
4299   if (!arg2) {
4300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4301     return 0;
4302   }
4303   {
4304     try {
4305       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4306     } CALL_CATCH_EXCEPTION(0);
4307   }
4308
4309   jresult = (void *)result;
4310   return jresult;
4311 }
4312
4313
4314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4315   void * jresult ;
4316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4317   Dali::Vector3 *arg2 = 0 ;
4318   Dali::Vector3 result;
4319
4320   arg1 = (Dali::Vector3 *)jarg1;
4321   arg2 = (Dali::Vector3 *)jarg2;
4322   if (!arg2) {
4323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4324     return 0;
4325   }
4326   {
4327     try {
4328       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4329     } CALL_CATCH_EXCEPTION(0);
4330   }
4331
4332   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4333   return jresult;
4334 }
4335
4336
4337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4338   void * jresult ;
4339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4340   float arg2 ;
4341   Dali::Vector3 result;
4342
4343   arg1 = (Dali::Vector3 *)jarg1;
4344   arg2 = (float)jarg2;
4345   {
4346     try {
4347       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4348     } CALL_CATCH_EXCEPTION(0);
4349   }
4350
4351   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4352   return jresult;
4353 }
4354
4355
4356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4357   void * jresult ;
4358   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4359   Dali::Vector3 *arg2 = 0 ;
4360   Dali::Vector3 *result = 0 ;
4361
4362   arg1 = (Dali::Vector3 *)jarg1;
4363   arg2 = (Dali::Vector3 *)jarg2;
4364   if (!arg2) {
4365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4366     return 0;
4367   }
4368   {
4369     try {
4370       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4371     } CALL_CATCH_EXCEPTION(0);
4372   }
4373
4374   jresult = (void *)result;
4375   return jresult;
4376 }
4377
4378
4379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4380   void * jresult ;
4381   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4382   float arg2 ;
4383   Dali::Vector3 *result = 0 ;
4384
4385   arg1 = (Dali::Vector3 *)jarg1;
4386   arg2 = (float)jarg2;
4387   {
4388     try {
4389       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4390     } CALL_CATCH_EXCEPTION(0);
4391   }
4392
4393   jresult = (void *)result;
4394   return jresult;
4395 }
4396
4397
4398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4399   void * jresult ;
4400   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4401   Dali::Vector3 result;
4402
4403   arg1 = (Dali::Vector3 *)jarg1;
4404   {
4405     try {
4406       result = ((Dali::Vector3 const *)arg1)->operator -();
4407     } CALL_CATCH_EXCEPTION(0);
4408   }
4409
4410   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4416   bool jresult ;
4417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4418   Dali::Vector3 *arg2 = 0 ;
4419   bool result;
4420
4421   arg1 = (Dali::Vector3 *)jarg1;
4422   arg2 = (Dali::Vector3 *)jarg2;
4423   if (!arg2) {
4424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4425     return 0;
4426   }
4427   {
4428     try {
4429       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4430     } CALL_CATCH_EXCEPTION(0);
4431   }
4432
4433   jresult = result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4439   bool jresult ;
4440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4441   Dali::Vector3 *arg2 = 0 ;
4442   bool result;
4443
4444   arg1 = (Dali::Vector3 *)jarg1;
4445   arg2 = (Dali::Vector3 *)jarg2;
4446   if (!arg2) {
4447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4448     return 0;
4449   }
4450   {
4451     try {
4452       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4453     } CALL_CATCH_EXCEPTION(0);
4454   }
4455
4456   jresult = result;
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4462   float jresult ;
4463   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4464   unsigned int arg2 ;
4465   float *result = 0 ;
4466
4467   arg1 = (Dali::Vector3 *)jarg1;
4468   arg2 = (unsigned int)jarg2;
4469   {
4470     try {
4471       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4472     } CALL_CATCH_EXCEPTION(0);
4473   }
4474
4475   jresult = *result;
4476   return jresult;
4477 }
4478
4479
4480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4481   float jresult ;
4482   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4483   Dali::Vector3 *arg2 = 0 ;
4484   float result;
4485
4486   arg1 = (Dali::Vector3 *)jarg1;
4487   arg2 = (Dali::Vector3 *)jarg2;
4488   if (!arg2) {
4489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4490     return 0;
4491   }
4492   {
4493     try {
4494       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4495     } CALL_CATCH_EXCEPTION(0);
4496   }
4497
4498   jresult = result;
4499   return jresult;
4500 }
4501
4502
4503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4504   void * jresult ;
4505   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4506   Dali::Vector3 *arg2 = 0 ;
4507   Dali::Vector3 result;
4508
4509   arg1 = (Dali::Vector3 *)jarg1;
4510   arg2 = (Dali::Vector3 *)jarg2;
4511   if (!arg2) {
4512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4513     return 0;
4514   }
4515   {
4516     try {
4517       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4518     } CALL_CATCH_EXCEPTION(0);
4519   }
4520
4521   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4522   return jresult;
4523 }
4524
4525
4526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4527   float jresult ;
4528   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4529   float result;
4530
4531   arg1 = (Dali::Vector3 *)jarg1;
4532   {
4533     try {
4534       result = (float)((Dali::Vector3 const *)arg1)->Length();
4535     } CALL_CATCH_EXCEPTION(0);
4536   }
4537
4538   jresult = result;
4539   return jresult;
4540 }
4541
4542
4543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4544   float jresult ;
4545   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4546   float result;
4547
4548   arg1 = (Dali::Vector3 *)jarg1;
4549   {
4550     try {
4551       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4552     } CALL_CATCH_EXCEPTION(0);
4553   }
4554
4555   jresult = result;
4556   return jresult;
4557 }
4558
4559
4560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4561   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4562
4563   arg1 = (Dali::Vector3 *)jarg1;
4564   {
4565     try {
4566       (arg1)->Normalize();
4567     } CALL_CATCH_EXCEPTION();
4568   }
4569
4570 }
4571
4572
4573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4574   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4575   Dali::Vector3 *arg2 = 0 ;
4576   Dali::Vector3 *arg3 = 0 ;
4577
4578   arg1 = (Dali::Vector3 *)jarg1;
4579   arg2 = (Dali::Vector3 *)jarg2;
4580   if (!arg2) {
4581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4582     return ;
4583   }
4584   arg3 = (Dali::Vector3 *)jarg3;
4585   if (!arg3) {
4586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4587     return ;
4588   }
4589   {
4590     try {
4591       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4592     } CALL_CATCH_EXCEPTION();
4593   }
4594
4595 }
4596
4597
4598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4599   void * jresult ;
4600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4601   float *result = 0 ;
4602
4603   arg1 = (Dali::Vector3 *)jarg1;
4604   {
4605     try {
4606       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4607     } CALL_CATCH_EXCEPTION(0);
4608   }
4609
4610   jresult = (void *)result;
4611   return jresult;
4612 }
4613
4614
4615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4616   void * jresult ;
4617   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4618   Dali::Vector2 *result = 0 ;
4619
4620   arg1 = (Dali::Vector3 *)jarg1;
4621   {
4622     try {
4623       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4624     } CALL_CATCH_EXCEPTION(0);
4625   }
4626
4627   jresult = (void *)result;
4628   return jresult;
4629 }
4630
4631
4632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4633   void * jresult ;
4634   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4635   Dali::Vector2 *result = 0 ;
4636
4637   arg1 = (Dali::Vector3 *)jarg1;
4638   {
4639     try {
4640       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4641     } CALL_CATCH_EXCEPTION(0);
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4650   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4651   float arg2 ;
4652
4653   arg1 = (Dali::Vector3 *)jarg1;
4654   arg2 = (float)jarg2;
4655   if (arg1) (arg1)->x = arg2;
4656 }
4657
4658
4659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
4660   float jresult ;
4661   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4662   float result;
4663
4664   arg1 = (Dali::Vector3 *)jarg1;
4665   result = (float) ((arg1)->x);
4666   jresult = result;
4667   return jresult;
4668 }
4669
4670
4671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
4672   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4673   float arg2 ;
4674
4675   arg1 = (Dali::Vector3 *)jarg1;
4676   arg2 = (float)jarg2;
4677   if (arg1) (arg1)->width = arg2;
4678 }
4679
4680
4681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
4682   float jresult ;
4683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4684   float result;
4685
4686   arg1 = (Dali::Vector3 *)jarg1;
4687   result = (float) ((arg1)->width);
4688   jresult = result;
4689   return jresult;
4690 }
4691
4692
4693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
4694   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4695   float arg2 ;
4696
4697   arg1 = (Dali::Vector3 *)jarg1;
4698   arg2 = (float)jarg2;
4699   if (arg1) (arg1)->r = arg2;
4700 }
4701
4702
4703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
4704   float jresult ;
4705   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4706   float result;
4707
4708   arg1 = (Dali::Vector3 *)jarg1;
4709   result = (float) ((arg1)->r);
4710   jresult = result;
4711   return jresult;
4712 }
4713
4714
4715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
4716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4717   float arg2 ;
4718
4719   arg1 = (Dali::Vector3 *)jarg1;
4720   arg2 = (float)jarg2;
4721   if (arg1) (arg1)->y = arg2;
4722 }
4723
4724
4725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
4726   float jresult ;
4727   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4728   float result;
4729
4730   arg1 = (Dali::Vector3 *)jarg1;
4731   result = (float) ((arg1)->y);
4732   jresult = result;
4733   return jresult;
4734 }
4735
4736
4737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
4738   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4739   float arg2 ;
4740
4741   arg1 = (Dali::Vector3 *)jarg1;
4742   arg2 = (float)jarg2;
4743   if (arg1) (arg1)->height = arg2;
4744 }
4745
4746
4747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
4748   float jresult ;
4749   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4750   float result;
4751
4752   arg1 = (Dali::Vector3 *)jarg1;
4753   result = (float) ((arg1)->height);
4754   jresult = result;
4755   return jresult;
4756 }
4757
4758
4759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
4760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4761   float arg2 ;
4762
4763   arg1 = (Dali::Vector3 *)jarg1;
4764   arg2 = (float)jarg2;
4765   if (arg1) (arg1)->g = arg2;
4766 }
4767
4768
4769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
4770   float jresult ;
4771   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4772   float result;
4773
4774   arg1 = (Dali::Vector3 *)jarg1;
4775   result = (float) ((arg1)->g);
4776   jresult = result;
4777   return jresult;
4778 }
4779
4780
4781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
4782   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4783   float arg2 ;
4784
4785   arg1 = (Dali::Vector3 *)jarg1;
4786   arg2 = (float)jarg2;
4787   if (arg1) (arg1)->z = arg2;
4788 }
4789
4790
4791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
4792   float jresult ;
4793   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4794   float result;
4795
4796   arg1 = (Dali::Vector3 *)jarg1;
4797   result = (float) ((arg1)->z);
4798   jresult = result;
4799   return jresult;
4800 }
4801
4802
4803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
4804   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4805   float arg2 ;
4806
4807   arg1 = (Dali::Vector3 *)jarg1;
4808   arg2 = (float)jarg2;
4809   if (arg1) (arg1)->depth = arg2;
4810 }
4811
4812
4813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
4814   float jresult ;
4815   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4816   float result;
4817
4818   arg1 = (Dali::Vector3 *)jarg1;
4819   result = (float) ((arg1)->depth);
4820   jresult = result;
4821   return jresult;
4822 }
4823
4824
4825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
4826   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4827   float arg2 ;
4828
4829   arg1 = (Dali::Vector3 *)jarg1;
4830   arg2 = (float)jarg2;
4831   if (arg1) (arg1)->b = arg2;
4832 }
4833
4834
4835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
4836   float jresult ;
4837   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4838   float result;
4839
4840   arg1 = (Dali::Vector3 *)jarg1;
4841   result = (float) ((arg1)->b);
4842   jresult = result;
4843   return jresult;
4844 }
4845
4846
4847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
4848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4849
4850   arg1 = (Dali::Vector3 *)jarg1;
4851   {
4852     try {
4853       delete arg1;
4854     } CALL_CATCH_EXCEPTION();
4855   }
4856
4857 }
4858
4859
4860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
4861   void * jresult ;
4862   Dali::Vector3 *arg1 = 0 ;
4863   Dali::Vector3 *arg2 = 0 ;
4864   Dali::Vector3 result;
4865
4866   arg1 = (Dali::Vector3 *)jarg1;
4867   if (!arg1) {
4868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4869     return 0;
4870   }
4871   arg2 = (Dali::Vector3 *)jarg2;
4872   if (!arg2) {
4873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4874     return 0;
4875   }
4876   {
4877     try {
4878       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
4879     } CALL_CATCH_EXCEPTION(0);
4880   }
4881
4882   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4883   return jresult;
4884 }
4885
4886
4887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
4888   void * jresult ;
4889   Dali::Vector3 *arg1 = 0 ;
4890   Dali::Vector3 *arg2 = 0 ;
4891   Dali::Vector3 result;
4892
4893   arg1 = (Dali::Vector3 *)jarg1;
4894   if (!arg1) {
4895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4896     return 0;
4897   }
4898   arg2 = (Dali::Vector3 *)jarg2;
4899   if (!arg2) {
4900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4901     return 0;
4902   }
4903   {
4904     try {
4905       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
4906     } CALL_CATCH_EXCEPTION(0);
4907   }
4908
4909   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4910   return jresult;
4911 }
4912
4913
4914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
4915   void * jresult ;
4916   Dali::Vector3 *arg1 = 0 ;
4917   float *arg2 = 0 ;
4918   float *arg3 = 0 ;
4919   float temp2 ;
4920   float temp3 ;
4921   Dali::Vector3 result;
4922
4923   arg1 = (Dali::Vector3 *)jarg1;
4924   if (!arg1) {
4925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4926     return 0;
4927   }
4928   temp2 = (float)jarg2;
4929   arg2 = &temp2;
4930   temp3 = (float)jarg3;
4931   arg3 = &temp3;
4932   {
4933     try {
4934       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4935     } CALL_CATCH_EXCEPTION(0);
4936   }
4937
4938   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4939   return jresult;
4940 }
4941
4942
4943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
4944   void * jresult ;
4945   Dali::Vector4 *result = 0 ;
4946
4947   {
4948     try {
4949       result = (Dali::Vector4 *)new Dali::Vector4();
4950     } CALL_CATCH_EXCEPTION(0);
4951   }
4952
4953   jresult = (void *)result;
4954   return jresult;
4955 }
4956
4957
4958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
4959   void * jresult ;
4960   float arg1 ;
4961   float arg2 ;
4962   float arg3 ;
4963   float arg4 ;
4964   Dali::Vector4 *result = 0 ;
4965
4966   arg1 = (float)jarg1;
4967   arg2 = (float)jarg2;
4968   arg3 = (float)jarg3;
4969   arg4 = (float)jarg4;
4970   {
4971     try {
4972       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
4973     } CALL_CATCH_EXCEPTION(0);
4974   }
4975
4976   jresult = (void *)result;
4977   return jresult;
4978 }
4979
4980
4981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
4982   void * jresult ;
4983   float *arg1 = (float *) 0 ;
4984   Dali::Vector4 *result = 0 ;
4985
4986   arg1 = jarg1;
4987   {
4988     try {
4989       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
4990     } CALL_CATCH_EXCEPTION(0);
4991   }
4992
4993   jresult = (void *)result;
4994
4995
4996   return jresult;
4997 }
4998
4999
5000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5001   void * jresult ;
5002   Dali::Vector2 *arg1 = 0 ;
5003   Dali::Vector4 *result = 0 ;
5004
5005   arg1 = (Dali::Vector2 *)jarg1;
5006   if (!arg1) {
5007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5008     return 0;
5009   }
5010   {
5011     try {
5012       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5013     } CALL_CATCH_EXCEPTION(0);
5014   }
5015
5016   jresult = (void *)result;
5017   return jresult;
5018 }
5019
5020
5021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5022   void * jresult ;
5023   Dali::Vector3 *arg1 = 0 ;
5024   Dali::Vector4 *result = 0 ;
5025
5026   arg1 = (Dali::Vector3 *)jarg1;
5027   if (!arg1) {
5028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5029     return 0;
5030   }
5031   {
5032     try {
5033       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5034     } CALL_CATCH_EXCEPTION(0);
5035   }
5036
5037   jresult = (void *)result;
5038   return jresult;
5039 }
5040
5041
5042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5043   void * jresult ;
5044   Dali::Vector4 *result = 0 ;
5045
5046   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5047   jresult = (void *)result;
5048   return jresult;
5049 }
5050
5051
5052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5053   void * jresult ;
5054   Dali::Vector4 *result = 0 ;
5055
5056   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5057   jresult = (void *)result;
5058   return jresult;
5059 }
5060
5061
5062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5063   void * jresult ;
5064   Dali::Vector4 *result = 0 ;
5065
5066   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5067   jresult = (void *)result;
5068   return jresult;
5069 }
5070
5071
5072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5073   void * jresult ;
5074   Dali::Vector4 *result = 0 ;
5075
5076   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5077   jresult = (void *)result;
5078   return jresult;
5079 }
5080
5081
5082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5083   void * jresult ;
5084   Dali::Vector4 *result = 0 ;
5085
5086   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5087   jresult = (void *)result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5093   void * jresult ;
5094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5095   float *arg2 = (float *) 0 ;
5096   Dali::Vector4 *result = 0 ;
5097
5098   arg1 = (Dali::Vector4 *)jarg1;
5099   arg2 = jarg2;
5100   {
5101     try {
5102       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5103     } CALL_CATCH_EXCEPTION(0);
5104   }
5105
5106   jresult = (void *)result;
5107
5108
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5114   void * jresult ;
5115   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5116   Dali::Vector2 *arg2 = 0 ;
5117   Dali::Vector4 *result = 0 ;
5118
5119   arg1 = (Dali::Vector4 *)jarg1;
5120   arg2 = (Dali::Vector2 *)jarg2;
5121   if (!arg2) {
5122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5123     return 0;
5124   }
5125   {
5126     try {
5127       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5128     } CALL_CATCH_EXCEPTION(0);
5129   }
5130
5131   jresult = (void *)result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5137   void * jresult ;
5138   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5139   Dali::Vector3 *arg2 = 0 ;
5140   Dali::Vector4 *result = 0 ;
5141
5142   arg1 = (Dali::Vector4 *)jarg1;
5143   arg2 = (Dali::Vector3 *)jarg2;
5144   if (!arg2) {
5145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5146     return 0;
5147   }
5148   {
5149     try {
5150       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5151     } CALL_CATCH_EXCEPTION(0);
5152   }
5153
5154   jresult = (void *)result;
5155   return jresult;
5156 }
5157
5158
5159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5160   void * jresult ;
5161   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5162   Dali::Vector4 *arg2 = 0 ;
5163   Dali::Vector4 result;
5164
5165   arg1 = (Dali::Vector4 *)jarg1;
5166   arg2 = (Dali::Vector4 *)jarg2;
5167   if (!arg2) {
5168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5169     return 0;
5170   }
5171   {
5172     try {
5173       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5174     } CALL_CATCH_EXCEPTION(0);
5175   }
5176
5177   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5178   return jresult;
5179 }
5180
5181
5182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5183   void * jresult ;
5184   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5185   Dali::Vector4 *arg2 = 0 ;
5186   Dali::Vector4 *result = 0 ;
5187
5188   arg1 = (Dali::Vector4 *)jarg1;
5189   arg2 = (Dali::Vector4 *)jarg2;
5190   if (!arg2) {
5191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5192     return 0;
5193   }
5194   {
5195     try {
5196       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5197     } CALL_CATCH_EXCEPTION(0);
5198   }
5199
5200   jresult = (void *)result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5206   void * jresult ;
5207   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5208   Dali::Vector4 *arg2 = 0 ;
5209   Dali::Vector4 result;
5210
5211   arg1 = (Dali::Vector4 *)jarg1;
5212   arg2 = (Dali::Vector4 *)jarg2;
5213   if (!arg2) {
5214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5215     return 0;
5216   }
5217   {
5218     try {
5219       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5220     } CALL_CATCH_EXCEPTION(0);
5221   }
5222
5223   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5224   return jresult;
5225 }
5226
5227
5228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5229   void * jresult ;
5230   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5231   Dali::Vector4 *arg2 = 0 ;
5232   Dali::Vector4 *result = 0 ;
5233
5234   arg1 = (Dali::Vector4 *)jarg1;
5235   arg2 = (Dali::Vector4 *)jarg2;
5236   if (!arg2) {
5237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5238     return 0;
5239   }
5240   {
5241     try {
5242       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5243     } CALL_CATCH_EXCEPTION(0);
5244   }
5245
5246   jresult = (void *)result;
5247   return jresult;
5248 }
5249
5250
5251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5252   void * jresult ;
5253   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5254   Dali::Vector4 *arg2 = 0 ;
5255   Dali::Vector4 result;
5256
5257   arg1 = (Dali::Vector4 *)jarg1;
5258   arg2 = (Dali::Vector4 *)jarg2;
5259   if (!arg2) {
5260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5261     return 0;
5262   }
5263   {
5264     try {
5265       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5266     } CALL_CATCH_EXCEPTION(0);
5267   }
5268
5269   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5270   return jresult;
5271 }
5272
5273
5274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5275   void * jresult ;
5276   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5277   float arg2 ;
5278   Dali::Vector4 result;
5279
5280   arg1 = (Dali::Vector4 *)jarg1;
5281   arg2 = (float)jarg2;
5282   {
5283     try {
5284       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5285     } CALL_CATCH_EXCEPTION(0);
5286   }
5287
5288   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5289   return jresult;
5290 }
5291
5292
5293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5294   void * jresult ;
5295   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5296   Dali::Vector4 *arg2 = 0 ;
5297   Dali::Vector4 *result = 0 ;
5298
5299   arg1 = (Dali::Vector4 *)jarg1;
5300   arg2 = (Dali::Vector4 *)jarg2;
5301   if (!arg2) {
5302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5303     return 0;
5304   }
5305   {
5306     try {
5307       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5308     } CALL_CATCH_EXCEPTION(0);
5309   }
5310
5311   jresult = (void *)result;
5312   return jresult;
5313 }
5314
5315
5316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5317   void * jresult ;
5318   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5319   float arg2 ;
5320   Dali::Vector4 *result = 0 ;
5321
5322   arg1 = (Dali::Vector4 *)jarg1;
5323   arg2 = (float)jarg2;
5324   {
5325     try {
5326       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5327     } CALL_CATCH_EXCEPTION(0);
5328   }
5329
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5336   void * jresult ;
5337   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5338   Dali::Vector4 *arg2 = 0 ;
5339   Dali::Vector4 result;
5340
5341   arg1 = (Dali::Vector4 *)jarg1;
5342   arg2 = (Dali::Vector4 *)jarg2;
5343   if (!arg2) {
5344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5345     return 0;
5346   }
5347   {
5348     try {
5349       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5350     } CALL_CATCH_EXCEPTION(0);
5351   }
5352
5353   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5359   void * jresult ;
5360   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5361   float arg2 ;
5362   Dali::Vector4 result;
5363
5364   arg1 = (Dali::Vector4 *)jarg1;
5365   arg2 = (float)jarg2;
5366   {
5367     try {
5368       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5369     } CALL_CATCH_EXCEPTION(0);
5370   }
5371
5372   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5373   return jresult;
5374 }
5375
5376
5377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5378   void * jresult ;
5379   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5380   Dali::Vector4 *arg2 = 0 ;
5381   Dali::Vector4 *result = 0 ;
5382
5383   arg1 = (Dali::Vector4 *)jarg1;
5384   arg2 = (Dali::Vector4 *)jarg2;
5385   if (!arg2) {
5386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5387     return 0;
5388   }
5389   {
5390     try {
5391       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5392     } CALL_CATCH_EXCEPTION(0);
5393   }
5394
5395   jresult = (void *)result;
5396   return jresult;
5397 }
5398
5399
5400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5401   void * jresult ;
5402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5403   float arg2 ;
5404   Dali::Vector4 *result = 0 ;
5405
5406   arg1 = (Dali::Vector4 *)jarg1;
5407   arg2 = (float)jarg2;
5408   {
5409     try {
5410       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5411     } CALL_CATCH_EXCEPTION(0);
5412   }
5413
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5420   void * jresult ;
5421   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5422   Dali::Vector4 result;
5423
5424   arg1 = (Dali::Vector4 *)jarg1;
5425   {
5426     try {
5427       result = ((Dali::Vector4 const *)arg1)->operator -();
5428     } CALL_CATCH_EXCEPTION(0);
5429   }
5430
5431   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5432   return jresult;
5433 }
5434
5435
5436 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5437   bool jresult ;
5438   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5439   Dali::Vector4 *arg2 = 0 ;
5440   bool result;
5441
5442   arg1 = (Dali::Vector4 *)jarg1;
5443   arg2 = (Dali::Vector4 *)jarg2;
5444   if (!arg2) {
5445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5446     return 0;
5447   }
5448   {
5449     try {
5450       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5451     } CALL_CATCH_EXCEPTION(0);
5452   }
5453
5454   jresult = result;
5455   return jresult;
5456 }
5457
5458
5459 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5460   bool jresult ;
5461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5462   Dali::Vector4 *arg2 = 0 ;
5463   bool result;
5464
5465   arg1 = (Dali::Vector4 *)jarg1;
5466   arg2 = (Dali::Vector4 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5474     } CALL_CATCH_EXCEPTION(0);
5475   }
5476
5477   jresult = result;
5478   return jresult;
5479 }
5480
5481
5482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5483   float jresult ;
5484   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5485   unsigned int arg2 ;
5486   float *result = 0 ;
5487
5488   arg1 = (Dali::Vector4 *)jarg1;
5489   arg2 = (unsigned int)jarg2;
5490   {
5491     try {
5492       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5493     } CALL_CATCH_EXCEPTION(0);
5494   }
5495
5496   jresult = *result;
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5502   float jresult ;
5503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5504   Dali::Vector3 *arg2 = 0 ;
5505   float result;
5506
5507   arg1 = (Dali::Vector4 *)jarg1;
5508   arg2 = (Dali::Vector3 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5516     } CALL_CATCH_EXCEPTION(0);
5517   }
5518
5519   jresult = result;
5520   return jresult;
5521 }
5522
5523
5524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5525   float jresult ;
5526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5527   Dali::Vector4 *arg2 = 0 ;
5528   float result;
5529
5530   arg1 = (Dali::Vector4 *)jarg1;
5531   arg2 = (Dali::Vector4 *)jarg2;
5532   if (!arg2) {
5533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5534     return 0;
5535   }
5536   {
5537     try {
5538       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5539     } CALL_CATCH_EXCEPTION(0);
5540   }
5541
5542   jresult = result;
5543   return jresult;
5544 }
5545
5546
5547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5548   float jresult ;
5549   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5550   Dali::Vector4 *arg2 = 0 ;
5551   float result;
5552
5553   arg1 = (Dali::Vector4 *)jarg1;
5554   arg2 = (Dali::Vector4 *)jarg2;
5555   if (!arg2) {
5556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5557     return 0;
5558   }
5559   {
5560     try {
5561       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5562     } CALL_CATCH_EXCEPTION(0);
5563   }
5564
5565   jresult = result;
5566   return jresult;
5567 }
5568
5569
5570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5571   void * jresult ;
5572   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5573   Dali::Vector4 *arg2 = 0 ;
5574   Dali::Vector4 result;
5575
5576   arg1 = (Dali::Vector4 *)jarg1;
5577   arg2 = (Dali::Vector4 *)jarg2;
5578   if (!arg2) {
5579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5580     return 0;
5581   }
5582   {
5583     try {
5584       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5585     } CALL_CATCH_EXCEPTION(0);
5586   }
5587
5588   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5589   return jresult;
5590 }
5591
5592
5593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5594   float jresult ;
5595   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5596   float result;
5597
5598   arg1 = (Dali::Vector4 *)jarg1;
5599   {
5600     try {
5601       result = (float)((Dali::Vector4 const *)arg1)->Length();
5602     } CALL_CATCH_EXCEPTION(0);
5603   }
5604
5605   jresult = result;
5606   return jresult;
5607 }
5608
5609
5610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5611   float jresult ;
5612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5613   float result;
5614
5615   arg1 = (Dali::Vector4 *)jarg1;
5616   {
5617     try {
5618       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5619     } CALL_CATCH_EXCEPTION(0);
5620   }
5621
5622   jresult = result;
5623   return jresult;
5624 }
5625
5626
5627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5629
5630   arg1 = (Dali::Vector4 *)jarg1;
5631   {
5632     try {
5633       (arg1)->Normalize();
5634     } CALL_CATCH_EXCEPTION();
5635   }
5636
5637 }
5638
5639
5640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5642   Dali::Vector4 *arg2 = 0 ;
5643   Dali::Vector4 *arg3 = 0 ;
5644
5645   arg1 = (Dali::Vector4 *)jarg1;
5646   arg2 = (Dali::Vector4 *)jarg2;
5647   if (!arg2) {
5648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5649     return ;
5650   }
5651   arg3 = (Dali::Vector4 *)jarg3;
5652   if (!arg3) {
5653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5654     return ;
5655   }
5656   {
5657     try {
5658       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
5659     } CALL_CATCH_EXCEPTION();
5660   }
5661
5662 }
5663
5664
5665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
5666   void * jresult ;
5667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5668   float *result = 0 ;
5669
5670   arg1 = (Dali::Vector4 *)jarg1;
5671   {
5672     try {
5673       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
5674     } CALL_CATCH_EXCEPTION(0);
5675   }
5676
5677   jresult = (void *)result;
5678   return jresult;
5679 }
5680
5681
5682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
5683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5684   float arg2 ;
5685
5686   arg1 = (Dali::Vector4 *)jarg1;
5687   arg2 = (float)jarg2;
5688   if (arg1) (arg1)->x = arg2;
5689 }
5690
5691
5692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
5693   float jresult ;
5694   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5695   float result;
5696
5697   arg1 = (Dali::Vector4 *)jarg1;
5698   result = (float) ((arg1)->x);
5699   jresult = result;
5700   return jresult;
5701 }
5702
5703
5704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
5705   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5706   float arg2 ;
5707
5708   arg1 = (Dali::Vector4 *)jarg1;
5709   arg2 = (float)jarg2;
5710   if (arg1) (arg1)->r = arg2;
5711 }
5712
5713
5714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
5715   float jresult ;
5716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5717   float result;
5718
5719   arg1 = (Dali::Vector4 *)jarg1;
5720   result = (float) ((arg1)->r);
5721   jresult = result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
5727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5728   float arg2 ;
5729
5730   arg1 = (Dali::Vector4 *)jarg1;
5731   arg2 = (float)jarg2;
5732   if (arg1) (arg1)->s = arg2;
5733 }
5734
5735
5736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
5737   float jresult ;
5738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5739   float result;
5740
5741   arg1 = (Dali::Vector4 *)jarg1;
5742   result = (float) ((arg1)->s);
5743   jresult = result;
5744   return jresult;
5745 }
5746
5747
5748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
5749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5750   float arg2 ;
5751
5752   arg1 = (Dali::Vector4 *)jarg1;
5753   arg2 = (float)jarg2;
5754   if (arg1) (arg1)->y = arg2;
5755 }
5756
5757
5758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
5759   float jresult ;
5760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5761   float result;
5762
5763   arg1 = (Dali::Vector4 *)jarg1;
5764   result = (float) ((arg1)->y);
5765   jresult = result;
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
5771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5772   float arg2 ;
5773
5774   arg1 = (Dali::Vector4 *)jarg1;
5775   arg2 = (float)jarg2;
5776   if (arg1) (arg1)->g = arg2;
5777 }
5778
5779
5780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
5781   float jresult ;
5782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5783   float result;
5784
5785   arg1 = (Dali::Vector4 *)jarg1;
5786   result = (float) ((arg1)->g);
5787   jresult = result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
5793   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5794   float arg2 ;
5795
5796   arg1 = (Dali::Vector4 *)jarg1;
5797   arg2 = (float)jarg2;
5798   if (arg1) (arg1)->t = arg2;
5799 }
5800
5801
5802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
5803   float jresult ;
5804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5805   float result;
5806
5807   arg1 = (Dali::Vector4 *)jarg1;
5808   result = (float) ((arg1)->t);
5809   jresult = result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
5815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5816   float arg2 ;
5817
5818   arg1 = (Dali::Vector4 *)jarg1;
5819   arg2 = (float)jarg2;
5820   if (arg1) (arg1)->z = arg2;
5821 }
5822
5823
5824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
5825   float jresult ;
5826   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5827   float result;
5828
5829   arg1 = (Dali::Vector4 *)jarg1;
5830   result = (float) ((arg1)->z);
5831   jresult = result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
5837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5838   float arg2 ;
5839
5840   arg1 = (Dali::Vector4 *)jarg1;
5841   arg2 = (float)jarg2;
5842   if (arg1) (arg1)->b = arg2;
5843 }
5844
5845
5846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
5847   float jresult ;
5848   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5849   float result;
5850
5851   arg1 = (Dali::Vector4 *)jarg1;
5852   result = (float) ((arg1)->b);
5853   jresult = result;
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
5859   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5860   float arg2 ;
5861
5862   arg1 = (Dali::Vector4 *)jarg1;
5863   arg2 = (float)jarg2;
5864   if (arg1) (arg1)->p = arg2;
5865 }
5866
5867
5868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
5869   float jresult ;
5870   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5871   float result;
5872
5873   arg1 = (Dali::Vector4 *)jarg1;
5874   result = (float) ((arg1)->p);
5875   jresult = result;
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
5881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5882   float arg2 ;
5883
5884   arg1 = (Dali::Vector4 *)jarg1;
5885   arg2 = (float)jarg2;
5886   if (arg1) (arg1)->w = arg2;
5887 }
5888
5889
5890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
5891   float jresult ;
5892   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5893   float result;
5894
5895   arg1 = (Dali::Vector4 *)jarg1;
5896   result = (float) ((arg1)->w);
5897   jresult = result;
5898   return jresult;
5899 }
5900
5901
5902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
5903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5904   float arg2 ;
5905
5906   arg1 = (Dali::Vector4 *)jarg1;
5907   arg2 = (float)jarg2;
5908   if (arg1) (arg1)->a = arg2;
5909 }
5910
5911
5912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
5913   float jresult ;
5914   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5915   float result;
5916
5917   arg1 = (Dali::Vector4 *)jarg1;
5918   result = (float) ((arg1)->a);
5919   jresult = result;
5920   return jresult;
5921 }
5922
5923
5924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
5925   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5926   float arg2 ;
5927
5928   arg1 = (Dali::Vector4 *)jarg1;
5929   arg2 = (float)jarg2;
5930   if (arg1) (arg1)->q = arg2;
5931 }
5932
5933
5934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
5935   float jresult ;
5936   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5937   float result;
5938
5939   arg1 = (Dali::Vector4 *)jarg1;
5940   result = (float) ((arg1)->q);
5941   jresult = result;
5942   return jresult;
5943 }
5944
5945
5946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
5947   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5948
5949   arg1 = (Dali::Vector4 *)jarg1;
5950   {
5951     try {
5952       delete arg1;
5953     } CALL_CATCH_EXCEPTION();
5954   }
5955
5956 }
5957
5958
5959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
5960   void * jresult ;
5961   Dali::Vector4 *arg1 = 0 ;
5962   Dali::Vector4 *arg2 = 0 ;
5963   Dali::Vector4 result;
5964
5965   arg1 = (Dali::Vector4 *)jarg1;
5966   if (!arg1) {
5967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5968     return 0;
5969   }
5970   arg2 = (Dali::Vector4 *)jarg2;
5971   if (!arg2) {
5972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5973     return 0;
5974   }
5975   {
5976     try {
5977       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
5978     } CALL_CATCH_EXCEPTION(0);
5979   }
5980
5981   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5982   return jresult;
5983 }
5984
5985
5986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
5987   void * jresult ;
5988   Dali::Vector4 *arg1 = 0 ;
5989   Dali::Vector4 *arg2 = 0 ;
5990   Dali::Vector4 result;
5991
5992   arg1 = (Dali::Vector4 *)jarg1;
5993   if (!arg1) {
5994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5995     return 0;
5996   }
5997   arg2 = (Dali::Vector4 *)jarg2;
5998   if (!arg2) {
5999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6000     return 0;
6001   }
6002   {
6003     try {
6004       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6005     } CALL_CATCH_EXCEPTION(0);
6006   }
6007
6008   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6009   return jresult;
6010 }
6011
6012
6013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6014   void * jresult ;
6015   Dali::Vector4 *arg1 = 0 ;
6016   float *arg2 = 0 ;
6017   float *arg3 = 0 ;
6018   float temp2 ;
6019   float temp3 ;
6020   Dali::Vector4 result;
6021
6022   arg1 = (Dali::Vector4 *)jarg1;
6023   if (!arg1) {
6024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6025     return 0;
6026   }
6027   temp2 = (float)jarg2;
6028   arg2 = &temp2;
6029   temp3 = (float)jarg3;
6030   arg3 = &temp3;
6031   {
6032     try {
6033       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6034     } CALL_CATCH_EXCEPTION(0);
6035   }
6036
6037   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6038   return jresult;
6039 }
6040
6041
6042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6043   void * jresult ;
6044   Dali::Uint16Pair *result = 0 ;
6045
6046   {
6047     try {
6048       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6049     } CALL_CATCH_EXCEPTION(0);
6050   }
6051
6052   jresult = (void *)result;
6053   return jresult;
6054 }
6055
6056
6057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6058   void * jresult ;
6059   uint32_t arg1 ;
6060   uint32_t arg2 ;
6061   Dali::Uint16Pair *result = 0 ;
6062
6063   arg1 = (uint32_t)jarg1;
6064   arg2 = (uint32_t)jarg2;
6065   {
6066     try {
6067       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6068     } CALL_CATCH_EXCEPTION(0);
6069   }
6070
6071   jresult = (void *)result;
6072   return jresult;
6073 }
6074
6075
6076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6077   void * jresult ;
6078   Dali::Uint16Pair *arg1 = 0 ;
6079   Dali::Uint16Pair *result = 0 ;
6080
6081   arg1 = (Dali::Uint16Pair *)jarg1;
6082   if (!arg1) {
6083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6084     return 0;
6085   }
6086   {
6087     try {
6088       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6089     } CALL_CATCH_EXCEPTION(0);
6090   }
6091
6092   jresult = (void *)result;
6093   return jresult;
6094 }
6095
6096
6097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6098   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6099   uint16_t arg2 ;
6100
6101   arg1 = (Dali::Uint16Pair *)jarg1;
6102   arg2 = (uint16_t)jarg2;
6103   {
6104     try {
6105       (arg1)->SetWidth(arg2);
6106     } CALL_CATCH_EXCEPTION();
6107   }
6108
6109 }
6110
6111
6112 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6113   unsigned short jresult ;
6114   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6115   uint16_t result;
6116
6117   arg1 = (Dali::Uint16Pair *)jarg1;
6118   {
6119     try {
6120       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6121     } CALL_CATCH_EXCEPTION(0);
6122   }
6123
6124   jresult = result;
6125   return jresult;
6126 }
6127
6128
6129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6130   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6131   uint16_t arg2 ;
6132
6133   arg1 = (Dali::Uint16Pair *)jarg1;
6134   arg2 = (uint16_t)jarg2;
6135   {
6136     try {
6137       (arg1)->SetHeight(arg2);
6138     } CALL_CATCH_EXCEPTION();
6139   }
6140
6141 }
6142
6143
6144 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6145   unsigned short jresult ;
6146   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6147   uint16_t result;
6148
6149   arg1 = (Dali::Uint16Pair *)jarg1;
6150   {
6151     try {
6152       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6153     } CALL_CATCH_EXCEPTION(0);
6154   }
6155
6156   jresult = result;
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6162   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6163   uint16_t arg2 ;
6164
6165   arg1 = (Dali::Uint16Pair *)jarg1;
6166   arg2 = (uint16_t)jarg2;
6167   {
6168     try {
6169       (arg1)->SetX(arg2);
6170     } CALL_CATCH_EXCEPTION();
6171   }
6172
6173 }
6174
6175
6176 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6177   unsigned short jresult ;
6178   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6179   uint16_t result;
6180
6181   arg1 = (Dali::Uint16Pair *)jarg1;
6182   {
6183     try {
6184       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6185     } CALL_CATCH_EXCEPTION(0);
6186   }
6187
6188   jresult = result;
6189   return jresult;
6190 }
6191
6192
6193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6194   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6195   uint16_t arg2 ;
6196
6197   arg1 = (Dali::Uint16Pair *)jarg1;
6198   arg2 = (uint16_t)jarg2;
6199   {
6200     try {
6201       (arg1)->SetY(arg2);
6202     } CALL_CATCH_EXCEPTION();
6203   }
6204
6205 }
6206
6207
6208 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6209   unsigned short jresult ;
6210   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6211   uint16_t result;
6212
6213   arg1 = (Dali::Uint16Pair *)jarg1;
6214   {
6215     try {
6216       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6217     } CALL_CATCH_EXCEPTION(0);
6218   }
6219
6220   jresult = result;
6221   return jresult;
6222 }
6223
6224
6225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6226   void * jresult ;
6227   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6228   Dali::Uint16Pair *arg2 = 0 ;
6229   Dali::Uint16Pair *result = 0 ;
6230
6231   arg1 = (Dali::Uint16Pair *)jarg1;
6232   arg2 = (Dali::Uint16Pair *)jarg2;
6233   if (!arg2) {
6234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6235     return 0;
6236   }
6237   {
6238     try {
6239       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6240     } CALL_CATCH_EXCEPTION(0);
6241   }
6242
6243   jresult = (void *)result;
6244   return jresult;
6245 }
6246
6247
6248 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6249   bool jresult ;
6250   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6251   Dali::Uint16Pair *arg2 = 0 ;
6252   bool result;
6253
6254   arg1 = (Dali::Uint16Pair *)jarg1;
6255   arg2 = (Dali::Uint16Pair *)jarg2;
6256   if (!arg2) {
6257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6258     return 0;
6259   }
6260   {
6261     try {
6262       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6263     } CALL_CATCH_EXCEPTION(0);
6264   }
6265
6266   jresult = result;
6267   return jresult;
6268 }
6269
6270
6271 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6272   bool jresult ;
6273   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6274   Dali::Uint16Pair *arg2 = 0 ;
6275   bool result;
6276
6277   arg1 = (Dali::Uint16Pair *)jarg1;
6278   arg2 = (Dali::Uint16Pair *)jarg2;
6279   if (!arg2) {
6280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6281     return 0;
6282   }
6283   {
6284     try {
6285       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6286     } CALL_CATCH_EXCEPTION(0);
6287   }
6288
6289   jresult = result;
6290   return jresult;
6291 }
6292
6293
6294 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6295   bool jresult ;
6296   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6297   Dali::Uint16Pair *arg2 = 0 ;
6298   bool result;
6299
6300   arg1 = (Dali::Uint16Pair *)jarg1;
6301   arg2 = (Dali::Uint16Pair *)jarg2;
6302   if (!arg2) {
6303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6304     return 0;
6305   }
6306   {
6307     try {
6308       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6309     } CALL_CATCH_EXCEPTION(0);
6310   }
6311
6312   jresult = result;
6313   return jresult;
6314 }
6315
6316
6317 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6318   bool jresult ;
6319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6320   Dali::Uint16Pair *arg2 = 0 ;
6321   bool result;
6322
6323   arg1 = (Dali::Uint16Pair *)jarg1;
6324   arg2 = (Dali::Uint16Pair *)jarg2;
6325   if (!arg2) {
6326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6327     return 0;
6328   }
6329   {
6330     try {
6331       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6332     } CALL_CATCH_EXCEPTION(0);
6333   }
6334
6335   jresult = result;
6336   return jresult;
6337 }
6338
6339
6340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6341   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6342
6343   arg1 = (Dali::Uint16Pair *)jarg1;
6344   {
6345     try {
6346       delete arg1;
6347     } CALL_CATCH_EXCEPTION();
6348   }
6349
6350 }
6351
6352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
6353   void * jresult ;
6354   Dali::Int32Pair *result = 0 ;
6355
6356   {
6357     try {
6358       result = (Dali::Int32Pair *)new Dali::Int32Pair();
6359     } CALL_CATCH_EXCEPTION(0);
6360   }
6361
6362   jresult = (void *)result;
6363   return jresult;
6364 }
6365
6366
6367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
6368   void * jresult ;
6369   Dali::Int32Pair *result = 0 ;
6370
6371   {
6372     try {
6373       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
6374     } CALL_CATCH_EXCEPTION(0);
6375   }
6376
6377   jresult = (void *)result;
6378   return jresult;
6379 }
6380
6381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
6382   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6383
6384   {
6385     try {
6386       (pInt32Pair)->SetX(x);
6387     } CALL_CATCH_EXCEPTION();
6388   }
6389 }
6390
6391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
6392   int result ;
6393   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
6394
6395   {
6396     try {
6397       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
6398     } CALL_CATCH_EXCEPTION(0);
6399   }
6400
6401   return result;
6402 }
6403
6404
6405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
6406   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6407
6408   {
6409     try {
6410       (pInt32Pair)->SetY(y);
6411     } CALL_CATCH_EXCEPTION();
6412   }
6413
6414 }
6415
6416
6417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
6418   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6419   int result;
6420
6421   {
6422     try {
6423       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
6424     } CALL_CATCH_EXCEPTION(0);
6425   }
6426
6427   return result;
6428 }
6429
6430
6431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
6432   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
6433
6434   {
6435     try {
6436       delete pInt32Pair;
6437     } CALL_CATCH_EXCEPTION();
6438   }
6439
6440 }
6441
6442
6443
6444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6445   void * jresult ;
6446   Dali::Degree *result = 0 ;
6447
6448   {
6449     try {
6450       result = (Dali::Degree *)new Dali::Degree();
6451     } CALL_CATCH_EXCEPTION(0);
6452   }
6453
6454   jresult = (void *)result;
6455   return jresult;
6456 }
6457
6458
6459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6460   void * jresult ;
6461   float arg1 ;
6462   Dali::Degree *result = 0 ;
6463
6464   arg1 = (float)jarg1;
6465   {
6466     try {
6467       result = (Dali::Degree *)new Dali::Degree(arg1);
6468     } CALL_CATCH_EXCEPTION(0);
6469   }
6470
6471   jresult = (void *)result;
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6477   void * jresult ;
6478   Dali::Radian arg1 ;
6479   Dali::Radian *argp1 ;
6480   Dali::Degree *result = 0 ;
6481
6482   argp1 = (Dali::Radian *)jarg1;
6483   if (!argp1) {
6484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6485     return 0;
6486   }
6487   arg1 = *argp1;
6488   {
6489     try {
6490       result = (Dali::Degree *)new Dali::Degree(arg1);
6491     } CALL_CATCH_EXCEPTION(0);
6492   }
6493
6494   jresult = (void *)result;
6495   return jresult;
6496 }
6497
6498
6499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6500   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6501   float arg2 ;
6502
6503   arg1 = (Dali::Degree *)jarg1;
6504   arg2 = (float)jarg2;
6505   if (arg1) (arg1)->degree = arg2;
6506 }
6507
6508
6509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6510   float jresult ;
6511   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6512   float result;
6513
6514   arg1 = (Dali::Degree *)jarg1;
6515   result = (float) ((arg1)->degree);
6516   jresult = result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6522   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6523
6524   arg1 = (Dali::Degree *)jarg1;
6525   {
6526     try {
6527       delete arg1;
6528     } CALL_CATCH_EXCEPTION();
6529   }
6530
6531 }
6532
6533
6534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6535   void * jresult ;
6536   Dali::Radian *result = 0 ;
6537
6538   result = (Dali::Radian *)&Dali::ANGLE_360;
6539   jresult = (void *)result;
6540   return jresult;
6541 }
6542
6543
6544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6545   void * jresult ;
6546   Dali::Radian *result = 0 ;
6547
6548   result = (Dali::Radian *)&Dali::ANGLE_315;
6549   jresult = (void *)result;
6550   return jresult;
6551 }
6552
6553
6554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6555   void * jresult ;
6556   Dali::Radian *result = 0 ;
6557
6558   result = (Dali::Radian *)&Dali::ANGLE_270;
6559   jresult = (void *)result;
6560   return jresult;
6561 }
6562
6563
6564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6565   void * jresult ;
6566   Dali::Radian *result = 0 ;
6567
6568   result = (Dali::Radian *)&Dali::ANGLE_225;
6569   jresult = (void *)result;
6570   return jresult;
6571 }
6572
6573
6574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6575   void * jresult ;
6576   Dali::Radian *result = 0 ;
6577
6578   result = (Dali::Radian *)&Dali::ANGLE_180;
6579   jresult = (void *)result;
6580   return jresult;
6581 }
6582
6583
6584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6585   void * jresult ;
6586   Dali::Radian *result = 0 ;
6587
6588   result = (Dali::Radian *)&Dali::ANGLE_135;
6589   jresult = (void *)result;
6590   return jresult;
6591 }
6592
6593
6594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6595   void * jresult ;
6596   Dali::Radian *result = 0 ;
6597
6598   result = (Dali::Radian *)&Dali::ANGLE_120;
6599   jresult = (void *)result;
6600   return jresult;
6601 }
6602
6603
6604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6605   void * jresult ;
6606   Dali::Radian *result = 0 ;
6607
6608   result = (Dali::Radian *)&Dali::ANGLE_90;
6609   jresult = (void *)result;
6610   return jresult;
6611 }
6612
6613
6614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6615   void * jresult ;
6616   Dali::Radian *result = 0 ;
6617
6618   result = (Dali::Radian *)&Dali::ANGLE_60;
6619   jresult = (void *)result;
6620   return jresult;
6621 }
6622
6623
6624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6625   void * jresult ;
6626   Dali::Radian *result = 0 ;
6627
6628   result = (Dali::Radian *)&Dali::ANGLE_45;
6629   jresult = (void *)result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6635   void * jresult ;
6636   Dali::Radian *result = 0 ;
6637
6638   result = (Dali::Radian *)&Dali::ANGLE_30;
6639   jresult = (void *)result;
6640   return jresult;
6641 }
6642
6643
6644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6645   void * jresult ;
6646   Dali::Radian *result = 0 ;
6647
6648   result = (Dali::Radian *)&Dali::ANGLE_0;
6649   jresult = (void *)result;
6650   return jresult;
6651 }
6652
6653
6654 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6655   bool jresult ;
6656   Dali::Degree *arg1 = 0 ;
6657   Dali::Degree *arg2 = 0 ;
6658   bool result;
6659
6660   arg1 = (Dali::Degree *)jarg1;
6661   if (!arg1) {
6662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6663     return 0;
6664   }
6665   arg2 = (Dali::Degree *)jarg2;
6666   if (!arg2) {
6667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6668     return 0;
6669   }
6670   {
6671     try {
6672       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6673     } CALL_CATCH_EXCEPTION(0);
6674   }
6675
6676   jresult = result;
6677   return jresult;
6678 }
6679
6680
6681 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6682   bool jresult ;
6683   Dali::Degree *arg1 = 0 ;
6684   Dali::Degree *arg2 = 0 ;
6685   bool result;
6686
6687   arg1 = (Dali::Degree *)jarg1;
6688   if (!arg1) {
6689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6690     return 0;
6691   }
6692   arg2 = (Dali::Degree *)jarg2;
6693   if (!arg2) {
6694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6695     return 0;
6696   }
6697   {
6698     try {
6699       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6700     } CALL_CATCH_EXCEPTION(0);
6701   }
6702
6703   jresult = result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6709   void * jresult ;
6710   Dali::Degree arg1 ;
6711   float arg2 ;
6712   float arg3 ;
6713   Dali::Degree *argp1 ;
6714   Dali::Degree result;
6715
6716   argp1 = (Dali::Degree *)jarg1;
6717   if (!argp1) {
6718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6719     return 0;
6720   }
6721   arg1 = *argp1;
6722   arg2 = (float)jarg2;
6723   arg3 = (float)jarg3;
6724   {
6725     try {
6726       result = Dali::Clamp(arg1,arg2,arg3);
6727     } CALL_CATCH_EXCEPTION(0);
6728   }
6729
6730   jresult = new Dali::Degree((const Dali::Degree &)result);
6731   return jresult;
6732 }
6733
6734
6735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6736   void * jresult ;
6737   Dali::Radian *result = 0 ;
6738
6739   {
6740     try {
6741       result = (Dali::Radian *)new Dali::Radian();
6742     } CALL_CATCH_EXCEPTION(0);
6743   }
6744
6745   jresult = (void *)result;
6746   return jresult;
6747 }
6748
6749
6750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
6751   void * jresult ;
6752   float arg1 ;
6753   Dali::Radian *result = 0 ;
6754
6755   arg1 = (float)jarg1;
6756   {
6757     try {
6758       result = (Dali::Radian *)new Dali::Radian(arg1);
6759     } CALL_CATCH_EXCEPTION(0);
6760   }
6761
6762   jresult = (void *)result;
6763   return jresult;
6764 }
6765
6766
6767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
6768   void * jresult ;
6769   Dali::Degree arg1 ;
6770   Dali::Degree *argp1 ;
6771   Dali::Radian *result = 0 ;
6772
6773   argp1 = (Dali::Degree *)jarg1;
6774   if (!argp1) {
6775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6776     return 0;
6777   }
6778   arg1 = *argp1;
6779   {
6780     try {
6781       result = (Dali::Radian *)new Dali::Radian(arg1);
6782     } CALL_CATCH_EXCEPTION(0);
6783   }
6784
6785   jresult = (void *)result;
6786   return jresult;
6787 }
6788
6789
6790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
6791   void * jresult ;
6792   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6793   float arg2 ;
6794   Dali::Radian *result = 0 ;
6795
6796   arg1 = (Dali::Radian *)jarg1;
6797   arg2 = (float)jarg2;
6798   {
6799     try {
6800       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6801     } CALL_CATCH_EXCEPTION(0);
6802   }
6803
6804   jresult = (void *)result;
6805   return jresult;
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
6810   void * jresult ;
6811   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6812   Dali::Degree arg2 ;
6813   Dali::Degree *argp2 ;
6814   Dali::Radian *result = 0 ;
6815
6816   arg1 = (Dali::Radian *)jarg1;
6817   argp2 = (Dali::Degree *)jarg2;
6818   if (!argp2) {
6819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6820     return 0;
6821   }
6822   arg2 = *argp2;
6823   {
6824     try {
6825       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6826     } CALL_CATCH_EXCEPTION(0);
6827   }
6828
6829   jresult = (void *)result;
6830   return jresult;
6831 }
6832
6833
6834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
6835   float jresult ;
6836   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6837   float result;
6838
6839   arg1 = (Dali::Radian *)jarg1;
6840   {
6841     try {
6842       result = (float)((Dali::Radian const *)arg1)->operator float();
6843     } CALL_CATCH_EXCEPTION(0);
6844   }
6845
6846   jresult = result;
6847   return jresult;
6848 }
6849
6850
6851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
6852   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6853   float arg2 ;
6854
6855   arg1 = (Dali::Radian *)jarg1;
6856   arg2 = (float)jarg2;
6857   if (arg1) (arg1)->radian = arg2;
6858 }
6859
6860
6861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
6862   float jresult ;
6863   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6864   float result;
6865
6866   arg1 = (Dali::Radian *)jarg1;
6867   result = (float) ((arg1)->radian);
6868   jresult = result;
6869   return jresult;
6870 }
6871
6872
6873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
6874   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6875
6876   arg1 = (Dali::Radian *)jarg1;
6877   {
6878     try {
6879       delete arg1;
6880     } CALL_CATCH_EXCEPTION();
6881   }
6882
6883 }
6884
6885
6886 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
6887   bool jresult ;
6888   Dali::Radian arg1 ;
6889   Dali::Radian arg2 ;
6890   Dali::Radian *argp1 ;
6891   Dali::Radian *argp2 ;
6892   bool result;
6893
6894   argp1 = (Dali::Radian *)jarg1;
6895   if (!argp1) {
6896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6897     return 0;
6898   }
6899   arg1 = *argp1;
6900   argp2 = (Dali::Radian *)jarg2;
6901   if (!argp2) {
6902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6903     return 0;
6904   }
6905   arg2 = *argp2;
6906   {
6907     try {
6908       result = (bool)Dali::operator ==(arg1,arg2);
6909     } CALL_CATCH_EXCEPTION(0);
6910   }
6911
6912   jresult = result;
6913   return jresult;
6914 }
6915
6916
6917 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
6918   bool jresult ;
6919   Dali::Radian arg1 ;
6920   Dali::Radian arg2 ;
6921   Dali::Radian *argp1 ;
6922   Dali::Radian *argp2 ;
6923   bool result;
6924
6925   argp1 = (Dali::Radian *)jarg1;
6926   if (!argp1) {
6927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6928     return 0;
6929   }
6930   arg1 = *argp1;
6931   argp2 = (Dali::Radian *)jarg2;
6932   if (!argp2) {
6933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6934     return 0;
6935   }
6936   arg2 = *argp2;
6937   {
6938     try {
6939       result = (bool)Dali::operator !=(arg1,arg2);
6940     } CALL_CATCH_EXCEPTION(0);
6941   }
6942
6943   jresult = result;
6944   return jresult;
6945 }
6946
6947
6948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
6949   bool jresult ;
6950   Dali::Radian arg1 ;
6951   Dali::Degree arg2 ;
6952   Dali::Radian *argp1 ;
6953   Dali::Degree *argp2 ;
6954   bool result;
6955
6956   argp1 = (Dali::Radian *)jarg1;
6957   if (!argp1) {
6958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6959     return 0;
6960   }
6961   arg1 = *argp1;
6962   argp2 = (Dali::Degree *)jarg2;
6963   if (!argp2) {
6964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6965     return 0;
6966   }
6967   arg2 = *argp2;
6968   {
6969     try {
6970       result = (bool)Dali::operator ==(arg1,arg2);
6971     } CALL_CATCH_EXCEPTION(0);
6972   }
6973
6974   jresult = result;
6975   return jresult;
6976 }
6977
6978
6979 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
6980   bool jresult ;
6981   Dali::Radian arg1 ;
6982   Dali::Degree arg2 ;
6983   Dali::Radian *argp1 ;
6984   Dali::Degree *argp2 ;
6985   bool result;
6986
6987   argp1 = (Dali::Radian *)jarg1;
6988   if (!argp1) {
6989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6990     return 0;
6991   }
6992   arg1 = *argp1;
6993   argp2 = (Dali::Degree *)jarg2;
6994   if (!argp2) {
6995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6996     return 0;
6997   }
6998   arg2 = *argp2;
6999   {
7000     try {
7001       result = (bool)Dali::operator !=(arg1,arg2);
7002     } CALL_CATCH_EXCEPTION(0);
7003   }
7004
7005   jresult = result;
7006   return jresult;
7007 }
7008
7009
7010 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7011   bool jresult ;
7012   Dali::Degree arg1 ;
7013   Dali::Radian arg2 ;
7014   Dali::Degree *argp1 ;
7015   Dali::Radian *argp2 ;
7016   bool result;
7017
7018   argp1 = (Dali::Degree *)jarg1;
7019   if (!argp1) {
7020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7021     return 0;
7022   }
7023   arg1 = *argp1;
7024   argp2 = (Dali::Radian *)jarg2;
7025   if (!argp2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7027     return 0;
7028   }
7029   arg2 = *argp2;
7030   {
7031     try {
7032       result = (bool)Dali::operator ==(arg1,arg2);
7033     } CALL_CATCH_EXCEPTION(0);
7034   }
7035
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7042   bool jresult ;
7043   Dali::Degree arg1 ;
7044   Dali::Radian arg2 ;
7045   Dali::Degree *argp1 ;
7046   Dali::Radian *argp2 ;
7047   bool result;
7048
7049   argp1 = (Dali::Degree *)jarg1;
7050   if (!argp1) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7052     return 0;
7053   }
7054   arg1 = *argp1;
7055   argp2 = (Dali::Radian *)jarg2;
7056   if (!argp2) {
7057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7058     return 0;
7059   }
7060   arg2 = *argp2;
7061   {
7062     try {
7063       result = (bool)Dali::operator !=(arg1,arg2);
7064     } CALL_CATCH_EXCEPTION(0);
7065   }
7066
7067   jresult = result;
7068   return jresult;
7069 }
7070
7071
7072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7073   bool jresult ;
7074   Dali::Radian arg1 ;
7075   Dali::Radian arg2 ;
7076   Dali::Radian *argp1 ;
7077   Dali::Radian *argp2 ;
7078   bool result;
7079
7080   argp1 = (Dali::Radian *)jarg1;
7081   if (!argp1) {
7082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7083     return 0;
7084   }
7085   arg1 = *argp1;
7086   argp2 = (Dali::Radian *)jarg2;
7087   if (!argp2) {
7088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7089     return 0;
7090   }
7091   arg2 = *argp2;
7092   {
7093     try {
7094       result = (bool)Dali::operator >(arg1,arg2);
7095     } CALL_CATCH_EXCEPTION(0);
7096   }
7097
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7104   bool jresult ;
7105   Dali::Radian arg1 ;
7106   Dali::Degree arg2 ;
7107   Dali::Radian *argp1 ;
7108   Dali::Degree *argp2 ;
7109   bool result;
7110
7111   argp1 = (Dali::Radian *)jarg1;
7112   if (!argp1) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7114     return 0;
7115   }
7116   arg1 = *argp1;
7117   argp2 = (Dali::Degree *)jarg2;
7118   if (!argp2) {
7119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7120     return 0;
7121   }
7122   arg2 = *argp2;
7123   {
7124     try {
7125       result = (bool)Dali::operator >(arg1,arg2);
7126     } CALL_CATCH_EXCEPTION(0);
7127   }
7128
7129   jresult = result;
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7135   bool jresult ;
7136   Dali::Degree arg1 ;
7137   Dali::Radian arg2 ;
7138   Dali::Degree *argp1 ;
7139   Dali::Radian *argp2 ;
7140   bool result;
7141
7142   argp1 = (Dali::Degree *)jarg1;
7143   if (!argp1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7145     return 0;
7146   }
7147   arg1 = *argp1;
7148   argp2 = (Dali::Radian *)jarg2;
7149   if (!argp2) {
7150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7151     return 0;
7152   }
7153   arg2 = *argp2;
7154   {
7155     try {
7156       result = (bool)Dali::operator >(arg1,arg2);
7157     } CALL_CATCH_EXCEPTION(0);
7158   }
7159
7160   jresult = result;
7161   return jresult;
7162 }
7163
7164
7165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7166   bool jresult ;
7167   Dali::Radian arg1 ;
7168   Dali::Radian arg2 ;
7169   Dali::Radian *argp1 ;
7170   Dali::Radian *argp2 ;
7171   bool result;
7172
7173   argp1 = (Dali::Radian *)jarg1;
7174   if (!argp1) {
7175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7176     return 0;
7177   }
7178   arg1 = *argp1;
7179   argp2 = (Dali::Radian *)jarg2;
7180   if (!argp2) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7182     return 0;
7183   }
7184   arg2 = *argp2;
7185   {
7186     try {
7187       result = (bool)Dali::operator <(arg1,arg2);
7188     } CALL_CATCH_EXCEPTION(0);
7189   }
7190
7191   jresult = result;
7192   return jresult;
7193 }
7194
7195
7196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7197   bool jresult ;
7198   Dali::Radian arg1 ;
7199   Dali::Degree arg2 ;
7200   Dali::Radian *argp1 ;
7201   Dali::Degree *argp2 ;
7202   bool result;
7203
7204   argp1 = (Dali::Radian *)jarg1;
7205   if (!argp1) {
7206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7207     return 0;
7208   }
7209   arg1 = *argp1;
7210   argp2 = (Dali::Degree *)jarg2;
7211   if (!argp2) {
7212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7213     return 0;
7214   }
7215   arg2 = *argp2;
7216   {
7217     try {
7218       result = (bool)Dali::operator <(arg1,arg2);
7219     } CALL_CATCH_EXCEPTION(0);
7220   }
7221
7222   jresult = result;
7223   return jresult;
7224 }
7225
7226
7227 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7228   bool jresult ;
7229   Dali::Degree arg1 ;
7230   Dali::Radian arg2 ;
7231   Dali::Degree *argp1 ;
7232   Dali::Radian *argp2 ;
7233   bool result;
7234
7235   argp1 = (Dali::Degree *)jarg1;
7236   if (!argp1) {
7237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7238     return 0;
7239   }
7240   arg1 = *argp1;
7241   argp2 = (Dali::Radian *)jarg2;
7242   if (!argp2) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7244     return 0;
7245   }
7246   arg2 = *argp2;
7247   {
7248     try {
7249       result = (bool)Dali::operator <(arg1,arg2);
7250     } CALL_CATCH_EXCEPTION(0);
7251   }
7252
7253   jresult = result;
7254   return jresult;
7255 }
7256
7257
7258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7259   void * jresult ;
7260   Dali::Radian arg1 ;
7261   float arg2 ;
7262   Dali::Radian *argp1 ;
7263   Dali::Radian result;
7264
7265   argp1 = (Dali::Radian *)jarg1;
7266   if (!argp1) {
7267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7268     return 0;
7269   }
7270   arg1 = *argp1;
7271   arg2 = (float)jarg2;
7272   {
7273     try {
7274       result = Dali::operator *(arg1,arg2);
7275     } CALL_CATCH_EXCEPTION(0);
7276   }
7277
7278   jresult = new Dali::Radian((const Dali::Radian &)result);
7279   return jresult;
7280 }
7281
7282
7283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7284   void * jresult ;
7285   Dali::Radian arg1 ;
7286   Dali::Radian *argp1 ;
7287   Dali::Radian result;
7288
7289   argp1 = (Dali::Radian *)jarg1;
7290   if (!argp1) {
7291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7292     return 0;
7293   }
7294   arg1 = *argp1;
7295   {
7296     try {
7297       result = Dali::operator -(arg1);
7298     } CALL_CATCH_EXCEPTION(0);
7299   }
7300
7301   jresult = new Dali::Radian((const Dali::Radian &)result);
7302   return jresult;
7303 }
7304
7305
7306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7307   void * jresult ;
7308   Dali::Radian arg1 ;
7309   float arg2 ;
7310   float arg3 ;
7311   Dali::Radian *argp1 ;
7312   Dali::Radian result;
7313
7314   argp1 = (Dali::Radian *)jarg1;
7315   if (!argp1) {
7316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7317     return 0;
7318   }
7319   arg1 = *argp1;
7320   arg2 = (float)jarg2;
7321   arg3 = (float)jarg3;
7322   {
7323     try {
7324       result = Dali::Clamp(arg1,arg2,arg3);
7325     } CALL_CATCH_EXCEPTION(0);
7326   }
7327
7328   jresult = new Dali::Radian((const Dali::Radian &)result);
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
7334   void * jresult ;
7335   Dali::Matrix *result = 0 ;
7336
7337   {
7338     try {
7339       result = (Dali::Matrix *)new Dali::Matrix();
7340     } CALL_CATCH_EXCEPTION(0);
7341   }
7342
7343   jresult = (void *)result;
7344   return jresult;
7345 }
7346
7347
7348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
7349   void * jresult ;
7350   bool arg1 ;
7351   Dali::Matrix *result = 0 ;
7352
7353   arg1 = jarg1 ? true : false;
7354   {
7355     try {
7356       result = (Dali::Matrix *)new Dali::Matrix(arg1);
7357     } CALL_CATCH_EXCEPTION(0);
7358   }
7359
7360   jresult = (void *)result;
7361   return jresult;
7362 }
7363
7364
7365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
7366   void * jresult ;
7367   float *arg1 = (float *) 0 ;
7368   Dali::Matrix *result = 0 ;
7369
7370   arg1 = jarg1;
7371   {
7372     try {
7373       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
7374     } CALL_CATCH_EXCEPTION(0);
7375   }
7376
7377   jresult = (void *)result;
7378
7379
7380   return jresult;
7381 }
7382
7383
7384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
7385   void * jresult ;
7386   Dali::Quaternion *arg1 = 0 ;
7387   Dali::Matrix *result = 0 ;
7388
7389   arg1 = (Dali::Quaternion *)jarg1;
7390   if (!arg1) {
7391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7392     return 0;
7393   }
7394   {
7395     try {
7396       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
7397     } CALL_CATCH_EXCEPTION(0);
7398   }
7399
7400   jresult = (void *)result;
7401   return jresult;
7402 }
7403
7404
7405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
7406   void * jresult ;
7407   Dali::Matrix *arg1 = 0 ;
7408   Dali::Matrix *result = 0 ;
7409
7410   arg1 = (Dali::Matrix *)jarg1;
7411   if (!arg1) {
7412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7413     return 0;
7414   }
7415   {
7416     try {
7417       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
7418     } CALL_CATCH_EXCEPTION(0);
7419   }
7420
7421   jresult = (void *)result;
7422   return jresult;
7423 }
7424
7425
7426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
7427   void * jresult ;
7428   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7429   Dali::Matrix *arg2 = 0 ;
7430   Dali::Matrix *result = 0 ;
7431
7432   arg1 = (Dali::Matrix *)jarg1;
7433   arg2 = (Dali::Matrix *)jarg2;
7434   if (!arg2) {
7435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7436     return 0;
7437   }
7438   {
7439     try {
7440       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
7441     } CALL_CATCH_EXCEPTION(0);
7442   }
7443
7444   jresult = (void *)result;
7445   return jresult;
7446 }
7447
7448
7449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
7450   void * jresult ;
7451   Dali::Matrix *result = 0 ;
7452
7453   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
7454   jresult = (void *)result;
7455   return jresult;
7456 }
7457
7458
7459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
7460   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7461
7462   arg1 = (Dali::Matrix *)jarg1;
7463   {
7464     try {
7465       (arg1)->SetIdentity();
7466     } CALL_CATCH_EXCEPTION();
7467   }
7468
7469 }
7470
7471
7472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
7473   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7474   Dali::Vector3 *arg2 = 0 ;
7475
7476   arg1 = (Dali::Matrix *)jarg1;
7477   arg2 = (Dali::Vector3 *)jarg2;
7478   if (!arg2) {
7479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7480     return ;
7481   }
7482   {
7483     try {
7484       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
7485     } CALL_CATCH_EXCEPTION();
7486   }
7487
7488 }
7489
7490
7491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
7492   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7493   Dali::Matrix *arg2 = 0 ;
7494
7495   arg1 = (Dali::Matrix *)jarg1;
7496   arg2 = (Dali::Matrix *)jarg2;
7497   if (!arg2) {
7498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7499     return ;
7500   }
7501   {
7502     try {
7503       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
7504     } CALL_CATCH_EXCEPTION();
7505   }
7506
7507 }
7508
7509
7510 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
7511   bool jresult ;
7512   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7513   bool result;
7514
7515   arg1 = (Dali::Matrix *)jarg1;
7516   {
7517     try {
7518       result = (bool)(arg1)->Invert();
7519     } CALL_CATCH_EXCEPTION(0);
7520   }
7521
7522   jresult = result;
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
7528   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7529
7530   arg1 = (Dali::Matrix *)jarg1;
7531   {
7532     try {
7533       (arg1)->Transpose();
7534     } CALL_CATCH_EXCEPTION();
7535   }
7536
7537 }
7538
7539
7540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
7541   void * jresult ;
7542   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7543   Dali::Vector3 result;
7544
7545   arg1 = (Dali::Matrix *)jarg1;
7546   {
7547     try {
7548       result = ((Dali::Matrix const *)arg1)->GetXAxis();
7549     } CALL_CATCH_EXCEPTION(0);
7550   }
7551
7552   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7553   return jresult;
7554 }
7555
7556
7557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
7558   void * jresult ;
7559   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7560   Dali::Vector3 result;
7561
7562   arg1 = (Dali::Matrix *)jarg1;
7563   {
7564     try {
7565       result = ((Dali::Matrix const *)arg1)->GetYAxis();
7566     } CALL_CATCH_EXCEPTION(0);
7567   }
7568
7569   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
7575   void * jresult ;
7576   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7577   Dali::Vector3 result;
7578
7579   arg1 = (Dali::Matrix *)jarg1;
7580   {
7581     try {
7582       result = ((Dali::Matrix const *)arg1)->GetZAxis();
7583     } CALL_CATCH_EXCEPTION(0);
7584   }
7585
7586   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7587   return jresult;
7588 }
7589
7590
7591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
7592   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7593   Dali::Vector3 *arg2 = 0 ;
7594
7595   arg1 = (Dali::Matrix *)jarg1;
7596   arg2 = (Dali::Vector3 *)jarg2;
7597   if (!arg2) {
7598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7599     return ;
7600   }
7601   {
7602     try {
7603       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
7604     } CALL_CATCH_EXCEPTION();
7605   }
7606
7607 }
7608
7609
7610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
7611   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7612   Dali::Vector3 *arg2 = 0 ;
7613
7614   arg1 = (Dali::Matrix *)jarg1;
7615   arg2 = (Dali::Vector3 *)jarg2;
7616   if (!arg2) {
7617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7618     return ;
7619   }
7620   {
7621     try {
7622       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
7623     } CALL_CATCH_EXCEPTION();
7624   }
7625
7626 }
7627
7628
7629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
7630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7631   Dali::Vector3 *arg2 = 0 ;
7632
7633   arg1 = (Dali::Matrix *)jarg1;
7634   arg2 = (Dali::Vector3 *)jarg2;
7635   if (!arg2) {
7636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7637     return ;
7638   }
7639   {
7640     try {
7641       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
7642     } CALL_CATCH_EXCEPTION();
7643   }
7644
7645 }
7646
7647
7648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
7649   void * jresult ;
7650   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7651   Dali::Vector4 *result = 0 ;
7652
7653   arg1 = (Dali::Matrix *)jarg1;
7654   {
7655     try {
7656       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
7657     } CALL_CATCH_EXCEPTION(0);
7658   }
7659
7660   jresult = (void *)result;
7661   return jresult;
7662 }
7663
7664
7665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
7666   void * jresult ;
7667   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7668   Dali::Vector3 *result = 0 ;
7669
7670   arg1 = (Dali::Matrix *)jarg1;
7671   {
7672     try {
7673       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
7674     } CALL_CATCH_EXCEPTION(0);
7675   }
7676
7677   jresult = (void *)result;
7678   return jresult;
7679 }
7680
7681
7682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
7683   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7684   Dali::Vector4 *arg2 = 0 ;
7685
7686   arg1 = (Dali::Matrix *)jarg1;
7687   arg2 = (Dali::Vector4 *)jarg2;
7688   if (!arg2) {
7689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7690     return ;
7691   }
7692   {
7693     try {
7694       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
7695     } CALL_CATCH_EXCEPTION();
7696   }
7697
7698 }
7699
7700
7701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
7702   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7703   Dali::Vector3 *arg2 = 0 ;
7704
7705   arg1 = (Dali::Matrix *)jarg1;
7706   arg2 = (Dali::Vector3 *)jarg2;
7707   if (!arg2) {
7708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7709     return ;
7710   }
7711   {
7712     try {
7713       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
7714     } CALL_CATCH_EXCEPTION();
7715   }
7716
7717 }
7718
7719
7720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
7721   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7722
7723   arg1 = (Dali::Matrix *)jarg1;
7724   {
7725     try {
7726       (arg1)->OrthoNormalize();
7727     } CALL_CATCH_EXCEPTION();
7728   }
7729
7730 }
7731
7732
7733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
7734   void * jresult ;
7735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7736   float *result = 0 ;
7737
7738   arg1 = (Dali::Matrix *)jarg1;
7739   {
7740     try {
7741       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
7742     } CALL_CATCH_EXCEPTION(0);
7743   }
7744
7745   jresult = (void *)result;
7746   return jresult;
7747 }
7748
7749
7750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
7751   Dali::Matrix *arg1 = 0 ;
7752   Dali::Matrix *arg2 = 0 ;
7753   Dali::Matrix *arg3 = 0 ;
7754
7755   arg1 = (Dali::Matrix *)jarg1;
7756   if (!arg1) {
7757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7758     return ;
7759   }
7760   arg2 = (Dali::Matrix *)jarg2;
7761   if (!arg2) {
7762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7763     return ;
7764   }
7765   arg3 = (Dali::Matrix *)jarg3;
7766   if (!arg3) {
7767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7768     return ;
7769   }
7770   {
7771     try {
7772       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
7773     } CALL_CATCH_EXCEPTION();
7774   }
7775
7776 }
7777
7778
7779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
7780   Dali::Matrix *arg1 = 0 ;
7781   Dali::Matrix *arg2 = 0 ;
7782   Dali::Quaternion *arg3 = 0 ;
7783
7784   arg1 = (Dali::Matrix *)jarg1;
7785   if (!arg1) {
7786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7787     return ;
7788   }
7789   arg2 = (Dali::Matrix *)jarg2;
7790   if (!arg2) {
7791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7792     return ;
7793   }
7794   arg3 = (Dali::Quaternion *)jarg3;
7795   if (!arg3) {
7796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7797     return ;
7798   }
7799   {
7800     try {
7801       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
7802     } CALL_CATCH_EXCEPTION();
7803   }
7804
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
7809   void * jresult ;
7810   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7811   Dali::Vector4 *arg2 = 0 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Matrix *)jarg1;
7815   if (!arg1) {
7816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7817     return 0;
7818   }
7819   arg2 = (Dali::Vector4 *)jarg2;
7820   if (!arg2) {
7821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7822     return 0;
7823   }
7824   {
7825     try {
7826       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7827     } CALL_CATCH_EXCEPTION(0);
7828   }
7829
7830   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7836   void * jresult ;
7837   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
7838   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
7839   Dali::Matrix result(false);
7840
7841   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7842   if (!lhsPtr) {
7843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7844     return 0;
7845   }
7846   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7847   if (!rhsPtr) {
7848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7849     return 0;
7850   }
7851   {
7852     try {
7853       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
7854     } CALL_CATCH_EXCEPTION(0);
7855   }
7856
7857   jresult = new Dali::Matrix((const Dali::Matrix &)result);
7858   return jresult;
7859 }
7860
7861
7862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
7863   // Faster mulitply operation without memcpy
7864
7865   Dali::Matrix *jresult = (Dali::Matrix *)0;
7866   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
7867   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
7868
7869   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
7870   if (!lhsPtr) {
7871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7872     return 0;
7873   }
7874   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7875   if (!rhsPtr) {
7876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7877     return 0;
7878   }
7879   {
7880     try {
7881       jresult = new Dali::Matrix(false);
7882       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
7883     } CALL_CATCH_EXCEPTION(0);
7884   }
7885
7886   return jresult;
7887 }
7888
7889
7890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
7891   void * jresult = 0;
7892   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
7893   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
7894   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
7895
7896   lhsPtr = (Dali::Matrix *)nuiMatrix;
7897   if (!lhsPtr) {
7898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
7899     return 0;
7900   }
7901   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
7902   if (!rhsPtr) {
7903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
7904     return 0;
7905   }
7906   {
7907     try {
7908       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
7909     } CALL_CATCH_EXCEPTION(0);
7910   }
7911
7912   jresult = (void *)retPtr;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
7918   bool jresult ;
7919   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7920   Dali::Matrix *arg2 = 0 ;
7921   bool result;
7922
7923   arg1 = (Dali::Matrix *)jarg1;
7924   arg2 = (Dali::Matrix *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
7932     } CALL_CATCH_EXCEPTION(0);
7933   }
7934
7935   jresult = result;
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
7941   bool jresult ;
7942   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7943   Dali::Matrix *arg2 = 0 ;
7944   bool result;
7945
7946   arg1 = (Dali::Matrix *)jarg1;
7947   arg2 = (Dali::Matrix *)jarg2;
7948   if (!arg2) {
7949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7950     return 0;
7951   }
7952   {
7953     try {
7954       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
7955     } CALL_CATCH_EXCEPTION(0);
7956   }
7957
7958   jresult = result;
7959   return jresult;
7960 }
7961
7962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
7963   float jresult ;
7964   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
7965
7966   pMatrix = (Dali::Matrix *)nuiMatrix;
7967   if (!pMatrix) {
7968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7969     return 0;
7970   }
7971   if (index >= 16) {
7972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
7973     return 0;
7974   }
7975   {
7976     try {
7977       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
7978       jresult = temp[index];
7979     } CALL_CATCH_EXCEPTION(0);
7980   }
7981   return jresult;
7982 }
7983
7984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
7985   float jresult ;
7986   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
7987
7988   pMatrix = (Dali::Matrix *)nuiMatrix;
7989   if (!pMatrix) {
7990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7991     return 0;
7992   }
7993   if (indexRow >= 4) {
7994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
7995     return 0;
7996   }
7997   if (indexColumn >= 4) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
8004       jresult = temp[(indexColumn << 2) | indexRow];
8005     } CALL_CATCH_EXCEPTION(0);
8006   }
8007   return jresult;
8008 }
8009
8010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8011   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8012
8013   pMatrix = (Dali::Matrix *)nuiMatrix;
8014   if (!pMatrix) {
8015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8016     return;
8017   }
8018   if (index >= 16) {
8019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
8020     return;
8021   }
8022   {
8023     try {
8024       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8025       temp[index] = value;
8026     } CALL_CATCH_EXCEPTION();
8027   }
8028 }
8029
8030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8031   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
8032
8033   pMatrix = (Dali::Matrix *)nuiMatrix;
8034   if (!pMatrix) {
8035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8036     return;
8037   }
8038   if (indexRow >= 4) {
8039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
8040     return;
8041   }
8042   if (indexColumn >= 4) {
8043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
8044     return;
8045   }
8046   {
8047     try {
8048       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
8049       temp[(indexColumn << 2) | indexRow] = value;
8050     } CALL_CATCH_EXCEPTION();
8051   }
8052 }
8053
8054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8055   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8056   Dali::Vector3 *arg2 = 0 ;
8057   Dali::Quaternion *arg3 = 0 ;
8058   Dali::Vector3 *arg4 = 0 ;
8059
8060   arg1 = (Dali::Matrix *)jarg1;
8061   arg2 = (Dali::Vector3 *)jarg2;
8062   if (!arg2) {
8063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8064     return ;
8065   }
8066   arg3 = (Dali::Quaternion *)jarg3;
8067   if (!arg3) {
8068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8069     return ;
8070   }
8071   arg4 = (Dali::Vector3 *)jarg4;
8072   if (!arg4) {
8073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8074     return ;
8075   }
8076   {
8077     try {
8078       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8079     } CALL_CATCH_EXCEPTION();
8080   }
8081
8082 }
8083
8084
8085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8086   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8087   Dali::Vector3 *arg2 = 0 ;
8088   Dali::Quaternion *arg3 = 0 ;
8089   Dali::Vector3 *arg4 = 0 ;
8090
8091   arg1 = (Dali::Matrix *)jarg1;
8092   arg2 = (Dali::Vector3 *)jarg2;
8093   if (!arg2) {
8094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8095     return ;
8096   }
8097   arg3 = (Dali::Quaternion *)jarg3;
8098   if (!arg3) {
8099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8100     return ;
8101   }
8102   arg4 = (Dali::Vector3 *)jarg4;
8103   if (!arg4) {
8104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8105     return ;
8106   }
8107   {
8108     try {
8109       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8110     } CALL_CATCH_EXCEPTION();
8111   }
8112
8113 }
8114
8115
8116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8117   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8118   Dali::Vector3 *arg2 = 0 ;
8119   Dali::Vector3 *arg3 = 0 ;
8120   Dali::Vector3 *arg4 = 0 ;
8121   Dali::Vector3 *arg5 = 0 ;
8122
8123   arg1 = (Dali::Matrix *)jarg1;
8124   arg2 = (Dali::Vector3 *)jarg2;
8125   if (!arg2) {
8126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8127     return ;
8128   }
8129   arg3 = (Dali::Vector3 *)jarg3;
8130   if (!arg3) {
8131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8132     return ;
8133   }
8134   arg4 = (Dali::Vector3 *)jarg4;
8135   if (!arg4) {
8136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8137     return ;
8138   }
8139   arg5 = (Dali::Vector3 *)jarg5;
8140   if (!arg5) {
8141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8142     return ;
8143   }
8144   {
8145     try {
8146       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8147     } CALL_CATCH_EXCEPTION();
8148   }
8149
8150 }
8151
8152
8153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8154   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8155   Dali::Vector3 *arg2 = 0 ;
8156   Dali::Quaternion *arg3 = 0 ;
8157   Dali::Vector3 *arg4 = 0 ;
8158
8159   arg1 = (Dali::Matrix *)jarg1;
8160   arg2 = (Dali::Vector3 *)jarg2;
8161   if (!arg2) {
8162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8163     return ;
8164   }
8165   arg3 = (Dali::Quaternion *)jarg3;
8166   if (!arg3) {
8167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8168     return ;
8169   }
8170   arg4 = (Dali::Vector3 *)jarg4;
8171   if (!arg4) {
8172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8173     return ;
8174   }
8175   {
8176     try {
8177       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8178     } CALL_CATCH_EXCEPTION();
8179   }
8180
8181 }
8182
8183
8184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
8185   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8186
8187   arg1 = (Dali::Matrix *)jarg1;
8188   {
8189     try {
8190       delete arg1;
8191     } CALL_CATCH_EXCEPTION();
8192   }
8193
8194 }
8195
8196
8197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
8198   void * jresult ;
8199   Dali::Matrix3 *result = 0 ;
8200
8201   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
8202   jresult = (void *)result;
8203   return jresult;
8204 }
8205
8206
8207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
8208   void * jresult ;
8209   Dali::Matrix3 *result = 0 ;
8210
8211   {
8212     try {
8213       result = (Dali::Matrix3 *)new Dali::Matrix3();
8214     } CALL_CATCH_EXCEPTION(0);
8215   }
8216
8217   jresult = (void *)result;
8218   return jresult;
8219 }
8220
8221
8222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
8223   void * jresult ;
8224   Dali::Matrix3 *arg1 = 0 ;
8225   Dali::Matrix3 *result = 0 ;
8226
8227   arg1 = (Dali::Matrix3 *)jarg1;
8228   if (!arg1) {
8229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8230     return 0;
8231   }
8232   {
8233     try {
8234       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
8235     } CALL_CATCH_EXCEPTION(0);
8236   }
8237
8238   jresult = (void *)result;
8239   return jresult;
8240 }
8241
8242
8243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
8244   void * jresult ;
8245   Dali::Matrix *arg1 = 0 ;
8246   Dali::Matrix3 *result = 0 ;
8247
8248   arg1 = (Dali::Matrix *)jarg1;
8249   if (!arg1) {
8250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8251     return 0;
8252   }
8253   {
8254     try {
8255       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
8256     } CALL_CATCH_EXCEPTION(0);
8257   }
8258
8259   jresult = (void *)result;
8260   return jresult;
8261 }
8262
8263
8264 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) {
8265   void * jresult ;
8266   float arg1 ;
8267   float arg2 ;
8268   float arg3 ;
8269   float arg4 ;
8270   float arg5 ;
8271   float arg6 ;
8272   float arg7 ;
8273   float arg8 ;
8274   float arg9 ;
8275   Dali::Matrix3 *result = 0 ;
8276
8277   arg1 = (float)jarg1;
8278   arg2 = (float)jarg2;
8279   arg3 = (float)jarg3;
8280   arg4 = (float)jarg4;
8281   arg5 = (float)jarg5;
8282   arg6 = (float)jarg6;
8283   arg7 = (float)jarg7;
8284   arg8 = (float)jarg8;
8285   arg9 = (float)jarg9;
8286   {
8287     try {
8288       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8289     } CALL_CATCH_EXCEPTION(0);
8290   }
8291
8292   jresult = (void *)result;
8293   return jresult;
8294 }
8295
8296
8297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
8298   void * jresult ;
8299   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8300   Dali::Matrix3 *arg2 = 0 ;
8301   Dali::Matrix3 *result = 0 ;
8302
8303   arg1 = (Dali::Matrix3 *)jarg1;
8304   arg2 = (Dali::Matrix3 *)jarg2;
8305   if (!arg2) {
8306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8307     return 0;
8308   }
8309   {
8310     try {
8311       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
8312     } CALL_CATCH_EXCEPTION(0);
8313   }
8314
8315   jresult = (void *)result;
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
8321   void * jresult ;
8322   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8323   Dali::Matrix *arg2 = 0 ;
8324   Dali::Matrix3 *result = 0 ;
8325
8326   arg1 = (Dali::Matrix3 *)jarg1;
8327   arg2 = (Dali::Matrix *)jarg2;
8328   if (!arg2) {
8329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8330     return 0;
8331   }
8332   {
8333     try {
8334       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8335     } CALL_CATCH_EXCEPTION(0);
8336   }
8337
8338   jresult = (void *)result;
8339   return jresult;
8340 }
8341
8342
8343 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
8344   bool jresult ;
8345   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8346   Dali::Matrix3 *arg2 = 0 ;
8347   bool result;
8348
8349   arg1 = (Dali::Matrix3 *)jarg1;
8350   arg2 = (Dali::Matrix3 *)jarg2;
8351   if (!arg2) {
8352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8353     return 0;
8354   }
8355   {
8356     try {
8357       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
8358     } CALL_CATCH_EXCEPTION(0);
8359   }
8360
8361   jresult = result;
8362   return jresult;
8363 }
8364
8365
8366 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
8367   bool jresult ;
8368   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8369   Dali::Matrix3 *arg2 = 0 ;
8370   bool result;
8371
8372   arg1 = (Dali::Matrix3 *)jarg1;
8373   arg2 = (Dali::Matrix3 *)jarg2;
8374   if (!arg2) {
8375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8376     return 0;
8377   }
8378   {
8379     try {
8380       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
8381     } CALL_CATCH_EXCEPTION(0);
8382   }
8383
8384   jresult = result;
8385   return jresult;
8386 }
8387
8388
8389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
8390   float jresult ;
8391   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8392
8393   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8394   if (!pMatrix) {
8395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8396     return 0;
8397   }
8398   if (index >= 9) {
8399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8400     return 0;
8401   }
8402   {
8403     try {
8404       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8405       jresult = temp[index];
8406     } CALL_CATCH_EXCEPTION(0);
8407   }
8408   return jresult;
8409 }
8410
8411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
8412   float jresult ;
8413   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8414
8415   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8416   if (!pMatrix) {
8417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8418     return 0;
8419   }
8420   if (indexRow >= 3) {
8421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8422     return 0;
8423   }
8424   if (indexColumn >= 3) {
8425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8426     return 0;
8427   }
8428   {
8429     try {
8430       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
8431       jresult = temp[indexColumn * 3 + indexRow];
8432     } CALL_CATCH_EXCEPTION(0);
8433   }
8434   return jresult;
8435 }
8436
8437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
8438   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8439
8440   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8441   if (!pMatrix) {
8442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8443     return;
8444   }
8445   if (index >= 9) {
8446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
8447     return;
8448   }
8449   {
8450     try {
8451       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8452       temp[index] = value;
8453     } CALL_CATCH_EXCEPTION();
8454   }
8455 }
8456
8457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
8458   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
8459
8460   pMatrix = (Dali::Matrix3 *)nuiMatrix;
8461   if (!pMatrix) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8463     return;
8464   }
8465   if (indexRow >= 3) {
8466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
8467     return;
8468   }
8469   if (indexColumn >= 3) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
8471     return;
8472   }
8473   {
8474     try {
8475       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
8476       temp[indexColumn * 3 + indexRow] = value;
8477     } CALL_CATCH_EXCEPTION();
8478   }
8479 }
8480
8481
8482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
8483   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8484
8485   arg1 = (Dali::Matrix3 *)jarg1;
8486   {
8487     try {
8488       delete arg1;
8489     } CALL_CATCH_EXCEPTION();
8490   }
8491
8492 }
8493
8494
8495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
8496   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8497
8498   arg1 = (Dali::Matrix3 *)jarg1;
8499   {
8500     try {
8501       (arg1)->SetIdentity();
8502     } CALL_CATCH_EXCEPTION();
8503   }
8504
8505 }
8506
8507
8508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
8509   void * jresult ;
8510   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8511   float *result = 0 ;
8512
8513   arg1 = (Dali::Matrix3 *)jarg1;
8514   {
8515     try {
8516       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
8517     } CALL_CATCH_EXCEPTION(0);
8518   }
8519
8520   jresult = (void *)result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
8526   bool jresult ;
8527   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8528   bool result;
8529
8530   arg1 = (Dali::Matrix3 *)jarg1;
8531   {
8532     try {
8533       result = (bool)(arg1)->Invert();
8534     } CALL_CATCH_EXCEPTION(0);
8535   }
8536
8537   jresult = result;
8538   return jresult;
8539 }
8540
8541
8542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
8543   bool jresult ;
8544   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8545   bool result;
8546
8547   arg1 = (Dali::Matrix3 *)jarg1;
8548   {
8549     try {
8550       result = (bool)(arg1)->Transpose();
8551     } CALL_CATCH_EXCEPTION(0);
8552   }
8553
8554   jresult = result;
8555   return jresult;
8556 }
8557
8558
8559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
8560   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8561   float arg2 ;
8562
8563   arg1 = (Dali::Matrix3 *)jarg1;
8564   arg2 = (float)jarg2;
8565   {
8566     try {
8567       (arg1)->Scale(arg2);
8568     } CALL_CATCH_EXCEPTION();
8569   }
8570
8571 }
8572
8573
8574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
8575   float jresult ;
8576   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8577   float result;
8578
8579   arg1 = (Dali::Matrix3 *)jarg1;
8580   {
8581     try {
8582       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
8583     } CALL_CATCH_EXCEPTION(0);
8584   }
8585
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
8592   bool jresult ;
8593   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8594   bool result;
8595
8596   arg1 = (Dali::Matrix3 *)jarg1;
8597   {
8598     try {
8599       result = (bool)(arg1)->ScaledInverseTranspose();
8600     } CALL_CATCH_EXCEPTION(0);
8601   }
8602
8603   jresult = result;
8604   return jresult;
8605 }
8606
8607
8608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
8609   Dali::Matrix3 *arg1 = 0 ;
8610   Dali::Matrix3 *arg2 = 0 ;
8611   Dali::Matrix3 *arg3 = 0 ;
8612
8613   arg1 = (Dali::Matrix3 *)jarg1;
8614   if (!arg1) {
8615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
8616     return ;
8617   }
8618   arg2 = (Dali::Matrix3 *)jarg2;
8619   if (!arg2) {
8620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8621     return ;
8622   }
8623   arg3 = (Dali::Matrix3 *)jarg3;
8624   if (!arg3) {
8625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8626     return ;
8627   }
8628   {
8629     try {
8630       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
8631     } CALL_CATCH_EXCEPTION();
8632   }
8633
8634 }
8635
8636
8637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
8638   void * jresult ;
8639   Dali::Matrix3 *arg1 = 0 ;
8640   Dali::Vector3 *arg2 = 0 ;
8641   Dali::Vector3 result;
8642
8643   arg1 = (Dali::Matrix3 *)jarg1;
8644   if (!arg1) {
8645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8646     return 0;
8647   }
8648   arg2 = (Dali::Vector3 *)jarg2;
8649   if (!arg2) {
8650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8651     return 0;
8652   }
8653   {
8654     try {
8655       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
8656     } CALL_CATCH_EXCEPTION(0);
8657   }
8658
8659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8660   return jresult;
8661 }
8662
8663
8664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8665   void * jresult ;
8666   Dali::Matrix3 *lhsPtr = 0 ;
8667   Dali::Matrix3 *rhsPtr = 0 ;
8668   Dali::Matrix3 result;
8669
8670   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8671   if (!lhsPtr) {
8672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8673     return 0;
8674   }
8675   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8676   if (!rhsPtr) {
8677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8678     return 0;
8679   }
8680   {
8681     try {
8682       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
8683     } CALL_CATCH_EXCEPTION(0);
8684   }
8685
8686   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
8692   // Faster mulitply operation without memcpy
8693
8694   Dali::Matrix3 *jresult = 0;
8695   Dali::Matrix3 *lhsPtr  = 0;
8696   Dali::Matrix3 *rhsPtr  = 0;
8697
8698   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
8699   if (!lhsPtr) {
8700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8701     return 0;
8702   }
8703   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
8704   if (!rhsPtr) {
8705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8706     return 0;
8707   }
8708   {
8709     try {
8710       jresult = new Dali::Matrix3();
8711       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
8712     } CALL_CATCH_EXCEPTION(0);
8713   }
8714
8715   return jresult;
8716 }
8717
8718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
8719   void * jresult = 0;
8720   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
8721   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
8722   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
8723
8724   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
8725   if (!lhsPtr) {
8726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
8727     return 0;
8728   }
8729   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
8730   if (!rhsPtr) {
8731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
8732     return 0;
8733   }
8734   {
8735     try {
8736       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
8737     } CALL_CATCH_EXCEPTION(0);
8738   }
8739
8740   jresult = (void *)retPtr;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
8746   float jresult ;
8747   float arg1 ;
8748   float arg2 ;
8749   float result;
8750
8751   arg1 = (float)jarg1;
8752   arg2 = (float)jarg2;
8753   {
8754     try {
8755       result = (float)Dali::Random::Range(arg1,arg2);
8756     } CALL_CATCH_EXCEPTION(0);
8757   }
8758
8759   jresult = result;
8760   return jresult;
8761 }
8762
8763
8764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
8765   void * jresult ;
8766   Dali::Vector4 result;
8767
8768   {
8769     try {
8770       result = Dali::Random::Axis();
8771     } CALL_CATCH_EXCEPTION(0);
8772   }
8773
8774   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8775   return jresult;
8776 }
8777
8778
8779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
8780   void * jresult ;
8781   Dali::AngleAxis *result = 0 ;
8782
8783   {
8784     try {
8785       result = (Dali::AngleAxis *)new Dali::AngleAxis();
8786     } CALL_CATCH_EXCEPTION(0);
8787   }
8788
8789   jresult = (void *)result;
8790   return jresult;
8791 }
8792
8793
8794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
8795   void * jresult ;
8796   Dali::Radian arg1 ;
8797   Dali::Vector3 *arg2 = 0 ;
8798   Dali::Radian *argp1 ;
8799   Dali::AngleAxis *result = 0 ;
8800
8801   argp1 = (Dali::Radian *)jarg1;
8802   if (!argp1) {
8803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8804     return 0;
8805   }
8806   arg1 = *argp1;
8807   arg2 = (Dali::Vector3 *)jarg2;
8808   if (!arg2) {
8809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8810     return 0;
8811   }
8812   {
8813     try {
8814       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
8815     } CALL_CATCH_EXCEPTION(0);
8816   }
8817
8818   jresult = (void *)result;
8819   return jresult;
8820 }
8821
8822
8823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
8824   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8825   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
8826
8827   arg1 = (Dali::AngleAxis *)jarg1;
8828   arg2 = (Dali::Radian *)jarg2;
8829   if (arg1) (arg1)->angle = *arg2;
8830 }
8831
8832
8833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
8834   void * jresult ;
8835   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8836   Dali::Radian *result = 0 ;
8837
8838   arg1 = (Dali::AngleAxis *)jarg1;
8839   result = (Dali::Radian *)& ((arg1)->angle);
8840   jresult = (void *)result;
8841   return jresult;
8842 }
8843
8844
8845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
8846   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8847   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
8848
8849   arg1 = (Dali::AngleAxis *)jarg1;
8850   arg2 = (Dali::Vector3 *)jarg2;
8851   if (arg1) (arg1)->axis = *arg2;
8852 }
8853
8854
8855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
8856   void * jresult ;
8857   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8858   Dali::Vector3 *result = 0 ;
8859
8860   arg1 = (Dali::AngleAxis *)jarg1;
8861   result = (Dali::Vector3 *)& ((arg1)->axis);
8862   jresult = (void *)result;
8863   return jresult;
8864 }
8865
8866
8867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
8868   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8869
8870   arg1 = (Dali::AngleAxis *)jarg1;
8871   {
8872     try {
8873       delete arg1;
8874     } CALL_CATCH_EXCEPTION();
8875   }
8876
8877 }
8878
8879
8880 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
8881   bool jresult ;
8882   Dali::AngleAxis *arg1 = 0 ;
8883   Dali::AngleAxis *arg2 = 0 ;
8884   bool result;
8885
8886   arg1 = (Dali::AngleAxis *)jarg1;
8887   if (!arg1) {
8888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
8889     return 0;
8890   }
8891   arg2 = (Dali::AngleAxis *)jarg2;
8892   if (!arg2) {
8893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
8894     return 0;
8895   }
8896   {
8897     try {
8898       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
8899     } CALL_CATCH_EXCEPTION(0);
8900   }
8901
8902   jresult = result;
8903   return jresult;
8904 }
8905
8906
8907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
8908   unsigned int jresult ;
8909   unsigned int arg1 ;
8910   unsigned int result;
8911
8912   arg1 = (unsigned int)jarg1;
8913   {
8914     try {
8915       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
8916     } CALL_CATCH_EXCEPTION(0);
8917   }
8918
8919   jresult = result;
8920   return jresult;
8921 }
8922
8923
8924 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
8925   bool jresult ;
8926   unsigned int arg1 ;
8927   bool result;
8928
8929   arg1 = (unsigned int)jarg1;
8930   {
8931     try {
8932       result = (bool)Dali::IsPowerOfTwo(arg1);
8933     } CALL_CATCH_EXCEPTION(0);
8934   }
8935
8936   jresult = result;
8937   return jresult;
8938 }
8939
8940
8941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
8942   float jresult ;
8943   float arg1 ;
8944   float arg2 ;
8945   float result;
8946
8947   arg1 = (float)jarg1;
8948   arg2 = (float)jarg2;
8949   {
8950     try {
8951       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
8952     } CALL_CATCH_EXCEPTION(0);
8953   }
8954
8955   jresult = result;
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
8961   bool jresult ;
8962   float arg1 ;
8963   bool result;
8964
8965   arg1 = (float)jarg1;
8966   {
8967     try {
8968       result = (bool)Dali::EqualsZero(arg1);
8969     } CALL_CATCH_EXCEPTION(0);
8970   }
8971
8972   jresult = result;
8973   return jresult;
8974 }
8975
8976
8977 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
8978   bool jresult ;
8979   float arg1 ;
8980   float arg2 ;
8981   bool result;
8982
8983   arg1 = (float)jarg1;
8984   arg2 = (float)jarg2;
8985   {
8986     try {
8987       result = (bool)Dali::Equals(arg1,arg2);
8988     } CALL_CATCH_EXCEPTION(0);
8989   }
8990
8991   jresult = result;
8992   return jresult;
8993 }
8994
8995
8996 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
8997   bool jresult ;
8998   float arg1 ;
8999   float arg2 ;
9000   float arg3 ;
9001   bool result;
9002
9003   arg1 = (float)jarg1;
9004   arg2 = (float)jarg2;
9005   arg3 = (float)jarg3;
9006   {
9007     try {
9008       result = (bool)Dali::Equals(arg1,arg2,arg3);
9009     } CALL_CATCH_EXCEPTION(0);
9010   }
9011
9012   jresult = result;
9013   return jresult;
9014 }
9015
9016
9017 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9018   float jresult ;
9019   float arg1 ;
9020   int arg2 ;
9021   float result;
9022
9023   arg1 = (float)jarg1;
9024   arg2 = (int)jarg2;
9025   {
9026     try {
9027       result = (float)Dali::Round(arg1,arg2);
9028     } CALL_CATCH_EXCEPTION(0);
9029   }
9030
9031   jresult = result;
9032   return jresult;
9033 }
9034
9035
9036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9037   float jresult ;
9038   float arg1 ;
9039   float arg2 ;
9040   float arg3 ;
9041   float result;
9042
9043   arg1 = (float)jarg1;
9044   arg2 = (float)jarg2;
9045   arg3 = (float)jarg3;
9046   {
9047     try {
9048       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9049     } CALL_CATCH_EXCEPTION(0);
9050   }
9051
9052   jresult = result;
9053   return jresult;
9054 }
9055
9056
9057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9058   float jresult ;
9059   float arg1 ;
9060   float arg2 ;
9061   float arg3 ;
9062   float arg4 ;
9063   float result;
9064
9065   arg1 = (float)jarg1;
9066   arg2 = (float)jarg2;
9067   arg3 = (float)jarg3;
9068   arg4 = (float)jarg4;
9069   {
9070     try {
9071       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9072     } CALL_CATCH_EXCEPTION(0);
9073   }
9074
9075   jresult = result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9081   int jresult ;
9082   int result;
9083
9084   result = (int)(int)Dali::Property::INVALID_INDEX;
9085   jresult = result;
9086   return jresult;
9087 }
9088
9089
9090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9091   int jresult ;
9092   int result;
9093
9094   result = (int)(int)Dali::Property::INVALID_KEY;
9095   jresult = result;
9096   return jresult;
9097 }
9098
9099
9100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9101   int jresult ;
9102   int result;
9103
9104   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9105   jresult = result;
9106   return jresult;
9107 }
9108
9109
9110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9111   void * jresult ;
9112   Dali::Handle *arg1 = 0 ;
9113   Dali::Property::Index arg2 ;
9114   Dali::Property *result = 0 ;
9115
9116   arg1 = (Dali::Handle *)jarg1;
9117   if (!arg1) {
9118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9119     return 0;
9120   }
9121   arg2 = (Dali::Property::Index)jarg2;
9122   {
9123     try {
9124       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9125     } CALL_CATCH_EXCEPTION(0);
9126   }
9127
9128   jresult = (void *)result;
9129   return jresult;
9130 }
9131
9132
9133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9134   void * jresult ;
9135   Dali::Handle *arg1 = 0 ;
9136   Dali::Property::Index arg2 ;
9137   int arg3 ;
9138   Dali::Property *result = 0 ;
9139
9140   arg1 = (Dali::Handle *)jarg1;
9141   if (!arg1) {
9142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9143     return 0;
9144   }
9145   arg2 = (Dali::Property::Index)jarg2;
9146   arg3 = (int)jarg3;
9147   {
9148     try {
9149       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9150     } CALL_CATCH_EXCEPTION(0);
9151   }
9152
9153   jresult = (void *)result;
9154   return jresult;
9155 }
9156
9157
9158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9159   void * jresult ;
9160   Dali::Handle *arg1 = 0 ;
9161   std::string *arg2 = 0 ;
9162   Dali::Property *result = 0 ;
9163
9164   arg1 = (Dali::Handle *)jarg1;
9165   if (!arg1) {
9166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9167     return 0;
9168   }
9169   if (!jarg2) {
9170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9171     return 0;
9172   }
9173   std::string arg2_str(jarg2);
9174   arg2 = &arg2_str;
9175   {
9176     try {
9177       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9178     } CALL_CATCH_EXCEPTION(0);
9179   }
9180
9181   jresult = (void *)result;
9182
9183   //argout typemap for const std::string&
9184
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9190   void * jresult ;
9191   Dali::Handle *arg1 = 0 ;
9192   std::string *arg2 = 0 ;
9193   int arg3 ;
9194   Dali::Property *result = 0 ;
9195
9196   arg1 = (Dali::Handle *)jarg1;
9197   if (!arg1) {
9198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9199     return 0;
9200   }
9201   if (!jarg2) {
9202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9203     return 0;
9204   }
9205   std::string arg2_str(jarg2);
9206   arg2 = &arg2_str;
9207   arg3 = (int)jarg3;
9208   {
9209     try {
9210       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9211     } CALL_CATCH_EXCEPTION(0);
9212   }
9213
9214   jresult = (void *)result;
9215
9216   //argout typemap for const std::string&
9217
9218   return jresult;
9219 }
9220
9221
9222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9223   Dali::Property *arg1 = (Dali::Property *) 0 ;
9224
9225   arg1 = (Dali::Property *)jarg1;
9226   {
9227     try {
9228       delete arg1;
9229     } CALL_CATCH_EXCEPTION();
9230   }
9231
9232 }
9233
9234
9235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9236   Dali::Property *arg1 = (Dali::Property *) 0 ;
9237   Dali::Handle *arg2 = 0 ;
9238
9239   arg1 = (Dali::Property *)jarg1;
9240   arg2 = (Dali::Handle *)jarg2;
9241   if (!arg2) {
9242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9243     return ;
9244   }
9245   if (arg1) (arg1)->object = *arg2;
9246 }
9247
9248
9249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9250   void * jresult ;
9251   Dali::Property *arg1 = (Dali::Property *) 0 ;
9252   Dali::Handle *result = 0 ;
9253
9254   arg1 = (Dali::Property *)jarg1;
9255   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9256   jresult = (void *)result;
9257   return jresult;
9258 }
9259
9260
9261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9262   Dali::Property *arg1 = (Dali::Property *) 0 ;
9263   Dali::Property::Index arg2 ;
9264
9265   arg1 = (Dali::Property *)jarg1;
9266   arg2 = (Dali::Property::Index)jarg2;
9267   if (arg1) (arg1)->propertyIndex = arg2;
9268 }
9269
9270
9271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9272   int jresult ;
9273   Dali::Property *arg1 = (Dali::Property *) 0 ;
9274   Dali::Property::Index result;
9275
9276   arg1 = (Dali::Property *)jarg1;
9277   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9278   jresult = result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9284   Dali::Property *arg1 = (Dali::Property *) 0 ;
9285   int arg2 ;
9286
9287   arg1 = (Dali::Property *)jarg1;
9288   arg2 = (int)jarg2;
9289   if (arg1) (arg1)->componentIndex = arg2;
9290 }
9291
9292
9293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9294   int jresult ;
9295   Dali::Property *arg1 = (Dali::Property *) 0 ;
9296   int result;
9297
9298   arg1 = (Dali::Property *)jarg1;
9299   result = (int) ((arg1)->componentIndex);
9300   jresult = result;
9301   return jresult;
9302 }
9303
9304
9305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9306   void * jresult ;
9307   Dali::Property::Array *result = 0 ;
9308
9309   {
9310     try {
9311       result = (Dali::Property::Array *)new Dali::Property::Array();
9312     } CALL_CATCH_EXCEPTION(0);
9313   }
9314
9315   jresult = (void *)result;
9316   return jresult;
9317 }
9318
9319
9320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9321   void * jresult ;
9322   Dali::Property::Array *arg1 = 0 ;
9323   Dali::Property::Array *result = 0 ;
9324
9325   arg1 = (Dali::Property::Array *)jarg1;
9326   if (!arg1) {
9327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9328     return 0;
9329   }
9330   {
9331     try {
9332       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9333     } CALL_CATCH_EXCEPTION(0);
9334   }
9335
9336   jresult = (void *)result;
9337   return jresult;
9338 }
9339
9340
9341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9342   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9343
9344   arg1 = (Dali::Property::Array *)jarg1;
9345   {
9346     try {
9347       delete arg1;
9348     } CALL_CATCH_EXCEPTION();
9349   }
9350
9351 }
9352
9353
9354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9355   unsigned long jresult ;
9356   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9357   Dali::Property::Array::SizeType result;
9358
9359   arg1 = (Dali::Property::Array *)jarg1;
9360   {
9361     try {
9362       result = ((Dali::Property::Array const *)arg1)->Size();
9363     } CALL_CATCH_EXCEPTION(0);
9364   }
9365
9366   jresult = (unsigned long)result;
9367   return jresult;
9368 }
9369
9370
9371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9372   unsigned long jresult ;
9373   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9374   Dali::Property::Array::SizeType result;
9375
9376   arg1 = (Dali::Property::Array *)jarg1;
9377   {
9378     try {
9379       result = ((Dali::Property::Array const *)arg1)->Count();
9380     } CALL_CATCH_EXCEPTION(0);
9381   }
9382
9383   jresult = (unsigned long)result;
9384   return jresult;
9385 }
9386
9387
9388 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
9389   bool jresult ;
9390   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9391   bool result;
9392
9393   arg1 = (Dali::Property::Array *)jarg1;
9394   {
9395     try {
9396       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
9397     } CALL_CATCH_EXCEPTION(0);
9398   }
9399
9400   jresult = result;
9401   return jresult;
9402 }
9403
9404
9405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
9406   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9407
9408   arg1 = (Dali::Property::Array *)jarg1;
9409   {
9410     try {
9411       (arg1)->Clear();
9412     } CALL_CATCH_EXCEPTION();
9413   }
9414
9415 }
9416
9417
9418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
9419   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9420   Dali::Property::Array::SizeType arg2 ;
9421
9422   arg1 = (Dali::Property::Array *)jarg1;
9423   arg2 = (Dali::Property::Array::SizeType)jarg2;
9424   {
9425     try {
9426       (arg1)->Reserve(arg2);
9427     } CALL_CATCH_EXCEPTION();
9428   }
9429
9430 }
9431
9432
9433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
9434   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9435   Dali::Property::Array::SizeType arg2 ;
9436
9437   arg1 = (Dali::Property::Array *)jarg1;
9438   arg2 = (Dali::Property::Array::SizeType)jarg2;
9439   {
9440     try {
9441       (arg1)->Resize(arg2);
9442     } CALL_CATCH_EXCEPTION();
9443   }
9444
9445 }
9446
9447
9448 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
9449   unsigned long jresult ;
9450   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9451   Dali::Property::Array::SizeType result;
9452
9453   arg1 = (Dali::Property::Array *)jarg1;
9454   {
9455     try {
9456       result = (arg1)->Capacity();
9457     } CALL_CATCH_EXCEPTION(0);
9458   }
9459
9460   jresult = (unsigned long)result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
9466   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9467   Dali::Property::Value *arg2 = 0 ;
9468
9469   arg1 = (Dali::Property::Array *)jarg1;
9470   arg2 = (Dali::Property::Value *)jarg2;
9471   if (!arg2) {
9472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9473     return ;
9474   }
9475   {
9476     try {
9477       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
9478     } CALL_CATCH_EXCEPTION();
9479   }
9480
9481 }
9482
9483
9484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
9485   void * jresult ;
9486   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9487   Dali::Property::Value *arg2 = 0 ;
9488   Dali::Property::Array *result = 0 ;
9489
9490   arg1 = (Dali::Property::Array *)jarg1;
9491   arg2 = (Dali::Property::Value *)jarg2;
9492   if (!arg2) {
9493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9494     return 0;
9495   }
9496   {
9497     try {
9498       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
9499     } CALL_CATCH_EXCEPTION(0);
9500   }
9501
9502   jresult = (void *)result;
9503   return jresult;
9504 }
9505
9506
9507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
9508   void * jresult ;
9509   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9510   Dali::Property::Array::SizeType arg2 ;
9511   Dali::Property::Value *result = 0 ;
9512
9513   arg1 = (Dali::Property::Array *)jarg1;
9514   arg2 = (Dali::Property::Array::SizeType)jarg2;
9515   {
9516     try {
9517       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
9518     } CALL_CATCH_EXCEPTION(0);
9519   }
9520
9521   jresult = (void *)result;
9522   return jresult;
9523 }
9524
9525
9526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
9527   void * jresult ;
9528   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9529   Dali::Property::Array::SizeType arg2 ;
9530   Dali::Property::Value *result = 0 ;
9531
9532   arg1 = (Dali::Property::Array *)jarg1;
9533   arg2 = (Dali::Property::Array::SizeType)jarg2;
9534   {
9535     try {
9536       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
9537     } CALL_CATCH_EXCEPTION(0);
9538   }
9539
9540   jresult = (void *)result;
9541   return jresult;
9542 }
9543
9544
9545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
9546   void * jresult ;
9547   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9548   Dali::Property::Array *arg2 = 0 ;
9549   Dali::Property::Array *result = 0 ;
9550
9551   arg1 = (Dali::Property::Array *)jarg1;
9552   arg2 = (Dali::Property::Array *)jarg2;
9553   if (!arg2) {
9554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9555     return 0;
9556   }
9557   {
9558     try {
9559       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
9560     } CALL_CATCH_EXCEPTION(0);
9561   }
9562
9563   jresult = (void *)result;
9564   return jresult;
9565 }
9566
9567
9568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
9569   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9570   enum Dali::Property::Key::Type arg2 ;
9571
9572   arg1 = (Dali::Property::Key *)jarg1;
9573   arg2 = (enum Dali::Property::Key::Type)jarg2;
9574   if (arg1) (arg1)->type = arg2;
9575 }
9576
9577
9578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
9579   int jresult ;
9580   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9581   enum Dali::Property::Key::Type result;
9582
9583   arg1 = (Dali::Property::Key *)jarg1;
9584   result = (enum Dali::Property::Key::Type) ((arg1)->type);
9585   jresult = (int)result;
9586   return jresult;
9587 }
9588
9589
9590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
9591   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9592   Dali::Property::Index arg2 ;
9593
9594   arg1 = (Dali::Property::Key *)jarg1;
9595   arg2 = (Dali::Property::Index)jarg2;
9596   if (arg1) (arg1)->indexKey = arg2;
9597 }
9598
9599
9600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
9601   int jresult ;
9602   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9603   Dali::Property::Index result;
9604
9605   arg1 = (Dali::Property::Key *)jarg1;
9606   result = (Dali::Property::Index) ((arg1)->indexKey);
9607   jresult = result;
9608   return jresult;
9609 }
9610
9611
9612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
9613   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9614   std::string *arg2 = 0 ;
9615
9616   arg1 = (Dali::Property::Key *)jarg1;
9617   if (!jarg2) {
9618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9619     return ;
9620   }
9621   std::string arg2_str(jarg2);
9622   arg2 = &arg2_str;
9623   if (arg1) (arg1)->stringKey = *arg2;
9624
9625   //argout typemap for const std::string&
9626
9627 }
9628
9629
9630 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
9631   char * jresult ;
9632   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9633   std::string *result = 0 ;
9634
9635   arg1 = (Dali::Property::Key *)jarg1;
9636   result = (std::string *) & ((arg1)->stringKey);
9637   jresult = SWIG_csharp_string_callback(result->c_str());
9638   return jresult;
9639 }
9640
9641
9642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
9643   void * jresult ;
9644   std::string *arg1 = 0 ;
9645   Dali::Property::Key *result = 0 ;
9646
9647   if (!jarg1) {
9648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9649     return 0;
9650   }
9651   std::string arg1_str(jarg1);
9652   arg1 = &arg1_str;
9653   {
9654     try {
9655       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
9656     } CALL_CATCH_EXCEPTION(0);
9657   }
9658
9659   jresult = (void *)result;
9660
9661   //argout typemap for const std::string&
9662
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
9668   void * jresult ;
9669   Dali::Property::Index arg1 ;
9670   Dali::Property::Key *result = 0 ;
9671
9672   arg1 = (Dali::Property::Index)jarg1;
9673   {
9674     try {
9675       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
9676     } CALL_CATCH_EXCEPTION(0);
9677   }
9678
9679   jresult = (void *)result;
9680   return jresult;
9681 }
9682
9683
9684 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
9685   bool jresult ;
9686   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9687   std::string *arg2 = 0 ;
9688   bool result;
9689
9690   arg1 = (Dali::Property::Key *)jarg1;
9691   if (!jarg2) {
9692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9693     return 0;
9694   }
9695   std::string arg2_str(jarg2);
9696   arg2 = &arg2_str;
9697   {
9698     try {
9699       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
9700     } CALL_CATCH_EXCEPTION(0);
9701   }
9702
9703   jresult = result;
9704
9705   //argout typemap for const std::string&
9706
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
9712   bool jresult ;
9713   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9714   Dali::Property::Index arg2 ;
9715   bool result;
9716
9717   arg1 = (Dali::Property::Key *)jarg1;
9718   arg2 = (Dali::Property::Index)jarg2;
9719   {
9720     try {
9721       result = (bool)(arg1)->operator ==(arg2);
9722     } CALL_CATCH_EXCEPTION(0);
9723   }
9724
9725   jresult = result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
9731   bool jresult ;
9732   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9733   Dali::Property::Key *arg2 = 0 ;
9734   bool result;
9735
9736   arg1 = (Dali::Property::Key *)jarg1;
9737   arg2 = (Dali::Property::Key *)jarg2;
9738   if (!arg2) {
9739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9740     return 0;
9741   }
9742   {
9743     try {
9744       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
9745     } CALL_CATCH_EXCEPTION(0);
9746   }
9747
9748   jresult = result;
9749   return jresult;
9750 }
9751
9752
9753 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
9754   bool jresult ;
9755   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9756   std::string *arg2 = 0 ;
9757   bool result;
9758
9759   arg1 = (Dali::Property::Key *)jarg1;
9760   if (!jarg2) {
9761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9762     return 0;
9763   }
9764   std::string arg2_str(jarg2);
9765   arg2 = &arg2_str;
9766   {
9767     try {
9768       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
9769     } CALL_CATCH_EXCEPTION(0);
9770   }
9771
9772   jresult = result;
9773
9774   //argout typemap for const std::string&
9775
9776   return jresult;
9777 }
9778
9779
9780 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
9781   bool jresult ;
9782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9783   Dali::Property::Index arg2 ;
9784   bool result;
9785
9786   arg1 = (Dali::Property::Key *)jarg1;
9787   arg2 = (Dali::Property::Index)jarg2;
9788   {
9789     try {
9790       result = (bool)(arg1)->operator !=(arg2);
9791     } CALL_CATCH_EXCEPTION(0);
9792   }
9793
9794   jresult = result;
9795   return jresult;
9796 }
9797
9798
9799 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
9800   bool jresult ;
9801   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9802   Dali::Property::Key *arg2 = 0 ;
9803   bool result;
9804
9805   arg1 = (Dali::Property::Key *)jarg1;
9806   arg2 = (Dali::Property::Key *)jarg2;
9807   if (!arg2) {
9808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9809     return 0;
9810   }
9811   {
9812     try {
9813       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
9814     } CALL_CATCH_EXCEPTION(0);
9815   }
9816
9817   jresult = result;
9818   return jresult;
9819 }
9820
9821
9822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
9823   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9824
9825   arg1 = (Dali::Property::Key *)jarg1;
9826   {
9827     try {
9828       delete arg1;
9829     } CALL_CATCH_EXCEPTION();
9830   }
9831
9832 }
9833
9834
9835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
9836   void * jresult ;
9837   Dali::Property::Map *result = 0 ;
9838
9839   {
9840     try {
9841       result = (Dali::Property::Map *)new Dali::Property::Map();
9842     } CALL_CATCH_EXCEPTION(0);
9843   }
9844
9845   jresult = (void *)result;
9846   return jresult;
9847 }
9848
9849
9850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
9851   void * jresult ;
9852   Dali::Property::Map *arg1 = 0 ;
9853   Dali::Property::Map *result = 0 ;
9854
9855   arg1 = (Dali::Property::Map *)jarg1;
9856   if (!arg1) {
9857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
9858     return 0;
9859   }
9860   {
9861     try {
9862       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
9863     } CALL_CATCH_EXCEPTION(0);
9864   }
9865
9866   jresult = (void *)result;
9867   return jresult;
9868 }
9869
9870
9871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
9872   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9873
9874   arg1 = (Dali::Property::Map *)jarg1;
9875   {
9876     try {
9877       delete arg1;
9878     } CALL_CATCH_EXCEPTION();
9879   }
9880
9881 }
9882
9883
9884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
9885   unsigned long jresult ;
9886   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9887   Dali::Property::Map::SizeType result;
9888
9889   arg1 = (Dali::Property::Map *)jarg1;
9890   {
9891     try {
9892       result = ((Dali::Property::Map const *)arg1)->Count();
9893     } CALL_CATCH_EXCEPTION(0);
9894   }
9895
9896   jresult = (unsigned long)result;
9897   return jresult;
9898 }
9899
9900
9901 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
9902   bool jresult ;
9903   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9904   bool result;
9905
9906   arg1 = (Dali::Property::Map *)jarg1;
9907   {
9908     try {
9909       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
9910     } CALL_CATCH_EXCEPTION(0);
9911   }
9912
9913   jresult = result;
9914   return jresult;
9915 }
9916
9917
9918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9919   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9920   char *arg2 = (char *) 0 ;
9921   Dali::Property::Value *arg3 = 0 ;
9922
9923   arg1 = (Dali::Property::Map *)jarg1;
9924   arg2 = (char *)jarg2;
9925   arg3 = (Dali::Property::Value *)jarg3;
9926   if (!arg3) {
9927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9928     return ;
9929   }
9930   {
9931     try {
9932       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
9933     } CALL_CATCH_EXCEPTION();
9934   }
9935
9936 }
9937
9938
9939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
9940   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9941   Dali::Property::Index arg2 ;
9942   Dali::Property::Value *arg3 = 0 ;
9943
9944   arg1 = (Dali::Property::Map *)jarg1;
9945   arg2 = (Dali::Property::Index)jarg2;
9946   arg3 = (Dali::Property::Value *)jarg3;
9947   if (!arg3) {
9948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9949     return ;
9950   }
9951   {
9952     try {
9953       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
9954     } CALL_CATCH_EXCEPTION();
9955   }
9956
9957 }
9958
9959
9960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9961   void * jresult ;
9962   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9963   char *arg2 = (char *) 0 ;
9964   Dali::Property::Value *arg3 = 0 ;
9965   Dali::Property::Map *result = 0 ;
9966
9967   arg1 = (Dali::Property::Map *)jarg1;
9968   arg2 = (char *)jarg2;
9969   arg3 = (Dali::Property::Value *)jarg3;
9970   if (!arg3) {
9971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9972     return 0;
9973   }
9974   {
9975     try {
9976       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
9977     } CALL_CATCH_EXCEPTION(0);
9978   }
9979
9980   jresult = (void *)result;
9981   return jresult;
9982 }
9983
9984
9985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
9986   void * jresult ;
9987   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9988   Dali::Property::Index arg2 ;
9989   Dali::Property::Value *arg3 = 0 ;
9990   Dali::Property::Map *result = 0 ;
9991
9992   arg1 = (Dali::Property::Map *)jarg1;
9993   arg2 = (Dali::Property::Index)jarg2;
9994   arg3 = (Dali::Property::Value *)jarg3;
9995   if (!arg3) {
9996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9997     return 0;
9998   }
9999   {
10000     try {
10001       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10002     } CALL_CATCH_EXCEPTION(0);
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10011   void * jresult ;
10012   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10013   Dali::Property::Map::SizeType arg2 ;
10014   Dali::Property::Value *result = 0 ;
10015
10016   arg1 = (Dali::Property::Map *)jarg1;
10017   arg2 = (Dali::Property::Map::SizeType)jarg2;
10018   {
10019     try {
10020       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10021     } CALL_CATCH_EXCEPTION(0);
10022   }
10023
10024   jresult = (void *)result;
10025   return jresult;
10026 }
10027
10028
10029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10030   char * jresult ;
10031   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10032   Dali::Property::Map::SizeType arg2 ;
10033   std::string *result = 0 ;
10034
10035   arg1 = (Dali::Property::Map *)jarg1;
10036   arg2 = (Dali::Property::Map::SizeType)jarg2;
10037   {
10038     try {
10039       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10040     } CALL_CATCH_EXCEPTION(0);
10041   }
10042
10043   jresult = SWIG_csharp_string_callback(result->c_str());
10044   return jresult;
10045 }
10046
10047
10048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10049   void * jresult ;
10050   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10051   Dali::Property::Map::SizeType arg2 ;
10052   SwigValueWrapper< Dali::Property::Key > result;
10053
10054   arg1 = (Dali::Property::Map *)jarg1;
10055   arg2 = (Dali::Property::Map::SizeType)jarg2;
10056   {
10057     try {
10058       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10059     } CALL_CATCH_EXCEPTION(0);
10060   }
10061
10062   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10063   return jresult;
10064 }
10065
10066
10067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10068   void * jresult ;
10069   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10070   Dali::Property::Map::SizeType arg2 ;
10071   StringValuePair *result = 0 ;
10072
10073   arg1 = (Dali::Property::Map *)jarg1;
10074   arg2 = (Dali::Property::Map::SizeType)jarg2;
10075   {
10076     try {
10077       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10078     } CALL_CATCH_EXCEPTION(0);
10079   }
10080
10081   jresult = (void *)result;
10082   return jresult;
10083 }
10084
10085
10086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10087   void * jresult ;
10088   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10089   char *arg2 = (char *) 0 ;
10090   Dali::Property::Value *result = 0 ;
10091
10092   arg1 = (Dali::Property::Map *)jarg1;
10093   arg2 = (char *)jarg2;
10094   {
10095     try {
10096       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10097     } CALL_CATCH_EXCEPTION(0);
10098   }
10099
10100   jresult = (void *)result;
10101   return jresult;
10102 }
10103
10104
10105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10106   void * jresult ;
10107   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10108   Dali::Property::Index arg2 ;
10109   Dali::Property::Value *result = 0 ;
10110
10111   arg1 = (Dali::Property::Map *)jarg1;
10112   arg2 = (Dali::Property::Index)jarg2;
10113   {
10114     try {
10115       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10116     } CALL_CATCH_EXCEPTION(0);
10117   }
10118
10119   jresult = (void *)result;
10120   return jresult;
10121 }
10122
10123
10124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10125   void * jresult ;
10126   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10127   Dali::Property::Index arg2 ;
10128   std::string *arg3 = 0 ;
10129   Dali::Property::Value *result = 0 ;
10130
10131   arg1 = (Dali::Property::Map *)jarg1;
10132   arg2 = (Dali::Property::Index)jarg2;
10133   if (!jarg3) {
10134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10135     return 0;
10136   }
10137   std::string arg3_str(jarg3);
10138   arg3 = &arg3_str;
10139   {
10140     try {
10141       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10142     } CALL_CATCH_EXCEPTION(0);
10143   }
10144
10145   jresult = (void *)result;
10146
10147   //argout typemap for const std::string&
10148
10149   return jresult;
10150 }
10151
10152
10153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10154   void * jresult ;
10155   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10156   std::string *arg2 = 0 ;
10157   Dali::Property::Type arg3 ;
10158   Dali::Property::Value *result = 0 ;
10159
10160   arg1 = (Dali::Property::Map *)jarg1;
10161   if (!jarg2) {
10162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10163     return 0;
10164   }
10165   std::string arg2_str(jarg2);
10166   arg2 = &arg2_str;
10167   arg3 = (Dali::Property::Type)jarg3;
10168   {
10169     try {
10170       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10171     } CALL_CATCH_EXCEPTION(0);
10172   }
10173
10174   jresult = (void *)result;
10175
10176   //argout typemap for const std::string&
10177
10178   return jresult;
10179 }
10180
10181
10182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10183   void * jresult ;
10184   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10185   Dali::Property::Index arg2 ;
10186   Dali::Property::Type arg3 ;
10187   Dali::Property::Value *result = 0 ;
10188
10189   arg1 = (Dali::Property::Map *)jarg1;
10190   arg2 = (Dali::Property::Index)jarg2;
10191   arg3 = (Dali::Property::Type)jarg3;
10192   {
10193     try {
10194       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10195     } CALL_CATCH_EXCEPTION(0);
10196   }
10197
10198   jresult = (void *)result;
10199   return jresult;
10200 }
10201
10202
10203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10204   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10205
10206   arg1 = (Dali::Property::Map *)jarg1;
10207   {
10208     try {
10209       (arg1)->Clear();
10210     } CALL_CATCH_EXCEPTION();
10211   }
10212
10213 }
10214
10215
10216 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
10217   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10218   Dali::Property::Index intKey = (Dali::Property::Index)key;
10219   bool isRemoved = false;
10220   {
10221     try {
10222       isRemoved = propertyMap->Remove(intKey);
10223     } CALL_CATCH_EXCEPTION(0);
10224   }
10225   return isRemoved;
10226 }
10227
10228
10229 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
10230   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10231   std::string strKey(key);
10232   bool isRemoved = false;
10233   {
10234     try {
10235       isRemoved = propertyMap->Remove(strKey);
10236     } CALL_CATCH_EXCEPTION(0);
10237   }
10238   return isRemoved;
10239 }
10240
10241
10242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10243   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10244   Dali::Property::Map *arg2 = 0 ;
10245
10246   arg1 = (Dali::Property::Map *)jarg1;
10247   arg2 = (Dali::Property::Map *)jarg2;
10248   if (!arg2) {
10249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10250     return ;
10251   }
10252   {
10253     try {
10254       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10255     } CALL_CATCH_EXCEPTION();
10256   }
10257
10258 }
10259
10260
10261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10262   void * jresult ;
10263   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10264   std::string *arg2 = 0 ;
10265   Dali::Property::Value *result = 0 ;
10266
10267   arg1 = (Dali::Property::Map *)jarg1;
10268   if (!jarg2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10270     return 0;
10271   }
10272   std::string arg2_str(jarg2);
10273   arg2 = &arg2_str;
10274   {
10275     try {
10276       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10277     } CALL_CATCH_EXCEPTION(0);
10278   }
10279
10280   jresult = (void *)result;
10281
10282   //argout typemap for const std::string&
10283
10284   return jresult;
10285 }
10286
10287
10288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10289   void * jresult ;
10290   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10291   Dali::Property::Index arg2 ;
10292   Dali::Property::Value *result = 0 ;
10293
10294   arg1 = (Dali::Property::Map *)jarg1;
10295   arg2 = (Dali::Property::Index)jarg2;
10296   {
10297     try {
10298       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10299     } CALL_CATCH_EXCEPTION(0);
10300   }
10301
10302   jresult = (void *)result;
10303   return jresult;
10304 }
10305
10306
10307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10308   void * jresult ;
10309   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10310   Dali::Property::Map *arg2 = 0 ;
10311   Dali::Property::Map *result = 0 ;
10312
10313   arg1 = (Dali::Property::Map *)jarg1;
10314   arg2 = (Dali::Property::Map *)jarg2;
10315   if (!arg2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10317     return 0;
10318   }
10319   {
10320     try {
10321       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10322     } CALL_CATCH_EXCEPTION(0);
10323   }
10324
10325   jresult = (void *)result;
10326   return jresult;
10327 }
10328
10329
10330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10331
10332   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10333
10334   if (!jarg2) {
10335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10336     return;
10337   }
10338   std::string arg2_str(jarg2);
10339   std::string* arg2 = &arg2_str;
10340
10341   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10342
10343   {
10344     try {
10345       arg1->operator[]((std::string const &)*arg2) = *arg3;
10346     } CALL_CATCH_EXCEPTION();
10347   }
10348 }
10349
10350
10351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10352
10353   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10354   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10355   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10356
10357   {
10358     try {
10359       arg1->operator[](arg2) = *arg3;
10360     } CALL_CATCH_EXCEPTION();
10361   }
10362 }
10363
10364
10365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10366   void * jresult ;
10367   Dali::Property::Value *result = 0 ;
10368
10369   {
10370     try {
10371       result = (Dali::Property::Value *)new Dali::Property::Value();
10372     } CALL_CATCH_EXCEPTION(0);
10373   }
10374
10375   jresult = (void *)result;
10376   return jresult;
10377 }
10378
10379
10380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
10381   void * jresult ;
10382   bool arg1 ;
10383   Dali::Property::Value *result = 0 ;
10384
10385   arg1 = jarg1 ? true : false;
10386   {
10387     try {
10388       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10389     } CALL_CATCH_EXCEPTION(0);
10390   }
10391
10392   jresult = (void *)result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10398   void * jresult ;
10399   int arg1 ;
10400   Dali::Property::Value *result = 0 ;
10401
10402   arg1 = (int)jarg1;
10403   {
10404     try {
10405       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10406     } CALL_CATCH_EXCEPTION(0);
10407   }
10408
10409   jresult = (void *)result;
10410   return jresult;
10411 }
10412
10413
10414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
10415   void * jresult ;
10416   float arg1 ;
10417   Dali::Property::Value *result = 0 ;
10418
10419   arg1 = (float)jarg1;
10420   {
10421     try {
10422       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10423     } CALL_CATCH_EXCEPTION(0);
10424   }
10425
10426   jresult = (void *)result;
10427   return jresult;
10428 }
10429
10430
10431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
10432   void * jresult ;
10433   Dali::Vector2 *arg1 = 0 ;
10434   Dali::Property::Value *result = 0 ;
10435
10436   arg1 = (Dali::Vector2 *)jarg1;
10437   if (!arg1) {
10438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
10439     return 0;
10440   }
10441   {
10442     try {
10443       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
10444     } CALL_CATCH_EXCEPTION(0);
10445   }
10446
10447   jresult = (void *)result;
10448   return jresult;
10449 }
10450
10451
10452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
10453   void * jresult ;
10454   Dali::Vector3 *arg1 = 0 ;
10455   Dali::Property::Value *result = 0 ;
10456
10457   arg1 = (Dali::Vector3 *)jarg1;
10458   if (!arg1) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10460     return 0;
10461   }
10462   {
10463     try {
10464       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
10465     } CALL_CATCH_EXCEPTION(0);
10466   }
10467
10468   jresult = (void *)result;
10469   return jresult;
10470 }
10471
10472
10473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
10474   void * jresult ;
10475   Dali::Vector4 *arg1 = 0 ;
10476   Dali::Property::Value *result = 0 ;
10477
10478   arg1 = (Dali::Vector4 *)jarg1;
10479   if (!arg1) {
10480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10481     return 0;
10482   }
10483   {
10484     try {
10485       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
10486     } CALL_CATCH_EXCEPTION(0);
10487   }
10488
10489   jresult = (void *)result;
10490   return jresult;
10491 }
10492
10493
10494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
10495   void * jresult ;
10496   Dali::Matrix3 *arg1 = 0 ;
10497   Dali::Property::Value *result = 0 ;
10498
10499   arg1 = (Dali::Matrix3 *)jarg1;
10500   if (!arg1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
10502     return 0;
10503   }
10504   {
10505     try {
10506       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
10507     } CALL_CATCH_EXCEPTION(0);
10508   }
10509
10510   jresult = (void *)result;
10511   return jresult;
10512 }
10513
10514
10515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
10516   void * jresult ;
10517   Dali::Matrix *arg1 = 0 ;
10518   Dali::Property::Value *result = 0 ;
10519
10520   arg1 = (Dali::Matrix *)jarg1;
10521   if (!arg1) {
10522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10523     return 0;
10524   }
10525   {
10526     try {
10527       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
10528     } CALL_CATCH_EXCEPTION(0);
10529   }
10530
10531   jresult = (void *)result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
10537   void * jresult ;
10538   Dali::Rect< int > *arg1 = 0 ;
10539   Dali::Property::Value *result = 0 ;
10540
10541   arg1 = (Dali::Rect< int > *)jarg1;
10542   if (!arg1) {
10543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
10544     return 0;
10545   }
10546   {
10547     try {
10548       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
10549     } CALL_CATCH_EXCEPTION(0);
10550   }
10551
10552   jresult = (void *)result;
10553   return jresult;
10554 }
10555
10556
10557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
10558   void * jresult ;
10559   Dali::AngleAxis *arg1 = 0 ;
10560   Dali::Property::Value *result = 0 ;
10561
10562   arg1 = (Dali::AngleAxis *)jarg1;
10563   if (!arg1) {
10564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
10565     return 0;
10566   }
10567   {
10568     try {
10569       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
10570     } CALL_CATCH_EXCEPTION(0);
10571   }
10572
10573   jresult = (void *)result;
10574   return jresult;
10575 }
10576
10577
10578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
10579   void * jresult ;
10580   Dali::Quaternion *arg1 = 0 ;
10581   Dali::Property::Value *result = 0 ;
10582
10583   arg1 = (Dali::Quaternion *)jarg1;
10584   if (!arg1) {
10585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10586     return 0;
10587   }
10588   {
10589     try {
10590       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
10591     } CALL_CATCH_EXCEPTION(0);
10592   }
10593
10594   jresult = (void *)result;
10595   return jresult;
10596 }
10597
10598
10599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
10600   void * jresult ;
10601   std::string *arg1 = 0 ;
10602   Dali::Property::Value *result = 0 ;
10603
10604   if (!jarg1) {
10605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10606     return 0;
10607   }
10608   std::string arg1_str(jarg1);
10609   arg1 = &arg1_str;
10610   {
10611     try {
10612       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
10613     } CALL_CATCH_EXCEPTION(0);
10614   }
10615
10616   jresult = (void *)result;
10617
10618   //argout typemap for const std::string&
10619
10620   return jresult;
10621 }
10622
10623
10624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
10625   void * jresult ;
10626   Dali::Property::Array *arg1 = 0 ;
10627   Dali::Property::Value *result = 0 ;
10628
10629   arg1 = (Dali::Property::Array *)jarg1;
10630   if (!arg1) {
10631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
10632     return 0;
10633   }
10634   {
10635     try {
10636       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10637     } CALL_CATCH_EXCEPTION(0);
10638   }
10639
10640   jresult = (void *)result;
10641   return jresult;
10642 }
10643
10644
10645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
10646   void * jresult ;
10647   Dali::Property::Map *arg1 = 0 ;
10648   Dali::Property::Value *result = 0 ;
10649
10650   arg1 = (Dali::Property::Map *)jarg1;
10651   if (!arg1) {
10652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
10653     return 0;
10654   }
10655   {
10656     try {
10657       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10658     } CALL_CATCH_EXCEPTION(0);
10659   }
10660
10661   jresult = (void *)result;
10662   return jresult;
10663 }
10664
10665
10666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
10667   void * jresult ;
10668   Extents *arg1 = 0 ;
10669   Dali::Property::Value *result = 0 ;
10670
10671   arg1 = (Extents *)jarg1;
10672   if (!arg1) {
10673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
10674     return 0;
10675   }
10676   {
10677     try {
10678       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
10679     } CALL_CATCH_EXCEPTION(0);
10680   }
10681
10682   jresult = (void*) result;
10683   return jresult;
10684 }
10685
10686
10687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
10688   void * jresult ;
10689   Dali::Property::Type arg1 ;
10690   Dali::Property::Value *result = 0 ;
10691
10692   arg1 = (Dali::Property::Type)jarg1;
10693   {
10694     try {
10695       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10696     } CALL_CATCH_EXCEPTION(0);
10697   }
10698
10699   jresult = (void *)result;
10700   return jresult;
10701 }
10702
10703
10704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
10705   void * jresult ;
10706   Dali::Property::Value *arg1 = 0 ;
10707   Dali::Property::Value *result = 0 ;
10708
10709   arg1 = (Dali::Property::Value *)jarg1;
10710   if (!arg1) {
10711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10712     return 0;
10713   }
10714   {
10715     try {
10716       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
10717     } CALL_CATCH_EXCEPTION(0);
10718   }
10719
10720   jresult = (void *)result;
10721   return jresult;
10722 }
10723
10724
10725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
10726   void * jresult ;
10727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10728   Dali::Property::Value *arg2 = 0 ;
10729   Dali::Property::Value *result = 0 ;
10730
10731   arg1 = (Dali::Property::Value *)jarg1;
10732   arg2 = (Dali::Property::Value *)jarg2;
10733   if (!arg2) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10735     return 0;
10736   }
10737   {
10738     try {
10739       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
10740     } CALL_CATCH_EXCEPTION(0);
10741   }
10742
10743   jresult = (void *)result;
10744   return jresult;
10745 }
10746
10747
10748 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
10749   bool jresult;
10750   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10751   Dali::Property::Value *arg2 = 0 ;
10752   bool result;
10753
10754   arg1 = (Dali::Property::Value *)jarg1;
10755   arg2 = (Dali::Property::Value *)jarg2;
10756   if (!arg2) {
10757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10758     return 0;
10759   }
10760   {
10761     try {
10762       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
10763     } CALL_CATCH_EXCEPTION(0);
10764   }
10765
10766   jresult = result;
10767   return jresult;
10768 }
10769
10770 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
10771   bool jresult;
10772   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10773   Dali::Property::Value *arg2 = 0 ;
10774   bool result;
10775
10776   arg1 = (Dali::Property::Value *)jarg1;
10777   arg2 = (Dali::Property::Value *)jarg2;
10778   if (!arg2) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10780     return 0;
10781   }
10782   {
10783     try {
10784       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
10785     } CALL_CATCH_EXCEPTION(0);
10786   }
10787
10788   jresult = result;
10789   return jresult;
10790 }
10791
10792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
10793   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10794
10795   arg1 = (Dali::Property::Value *)jarg1;
10796   {
10797     try {
10798       delete arg1;
10799     } CALL_CATCH_EXCEPTION();
10800   }
10801
10802 }
10803
10804
10805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
10806   int jresult ;
10807   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10808   Dali::Property::Type result;
10809
10810   arg1 = (Dali::Property::Value *)jarg1;
10811   {
10812     try {
10813       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
10814     } CALL_CATCH_EXCEPTION(0);
10815   }
10816
10817   jresult = (int)result;
10818   return jresult;
10819 }
10820
10821
10822 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
10823   bool jresult ;
10824   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10825   bool *arg2 = 0 ;
10826   bool result;
10827
10828   arg1 = (Dali::Property::Value *)jarg1;
10829   arg2 = (bool *)jarg2;
10830   {
10831     try {
10832       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10833     } CALL_CATCH_EXCEPTION(0);
10834   }
10835
10836   jresult = result;
10837   return jresult;
10838 }
10839
10840
10841 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
10842   bool jresult ;
10843   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10844   float *arg2 = 0 ;
10845   bool result;
10846
10847   arg1 = (Dali::Property::Value *)jarg1;
10848   arg2 = (float *)jarg2;
10849   {
10850     try {
10851       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10852     } CALL_CATCH_EXCEPTION(0);
10853   }
10854
10855   jresult = result;
10856   return jresult;
10857 }
10858
10859
10860 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
10861   bool jresult ;
10862   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10863   int *arg2 = 0 ;
10864   bool result;
10865
10866   arg1 = (Dali::Property::Value *)jarg1;
10867   arg2 = (int *)jarg2;
10868   {
10869     try {
10870       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10871     } CALL_CATCH_EXCEPTION(0);
10872   }
10873
10874   jresult = result;
10875   return jresult;
10876 }
10877
10878
10879 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
10880   bool jresult ;
10881   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10882   Dali::Rect< int > *arg2 = 0 ;
10883   bool result;
10884
10885   arg1 = (Dali::Property::Value *)jarg1;
10886   arg2 = (Dali::Rect< int > *)jarg2;
10887   if (!arg2) {
10888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
10889     return 0;
10890   }
10891   {
10892     try {
10893       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10894     } CALL_CATCH_EXCEPTION(0);
10895   }
10896
10897   jresult = result;
10898   return jresult;
10899 }
10900
10901
10902 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
10903   bool jresult ;
10904   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10905   Dali::Vector2 *arg2 = 0 ;
10906   bool result;
10907
10908   arg1 = (Dali::Property::Value *)jarg1;
10909   arg2 = (Dali::Vector2 *)jarg2;
10910   if (!arg2) {
10911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
10912     return 0;
10913   }
10914   {
10915     try {
10916       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10917     } CALL_CATCH_EXCEPTION(0);
10918   }
10919
10920   jresult = result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
10926   bool jresult ;
10927   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10928   Dali::Vector3 *arg2 = 0 ;
10929   bool result;
10930
10931   arg1 = (Dali::Property::Value *)jarg1;
10932   arg2 = (Dali::Vector3 *)jarg2;
10933   if (!arg2) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10935     return 0;
10936   }
10937   {
10938     try {
10939       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10940     } CALL_CATCH_EXCEPTION(0);
10941   }
10942
10943   jresult = result;
10944   return jresult;
10945 }
10946
10947
10948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
10949   bool jresult ;
10950   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10951   Dali::Vector4 *arg2 = 0 ;
10952   bool result;
10953
10954   arg1 = (Dali::Property::Value *)jarg1;
10955   arg2 = (Dali::Vector4 *)jarg2;
10956   if (!arg2) {
10957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
10958     return 0;
10959   }
10960   {
10961     try {
10962       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10963     } CALL_CATCH_EXCEPTION(0);
10964   }
10965
10966   jresult = result;
10967   return jresult;
10968 }
10969
10970
10971 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
10972   bool jresult ;
10973   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10974   Dali::Matrix3 *arg2 = 0 ;
10975   bool result;
10976
10977   arg1 = (Dali::Property::Value *)jarg1;
10978   arg2 = (Dali::Matrix3 *)jarg2;
10979   if (!arg2) {
10980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
10981     return 0;
10982   }
10983   {
10984     try {
10985       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10986     } CALL_CATCH_EXCEPTION(0);
10987   }
10988
10989   jresult = result;
10990   return jresult;
10991 }
10992
10993
10994 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
10995   bool jresult ;
10996   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10997   Dali::Matrix *arg2 = 0 ;
10998   bool result;
10999
11000   arg1 = (Dali::Property::Value *)jarg1;
11001   arg2 = (Dali::Matrix *)jarg2;
11002   if (!arg2) {
11003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11004     return 0;
11005   }
11006   {
11007     try {
11008       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11009     } CALL_CATCH_EXCEPTION(0);
11010   }
11011
11012   jresult = result;
11013   return jresult;
11014 }
11015
11016
11017 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11018   bool jresult ;
11019   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11020   Dali::AngleAxis *arg2 = 0 ;
11021   bool result;
11022
11023   arg1 = (Dali::Property::Value *)jarg1;
11024   arg2 = (Dali::AngleAxis *)jarg2;
11025   if (!arg2) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11027     return 0;
11028   }
11029   {
11030     try {
11031       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11032     } CALL_CATCH_EXCEPTION(0);
11033   }
11034
11035   jresult = result;
11036   return jresult;
11037 }
11038
11039
11040 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11041   bool jresult ;
11042   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11043   Dali::Quaternion *arg2 = 0 ;
11044   bool result;
11045
11046   arg1 = (Dali::Property::Value *)jarg1;
11047   arg2 = (Dali::Quaternion *)jarg2;
11048   if (!arg2) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11050     return 0;
11051   }
11052   {
11053     try {
11054       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11055     } CALL_CATCH_EXCEPTION(0);
11056   }
11057
11058   jresult = result;
11059   return jresult;
11060 }
11061
11062
11063 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11064   bool jresult ;
11065   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11066   std::string *arg2 = 0 ;
11067   bool result;
11068
11069   arg1 = (Dali::Property::Value *)jarg1;
11070
11071   //typemap in
11072   std::string temp;
11073   arg2 = &temp;
11074
11075   {
11076     try {
11077       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11078     } CALL_CATCH_EXCEPTION(0);
11079   }
11080
11081   jresult = result;
11082
11083   //Typemap argout in c++ file.
11084   //This will convert c++ string to c# string
11085   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11086
11087   return jresult;
11088 }
11089
11090
11091 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11092   bool jresult ;
11093   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11094   Dali::Property::Array *arg2 = 0 ;
11095   bool result;
11096
11097   arg1 = (Dali::Property::Value *)jarg1;
11098   arg2 = (Dali::Property::Array *)jarg2;
11099   if (!arg2) {
11100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11101     return 0;
11102   }
11103   {
11104     try {
11105       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11106     } CALL_CATCH_EXCEPTION(0);
11107   }
11108
11109   jresult = result;
11110   return jresult;
11111 }
11112
11113
11114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11115   bool jresult ;
11116   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11117   Dali::Property::Map *arg2 = 0 ;
11118   bool result;
11119
11120   arg1 = (Dali::Property::Value *)jarg1;
11121   arg2 = (Dali::Property::Map *)jarg2;
11122   if (!arg2) {
11123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11124     return 0;
11125   }
11126   {
11127     try {
11128       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11129     } CALL_CATCH_EXCEPTION(0);
11130   }
11131
11132   jresult = result;
11133   return jresult;
11134 }
11135
11136
11137 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11138   bool jresult ;
11139   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11140   Extents *arg2 = 0 ;
11141   bool result;
11142
11143   arg1 = (Dali::Property::Value *)jarg1;
11144   arg2 = (Extents *)jarg2;
11145   if (!arg2) {
11146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11147     return 0;
11148   }
11149   {
11150     try {
11151       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11152     } CALL_CATCH_EXCEPTION(0);
11153   }
11154   jresult = result;
11155   return jresult;
11156 }
11157
11158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11159   void * jresult ;
11160   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11161   Dali::Property::Array *result = 0 ;
11162
11163   arg1 = (Dali::Property::Value *)jarg1;
11164   {
11165     try {
11166       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11167     } CALL_CATCH_EXCEPTION(0);
11168   }
11169
11170   jresult = (void *)result;
11171   return jresult;
11172 }
11173
11174
11175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11176   void * jresult ;
11177   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11178   Dali::Property::Map *result = 0 ;
11179
11180   arg1 = (Dali::Property::Value *)jarg1;
11181   {
11182     try {
11183       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11184     } CALL_CATCH_EXCEPTION(0);
11185   }
11186
11187   jresult = (void *)result;
11188   return jresult;
11189 }
11190
11191
11192 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11193   char * jresult ;
11194   Dali::Property::Type arg1 ;
11195   char *result = 0 ;
11196
11197   arg1 = (Dali::Property::Type)jarg1;
11198   {
11199     try {
11200       result = (char *)Dali::PropertyTypes::GetName(arg1);
11201     } CALL_CATCH_EXCEPTION(0);
11202   }
11203
11204   jresult = SWIG_csharp_string_callback((const char *)result);
11205   return jresult;
11206 }
11207
11208
11209 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11210   bool jresult ;
11211   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11212   std::string *arg2 = 0 ;
11213   Dali::Property::Map *arg3 = 0 ;
11214   bool result;
11215
11216   arg1 = (Dali::BaseObject *)jarg1;
11217   if (!jarg2) {
11218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11219     return 0;
11220   }
11221   std::string arg2_str(jarg2);
11222   arg2 = &arg2_str;
11223   arg3 = (Dali::Property::Map *)jarg3;
11224   if (!arg3) {
11225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11226     return 0;
11227   }
11228   {
11229     try {
11230       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11231     } CALL_CATCH_EXCEPTION(0);
11232   }
11233
11234   jresult = result;
11235
11236   //argout typemap for const std::string&
11237
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11243   char * jresult ;
11244   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11245   std::string *result = 0 ;
11246
11247   arg1 = (Dali::BaseObject *)jarg1;
11248   {
11249     try {
11250       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11251     } CALL_CATCH_EXCEPTION(0);
11252   }
11253
11254   jresult = SWIG_csharp_string_callback(result->c_str());
11255   return jresult;
11256 }
11257
11258
11259 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11260   bool jresult ;
11261   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11262   Dali::TypeInfo *arg2 = 0 ;
11263   bool result;
11264
11265   arg1 = (Dali::BaseObject *)jarg1;
11266   arg2 = (Dali::TypeInfo *)jarg2;
11267   if (!arg2) {
11268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11269     return 0;
11270   }
11271   {
11272     try {
11273       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11274     } CALL_CATCH_EXCEPTION(0);
11275   }
11276
11277   jresult = result;
11278   return jresult;
11279 }
11280
11281
11282 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11283   bool jresult ;
11284   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11285   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11286   std::string *arg3 = 0 ;
11287   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11288   bool result;
11289
11290   arg1 = (Dali::BaseObject *)jarg1;
11291   arg2 = (ConnectionTrackerInterface *)jarg2;
11292   if (!jarg3) {
11293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11294     return 0;
11295   }
11296   std::string arg3_str(jarg3);
11297   arg3 = &arg3_str;
11298   arg4 = (FunctorDelegate *)jarg4;
11299   {
11300     try {
11301       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11302     } CALL_CATCH_EXCEPTION(0);
11303   }
11304
11305   jresult = result;
11306
11307   //argout typemap for const std::string&
11308
11309   return jresult;
11310 }
11311
11312
11313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11314   void * jresult ;
11315   Dali::BaseHandle *arg1 = 0 ;
11316   Dali::BaseObject *result = 0 ;
11317
11318   arg1 = (Dali::BaseHandle *)jarg1;
11319   if (!arg1) {
11320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11321     return 0;
11322   }
11323   {
11324     try {
11325       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11326     } CALL_CATCH_EXCEPTION(0);
11327   }
11328
11329   jresult = (void *)result;
11330   return jresult;
11331 }
11332
11333
11334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11335   void * jresult ;
11336   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11337   Dali::BaseHandle *result = 0 ;
11338
11339   arg1 = (Dali::BaseObject *)jarg1;
11340   {
11341     try {
11342       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11343     } CALL_CATCH_EXCEPTION(0);
11344   }
11345
11346   jresult = (void *)result;
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11352   void * jresult ;
11353   Dali::BaseHandle *result = 0 ;
11354
11355   {
11356     try {
11357       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11358     } CALL_CATCH_EXCEPTION(0);
11359   }
11360
11361   jresult = (void *)result;
11362   return jresult;
11363 }
11364
11365
11366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11367   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11368
11369   arg1 = (Dali::BaseHandle *)jarg1;
11370   {
11371     try {
11372       delete arg1;
11373     } CALL_CATCH_EXCEPTION();
11374   }
11375
11376 }
11377
11378
11379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11380   void * jresult ;
11381   Dali::BaseHandle *arg1 = 0 ;
11382   Dali::BaseHandle *result = 0 ;
11383
11384   arg1 = (Dali::BaseHandle *)jarg1;
11385   if (!arg1) {
11386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11387     return 0;
11388   }
11389   {
11390     try {
11391       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11392     } CALL_CATCH_EXCEPTION(0);
11393   }
11394
11395   jresult = (void *)result;
11396   return jresult;
11397 }
11398
11399
11400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11401   void * jresult ;
11402   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11403   Dali::BaseHandle *arg2 = 0 ;
11404   Dali::BaseHandle *result = 0 ;
11405
11406   arg1 = (Dali::BaseHandle *)jarg1;
11407   arg2 = (Dali::BaseHandle *)jarg2;
11408   if (!arg2) {
11409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11410     return 0;
11411   }
11412   {
11413     try {
11414       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11415     } CALL_CATCH_EXCEPTION(0);
11416   }
11417
11418   jresult = (void *)result;
11419   return jresult;
11420 }
11421
11422
11423 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11424   bool jresult ;
11425   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11426   std::string *arg2 = 0 ;
11427   Dali::Property::Map *arg3 = 0 ;
11428   bool result;
11429
11430   arg1 = (Dali::BaseHandle *)jarg1;
11431   if (!jarg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11433     return 0;
11434   }
11435   std::string arg2_str(jarg2);
11436   arg2 = &arg2_str;
11437   arg3 = (Dali::Property::Map *)jarg3;
11438   if (!arg3) {
11439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11440     return 0;
11441   }
11442   {
11443     try {
11444       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11445     } CALL_CATCH_EXCEPTION(0);
11446   }
11447
11448   jresult = result;
11449
11450   //argout typemap for const std::string&
11451
11452   return jresult;
11453 }
11454
11455
11456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
11457   char * jresult ;
11458   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11459   std::string *result = 0 ;
11460
11461   arg1 = (Dali::BaseHandle *)jarg1;
11462   {
11463     try {
11464       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
11465     } CALL_CATCH_EXCEPTION(0);
11466   }
11467
11468   jresult = SWIG_csharp_string_callback(result->c_str());
11469   return jresult;
11470 }
11471
11472
11473 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
11474   bool jresult ;
11475   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11476   Dali::TypeInfo *arg2 = 0 ;
11477   bool result;
11478
11479   arg1 = (Dali::BaseHandle *)jarg1;
11480   arg2 = (Dali::TypeInfo *)jarg2;
11481   if (!arg2) {
11482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11483     return 0;
11484   }
11485   {
11486     try {
11487       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
11488     } CALL_CATCH_EXCEPTION(0);
11489   }
11490
11491   jresult = result;
11492   return jresult;
11493 }
11494
11495
11496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
11497   void * jresult ;
11498   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11499   Dali::BaseObject *result = 0 ;
11500
11501   arg1 = (Dali::BaseHandle *)jarg1;
11502   {
11503     try {
11504       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
11505     } CALL_CATCH_EXCEPTION(0);
11506   }
11507
11508   jresult = (void *)result;
11509   return jresult;
11510 }
11511
11512
11513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
11514   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11515
11516   arg1 = (Dali::BaseHandle *)jarg1;
11517   {
11518     try {
11519       (arg1)->Reset();
11520     } CALL_CATCH_EXCEPTION();
11521   }
11522
11523 }
11524
11525
11526 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
11527   bool jresult ;
11528   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11529   Dali::BaseHandle *arg2 = 0 ;
11530   bool result;
11531
11532   arg1 = (Dali::BaseHandle *)jarg1;
11533   arg2 = (Dali::BaseHandle *)jarg2;
11534   if (!arg2) {
11535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11536     return 0;
11537   }
11538   {
11539     try {
11540       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
11541     } CALL_CATCH_EXCEPTION(0);
11542   }
11543
11544   jresult = result;
11545   return jresult;
11546 }
11547
11548
11549 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
11550   bool jresult ;
11551   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11552   Dali::BaseHandle *arg2 = 0 ;
11553   bool result;
11554
11555   arg1 = (Dali::BaseHandle *)jarg1;
11556   arg2 = (Dali::BaseHandle *)jarg2;
11557   if (!arg2) {
11558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11559     return 0;
11560   }
11561   {
11562     try {
11563       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
11564     } CALL_CATCH_EXCEPTION(0);
11565   }
11566
11567   jresult = result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
11573   void * jresult ;
11574   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11575   Dali::RefObject *result = 0 ;
11576
11577   arg1 = (Dali::BaseHandle *)jarg1;
11578   {
11579     try {
11580       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
11581     } CALL_CATCH_EXCEPTION(0);
11582   }
11583
11584   jresult = (void *)result;
11585   return jresult;
11586 }
11587
11588
11589 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
11590   bool jresult ;
11591   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11592   bool result;
11593
11594   arg1 = (Dali::BaseHandle *)jarg1;
11595   {
11596     try {
11597       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
11598     } CALL_CATCH_EXCEPTION(0);
11599   }
11600
11601   jresult = result;
11602   return jresult;
11603 }
11604
11605
11606 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
11607   bool jresult ;
11608   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11609   Dali::BaseHandle *arg2 = 0 ;
11610   bool result;
11611
11612   arg1 = (Dali::BaseHandle *)jarg1;
11613   arg2 = (Dali::BaseHandle *)jarg2;
11614   if (!arg2) {
11615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11616     return 0;
11617   }
11618   {
11619     try {
11620       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
11621     } CALL_CATCH_EXCEPTION(0);
11622   }
11623
11624   jresult = result;
11625   return jresult;
11626 }
11627
11628
11629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
11630   bool jresult ;
11631   Dali::BaseHandle *arg1 = 0 ;
11632   Dali::BaseHandle *arg2 = 0 ;
11633   bool result;
11634
11635   arg1 = (Dali::BaseHandle *)jarg1;
11636   if (!arg1) {
11637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11638     return 0;
11639   }
11640   arg2 = (Dali::BaseHandle *)jarg2;
11641   if (!arg2) {
11642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11643     return 0;
11644   }
11645   {
11646     try {
11647       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
11648     } CALL_CATCH_EXCEPTION(0);
11649   }
11650
11651   jresult = result;
11652   return jresult;
11653 }
11654
11655
11656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
11657   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11658
11659   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11660   {
11661     try {
11662       delete arg1;
11663     } CALL_CATCH_EXCEPTION();
11664   }
11665
11666 }
11667
11668
11669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11670   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11671   SlotObserver *arg2 = (SlotObserver *) 0 ;
11672   CallbackBase *arg3 = (CallbackBase *) 0 ;
11673
11674   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11675   arg2 = (SlotObserver *)jarg2;
11676   arg3 = (CallbackBase *)jarg3;
11677   {
11678     try {
11679       (arg1)->SignalConnected(arg2,arg3);
11680     } CALL_CATCH_EXCEPTION();
11681   }
11682
11683 }
11684
11685
11686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
11687   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11688
11689   arg1 = (Dali::SignalObserver *)jarg1;
11690   {
11691     try {
11692       delete arg1;
11693     } CALL_CATCH_EXCEPTION();
11694   }
11695
11696 }
11697
11698
11699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11700   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11701   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11702   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11703
11704   arg1 = (Dali::SignalObserver *)jarg1;
11705   arg2 = (Dali::SlotObserver *)jarg2;
11706   arg3 = (Dali::CallbackBase *)jarg3;
11707   {
11708     try {
11709       (arg1)->SignalDisconnected(arg2,arg3);
11710     } CALL_CATCH_EXCEPTION();
11711   }
11712
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
11717   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11718
11719   arg1 = (Dali::SlotObserver *)jarg1;
11720   {
11721     try {
11722       delete arg1;
11723     } CALL_CATCH_EXCEPTION();
11724   }
11725
11726 }
11727
11728
11729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
11730   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11731   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
11732
11733   arg1 = (Dali::SlotObserver *)jarg1;
11734   arg2 = (Dali::CallbackBase *)jarg2;
11735   {
11736     try {
11737       (arg1)->SlotDisconnected(arg2);
11738     } CALL_CATCH_EXCEPTION();
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
11745   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11746
11747   arg1 = (Dali::ConnectionTracker *)jarg1;
11748   {
11749     try {
11750       delete arg1;
11751     } CALL_CATCH_EXCEPTION();
11752   }
11753
11754 }
11755
11756
11757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
11758   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11759
11760   arg1 = (Dali::ConnectionTracker *)jarg1;
11761   {
11762     try {
11763       (arg1)->DisconnectAll();
11764     } CALL_CATCH_EXCEPTION();
11765   }
11766
11767 }
11768
11769
11770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11771   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11772   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11773   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11774
11775   arg1 = (Dali::ConnectionTracker *)jarg1;
11776   arg2 = (Dali::SlotObserver *)jarg2;
11777   arg3 = (Dali::CallbackBase *)jarg3;
11778   {
11779     try {
11780       (arg1)->SignalConnected(arg2,arg3);
11781     } CALL_CATCH_EXCEPTION();
11782   }
11783
11784 }
11785
11786
11787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11788   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11789   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11790   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11791
11792   arg1 = (Dali::ConnectionTracker *)jarg1;
11793   arg2 = (Dali::SlotObserver *)jarg2;
11794   arg3 = (Dali::CallbackBase *)jarg3;
11795   {
11796     try {
11797       (arg1)->SignalDisconnected(arg2,arg3);
11798     } CALL_CATCH_EXCEPTION();
11799   }
11800
11801 }
11802
11803
11804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
11805   unsigned long jresult ;
11806   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11807   std::size_t result;
11808
11809   arg1 = (Dali::ConnectionTracker *)jarg1;
11810   {
11811     try {
11812       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
11813     } CALL_CATCH_EXCEPTION(0);
11814   }
11815
11816   jresult = (unsigned long)result;
11817   return jresult;
11818 }
11819
11820
11821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
11822   void * jresult ;
11823   Dali::ObjectRegistry *result = 0 ;
11824
11825   {
11826     try {
11827       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
11828     } CALL_CATCH_EXCEPTION(0);
11829   }
11830
11831   jresult = (void *)result;
11832   return jresult;
11833 }
11834
11835
11836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
11837   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11838
11839   arg1 = (Dali::ObjectRegistry *)jarg1;
11840   {
11841     try {
11842       delete arg1;
11843     } CALL_CATCH_EXCEPTION();
11844   }
11845
11846 }
11847
11848
11849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
11850   void * jresult ;
11851   Dali::ObjectRegistry *arg1 = 0 ;
11852   Dali::ObjectRegistry *result = 0 ;
11853
11854   arg1 = (Dali::ObjectRegistry *)jarg1;
11855   if (!arg1) {
11856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
11857     return 0;
11858   }
11859   {
11860     try {
11861       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
11862     } CALL_CATCH_EXCEPTION(0);
11863   }
11864
11865   jresult = (void *)result;
11866   return jresult;
11867 }
11868
11869
11870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
11871   void * jresult ;
11872   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11873   Dali::ObjectRegistry *arg2 = 0 ;
11874   Dali::ObjectRegistry *result = 0 ;
11875
11876   arg1 = (Dali::ObjectRegistry *)jarg1;
11877   arg2 = (Dali::ObjectRegistry *)jarg2;
11878   if (!arg2) {
11879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
11880     return 0;
11881   }
11882   {
11883     try {
11884       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
11885     } CALL_CATCH_EXCEPTION(0);
11886   }
11887
11888   jresult = (void *)result;
11889   return jresult;
11890 }
11891
11892
11893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
11894   void * jresult ;
11895   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11896   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
11897
11898   arg1 = (Dali::ObjectRegistry *)jarg1;
11899   {
11900     try {
11901       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
11902     } CALL_CATCH_EXCEPTION(0);
11903   }
11904
11905   jresult = (void *)result;
11906   return jresult;
11907 }
11908
11909
11910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
11911   void * jresult ;
11912   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11913   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
11914
11915   arg1 = (Dali::ObjectRegistry *)jarg1;
11916   {
11917     try {
11918       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
11919     } CALL_CATCH_EXCEPTION(0);
11920   }
11921
11922   jresult = (void *)result;
11923   return jresult;
11924 }
11925
11926
11927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
11928   void * jresult ;
11929   Dali::PropertyCondition *result = 0 ;
11930
11931   {
11932     try {
11933       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
11934     } CALL_CATCH_EXCEPTION(0);
11935   }
11936
11937   jresult = (void *)result;
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
11943   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11944
11945   arg1 = (Dali::PropertyCondition *)jarg1;
11946   {
11947     try {
11948       delete arg1;
11949     } CALL_CATCH_EXCEPTION();
11950   }
11951
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
11956   void * jresult ;
11957   Dali::PropertyCondition *arg1 = 0 ;
11958   Dali::PropertyCondition *result = 0 ;
11959
11960   arg1 = (Dali::PropertyCondition *)jarg1;
11961   if (!arg1) {
11962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
11963     return 0;
11964   }
11965   {
11966     try {
11967       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
11968     } CALL_CATCH_EXCEPTION(0);
11969   }
11970
11971   jresult = (void *)result;
11972   return jresult;
11973 }
11974
11975
11976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
11977   void * jresult ;
11978   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11979   Dali::PropertyCondition *arg2 = 0 ;
11980   Dali::PropertyCondition *result = 0 ;
11981
11982   arg1 = (Dali::PropertyCondition *)jarg1;
11983   arg2 = (Dali::PropertyCondition *)jarg2;
11984   if (!arg2) {
11985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
11986     return 0;
11987   }
11988   {
11989     try {
11990       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
11991     } CALL_CATCH_EXCEPTION(0);
11992   }
11993
11994   jresult = (void *)result;
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12000   unsigned long jresult ;
12001   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12002   std::size_t result;
12003
12004   arg1 = (Dali::PropertyCondition *)jarg1;
12005   {
12006     try {
12007       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12008     } CALL_CATCH_EXCEPTION(0);
12009   }
12010   jresult = (unsigned long)result;
12011   return jresult;
12012 }
12013
12014
12015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12016   float jresult ;
12017   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12018   std::size_t arg2 ;
12019   float result;
12020
12021   arg1 = (Dali::PropertyCondition *)jarg1;
12022   arg2 = (std::size_t)jarg2;
12023   {
12024     try {
12025       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12026     } CALL_CATCH_EXCEPTION(0);
12027   }
12028   jresult = result;
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12034   void * jresult ;
12035   float arg1 ;
12036   Dali::PropertyCondition result;
12037
12038   arg1 = (float)jarg1;
12039   {
12040     try {
12041       result = Dali::LessThanCondition(arg1);
12042     } CALL_CATCH_EXCEPTION(0);
12043   }
12044
12045   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12046   return jresult;
12047 }
12048
12049
12050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12051   void * jresult ;
12052   float arg1 ;
12053   Dali::PropertyCondition result;
12054
12055   arg1 = (float)jarg1;
12056   {
12057     try {
12058       result = Dali::GreaterThanCondition(arg1);
12059     } CALL_CATCH_EXCEPTION(0);
12060   }
12061
12062   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12063   return jresult;
12064 }
12065
12066
12067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12068   void * jresult ;
12069   float arg1 ;
12070   float arg2 ;
12071   Dali::PropertyCondition result;
12072
12073   arg1 = (float)jarg1;
12074   arg2 = (float)jarg2;
12075   {
12076     try {
12077       result = Dali::InsideCondition(arg1,arg2);
12078     } CALL_CATCH_EXCEPTION(0);
12079   }
12080
12081   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12082   return jresult;
12083 }
12084
12085
12086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12087   void * jresult ;
12088   float arg1 ;
12089   float arg2 ;
12090   Dali::PropertyCondition result;
12091
12092   arg1 = (float)jarg1;
12093   arg2 = (float)jarg2;
12094   {
12095     try {
12096       result = Dali::OutsideCondition(arg1,arg2);
12097     } CALL_CATCH_EXCEPTION(0);
12098   }
12099
12100   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12101   return jresult;
12102 }
12103
12104
12105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12106   void * jresult ;
12107   float arg1 ;
12108   float arg2 ;
12109   Dali::PropertyCondition result;
12110
12111   arg1 = (float)jarg1;
12112   arg2 = (float)jarg2;
12113   {
12114     try {
12115       result = Dali::StepCondition(arg1,arg2);
12116     } CALL_CATCH_EXCEPTION(0);
12117   }
12118
12119   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12120   return jresult;
12121 }
12122
12123
12124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12125   void * jresult ;
12126   float arg1 ;
12127   Dali::PropertyCondition result;
12128
12129   arg1 = (float)jarg1;
12130   {
12131     try {
12132       result = Dali::StepCondition(arg1);
12133     } CALL_CATCH_EXCEPTION(0);
12134   }
12135
12136   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12137   return jresult;
12138 }
12139
12140
12141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12142   void * jresult ;
12143   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12144   Dali::PropertyCondition result;
12145
12146   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12147   if (!arg1) {
12148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12149     return 0;
12150   }
12151   {
12152     try {
12153       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12154     } CALL_CATCH_EXCEPTION(0);
12155   }
12156
12157   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12158   return jresult;
12159 }
12160
12161
12162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12163   void * jresult ;
12164   Dali::PropertyNotification *result = 0 ;
12165
12166   {
12167     try {
12168       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12169     } CALL_CATCH_EXCEPTION(0);
12170   }
12171
12172   jresult = (void *)result;
12173   return jresult;
12174 }
12175
12176
12177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12178   void * jresult ;
12179   Dali::BaseHandle arg1 ;
12180   Dali::BaseHandle *argp1 ;
12181   Dali::PropertyNotification result;
12182
12183   argp1 = (Dali::BaseHandle *)jarg1;
12184   if (!argp1) {
12185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12186     return 0;
12187   }
12188   arg1 = *argp1;
12189   {
12190     try {
12191       result = Dali::PropertyNotification::DownCast(arg1);
12192     } CALL_CATCH_EXCEPTION(0);
12193   }
12194
12195   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12196   return jresult;
12197 }
12198
12199
12200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12201   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12202
12203   arg1 = (Dali::PropertyNotification *)jarg1;
12204   {
12205     try {
12206       delete arg1;
12207     } CALL_CATCH_EXCEPTION();
12208   }
12209
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12214   void * jresult ;
12215   Dali::PropertyNotification *arg1 = 0 ;
12216   Dali::PropertyNotification *result = 0 ;
12217
12218   arg1 = (Dali::PropertyNotification *)jarg1;
12219   if (!arg1) {
12220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12221     return 0;
12222   }
12223   {
12224     try {
12225       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12226     } CALL_CATCH_EXCEPTION(0);
12227   }
12228
12229   jresult = (void *)result;
12230   return jresult;
12231 }
12232
12233
12234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12235   void * jresult ;
12236   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12237   Dali::PropertyNotification *arg2 = 0 ;
12238   Dali::PropertyNotification *result = 0 ;
12239
12240   arg1 = (Dali::PropertyNotification *)jarg1;
12241   arg2 = (Dali::PropertyNotification *)jarg2;
12242   if (!arg2) {
12243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12244     return 0;
12245   }
12246   {
12247     try {
12248       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12249     } CALL_CATCH_EXCEPTION(0);
12250   }
12251
12252   jresult = (void *)result;
12253   return jresult;
12254 }
12255
12256
12257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12258   void * jresult ;
12259   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12260   Dali::PropertyCondition result;
12261
12262   arg1 = (Dali::PropertyNotification *)jarg1;
12263   {
12264     try {
12265       result = (arg1)->GetCondition();
12266     } CALL_CATCH_EXCEPTION(0);
12267   }
12268
12269   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12270   return jresult;
12271 }
12272
12273
12274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12275   void * jresult ;
12276   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12277   Dali::Handle result;
12278
12279   arg1 = (Dali::PropertyNotification *)jarg1;
12280   {
12281     try {
12282       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12283     } CALL_CATCH_EXCEPTION(0);
12284   }
12285
12286   jresult = new Dali::Handle((const Dali::Handle &)result);
12287   return jresult;
12288 }
12289
12290
12291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12292   int jresult ;
12293   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12294   Dali::Property::Index result;
12295
12296   arg1 = (Dali::PropertyNotification *)jarg1;
12297   {
12298     try {
12299       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12300     } CALL_CATCH_EXCEPTION(0);
12301   }
12302
12303   jresult = result;
12304   return jresult;
12305 }
12306
12307
12308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12309   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12310   Dali::PropertyNotification::NotifyMode arg2 ;
12311
12312   arg1 = (Dali::PropertyNotification *)jarg1;
12313   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12314   {
12315     try {
12316       (arg1)->SetNotifyMode(arg2);
12317     } CALL_CATCH_EXCEPTION();
12318   }
12319
12320 }
12321
12322
12323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12324   int jresult ;
12325   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12326   Dali::PropertyNotification::NotifyMode result;
12327
12328   arg1 = (Dali::PropertyNotification *)jarg1;
12329   {
12330     try {
12331       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12332     } CALL_CATCH_EXCEPTION(0);
12333   }
12334
12335   jresult = (int)result;
12336   return jresult;
12337 }
12338
12339
12340 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12341   bool jresult ;
12342   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12343   bool result;
12344
12345   arg1 = (Dali::PropertyNotification *)jarg1;
12346   {
12347     try {
12348       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12349     } CALL_CATCH_EXCEPTION(0);
12350   }
12351
12352   jresult = result;
12353   return jresult;
12354 }
12355
12356
12357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12358   void * jresult ;
12359   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12360   Dali::PropertyNotifySignalType *result = 0 ;
12361
12362   arg1 = (Dali::PropertyNotification *)jarg1;
12363   {
12364     try {
12365       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12366     } CALL_CATCH_EXCEPTION(0);
12367   }
12368
12369   jresult = (void *)result;
12370   return jresult;
12371 }
12372
12373
12374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12375   void * jresult ;
12376   Dali::Handle *result = 0 ;
12377
12378   {
12379     try {
12380       result = (Dali::Handle *)new Dali::Handle();
12381     } CALL_CATCH_EXCEPTION(0);
12382   }
12383
12384   jresult = (void *)result;
12385   return jresult;
12386 }
12387
12388
12389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12390   void * jresult ;
12391   Dali::Handle result;
12392
12393   {
12394     try {
12395       result = Dali::Handle::New();
12396     } CALL_CATCH_EXCEPTION(0);
12397   }
12398
12399   jresult = new Dali::Handle((const Dali::Handle &)result);
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12405   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12406
12407   arg1 = (Dali::Handle *)jarg1;
12408   {
12409     try {
12410       delete arg1;
12411     } CALL_CATCH_EXCEPTION();
12412   }
12413
12414 }
12415
12416
12417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12418   void * jresult ;
12419   Dali::Handle *arg1 = 0 ;
12420   Dali::Handle *result = 0 ;
12421
12422   arg1 = (Dali::Handle *)jarg1;
12423   if (!arg1) {
12424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12425     return 0;
12426   }
12427   {
12428     try {
12429       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12430     } CALL_CATCH_EXCEPTION(0);
12431   }
12432
12433   jresult = (void *)result;
12434   return jresult;
12435 }
12436
12437
12438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12439   void * jresult ;
12440   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12441   Dali::Handle *arg2 = 0 ;
12442   Dali::Handle *result = 0 ;
12443
12444   arg1 = (Dali::Handle *)jarg1;
12445   arg2 = (Dali::Handle *)jarg2;
12446   if (!arg2) {
12447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12448     return 0;
12449   }
12450   {
12451     try {
12452       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12453     } CALL_CATCH_EXCEPTION(0);
12454   }
12455
12456   jresult = (void *)result;
12457   return jresult;
12458 }
12459
12460
12461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
12462   void * jresult ;
12463   Dali::BaseHandle arg1 ;
12464   Dali::BaseHandle *argp1 ;
12465   Dali::Handle result;
12466
12467   argp1 = (Dali::BaseHandle *)jarg1;
12468   if (!argp1) {
12469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12470     return 0;
12471   }
12472   arg1 = *argp1;
12473   {
12474     try {
12475       result = Dali::Handle::DownCast(arg1);
12476     } CALL_CATCH_EXCEPTION(0);
12477   }
12478
12479   jresult = new Dali::Handle((const Dali::Handle &)result);
12480   return jresult;
12481 }
12482
12483
12484 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
12485   bool jresult ;
12486   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12487   Dali::Handle::Capability arg2 ;
12488   bool result;
12489
12490   arg1 = (Dali::Handle *)jarg1;
12491   arg2 = (Dali::Handle::Capability)jarg2;
12492   {
12493     try {
12494       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
12495     } CALL_CATCH_EXCEPTION(0);
12496   }
12497
12498   jresult = result;
12499   return jresult;
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12506   unsigned int result;
12507
12508   arg1 = (Dali::Handle *)jarg1;
12509   {
12510     try {
12511       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
12512     } CALL_CATCH_EXCEPTION(0);
12513   }
12514
12515   jresult = result;
12516   return jresult;
12517 }
12518
12519
12520 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
12521   char * jresult ;
12522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12523   Dali::Property::Index arg2 ;
12524   std::string result;
12525
12526   arg1 = (Dali::Handle *)jarg1;
12527   arg2 = (Dali::Property::Index)jarg2;
12528   {
12529     try {
12530       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
12531     } CALL_CATCH_EXCEPTION(0);
12532   }
12533
12534   jresult = SWIG_csharp_string_callback((&result)->c_str());
12535   return jresult;
12536 }
12537
12538
12539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
12540   int jresult ;
12541   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12542   std::string *arg2 = 0 ;
12543   Dali::Property::Index result;
12544
12545   arg1 = (Dali::Handle *)jarg1;
12546   if (!jarg2) {
12547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12548     return 0;
12549   }
12550   std::string arg2_str(jarg2);
12551   arg2 = &arg2_str;
12552   {
12553     try {
12554       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
12555     } CALL_CATCH_EXCEPTION(0);
12556   }
12557
12558   jresult = result;
12559
12560   //argout typemap for const std::string&
12561
12562   return jresult;
12563 }
12564
12565
12566 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
12567   bool jresult ;
12568   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12569   Dali::Property::Index arg2 ;
12570   bool result;
12571
12572   arg1 = (Dali::Handle *)jarg1;
12573   arg2 = (Dali::Property::Index)jarg2;
12574   {
12575     try {
12576       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
12577     } CALL_CATCH_EXCEPTION(0);
12578   }
12579
12580   jresult = result;
12581   return jresult;
12582 }
12583
12584
12585 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
12586   bool jresult ;
12587   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12588   Dali::Property::Index arg2 ;
12589   bool result;
12590
12591   arg1 = (Dali::Handle *)jarg1;
12592   arg2 = (Dali::Property::Index)jarg2;
12593   {
12594     try {
12595       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
12596     } CALL_CATCH_EXCEPTION(0);
12597   }
12598
12599   jresult = result;
12600   return jresult;
12601 }
12602
12603
12604 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
12605   bool jresult ;
12606   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12607   Dali::Property::Index arg2 ;
12608   bool result;
12609
12610   arg1 = (Dali::Handle *)jarg1;
12611   arg2 = (Dali::Property::Index)jarg2;
12612   {
12613     try {
12614       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
12615     } CALL_CATCH_EXCEPTION(0);
12616   }
12617
12618   jresult = result;
12619   return jresult;
12620 }
12621
12622
12623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
12624   int jresult ;
12625   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12626   Dali::Property::Index arg2 ;
12627   Dali::Property::Type result;
12628
12629   arg1 = (Dali::Handle *)jarg1;
12630   arg2 = (Dali::Property::Index)jarg2;
12631   {
12632     try {
12633       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
12634     } CALL_CATCH_EXCEPTION(0);
12635   }
12636
12637   jresult = (int)result;
12638   return jresult;
12639 }
12640
12641
12642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
12643   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12644   Dali::Property::Index arg2 ;
12645   Dali::Property::Value *arg3 = 0 ;
12646
12647   arg1 = (Dali::Handle *)jarg1;
12648   arg2 = (Dali::Property::Index)jarg2;
12649   arg3 = (Dali::Property::Value *)jarg3;
12650   if (!arg3) {
12651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12652     return ;
12653   }
12654   {
12655     try {
12656       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
12657     } CALL_CATCH_EXCEPTION();
12658   }
12659
12660 }
12661
12662
12663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
12664   int jresult ;
12665   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12666   std::string *arg2 = 0 ;
12667   Dali::Property::Value *arg3 = 0 ;
12668   Dali::Property::Index result;
12669
12670   arg1 = (Dali::Handle *)jarg1;
12671   if (!jarg2) {
12672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12673     return 0;
12674   }
12675   std::string arg2_str(jarg2);
12676   arg2 = &arg2_str;
12677   arg3 = (Dali::Property::Value *)jarg3;
12678   if (!arg3) {
12679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12680     return 0;
12681   }
12682   {
12683     try {
12684       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
12685     } CALL_CATCH_EXCEPTION(0);
12686   }
12687
12688   jresult = result;
12689
12690   //argout typemap for const std::string&
12691
12692   return jresult;
12693 }
12694
12695
12696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
12697   int jresult ;
12698   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12699   std::string *arg2 = 0 ;
12700   Dali::Property::Value *arg3 = 0 ;
12701   Dali::Property::AccessMode arg4 ;
12702   Dali::Property::Index result;
12703
12704   arg1 = (Dali::Handle *)jarg1;
12705   if (!jarg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12707     return 0;
12708   }
12709   std::string arg2_str(jarg2);
12710   arg2 = &arg2_str;
12711   arg3 = (Dali::Property::Value *)jarg3;
12712   if (!arg3) {
12713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12714     return 0;
12715   }
12716   arg4 = (Dali::Property::AccessMode)jarg4;
12717   {
12718     try {
12719       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
12720     } CALL_CATCH_EXCEPTION(0);
12721   }
12722
12723   jresult = result;
12724
12725   //argout typemap for const std::string&
12726
12727   return jresult;
12728 }
12729
12730
12731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
12732   void * jresult ;
12733   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12734   Dali::Property::Index arg2 ;
12735   Dali::Property::Value result;
12736
12737   arg1 = (Dali::Handle *)jarg1;
12738   arg2 = (Dali::Property::Index)jarg2;
12739   {
12740     try {
12741       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
12742     } CALL_CATCH_EXCEPTION(0);
12743   }
12744
12745   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
12746   return jresult;
12747 }
12748
12749
12750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
12751   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12752   Dali::Property::IndexContainer *arg2 = 0 ;
12753
12754   arg1 = (Dali::Handle *)jarg1;
12755   arg2 = (Dali::Property::IndexContainer *)jarg2;
12756   if (!arg2) {
12757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
12758     return ;
12759   }
12760   {
12761     try {
12762       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
12763     } CALL_CATCH_EXCEPTION();
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
12770   void * jresult ;
12771   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12772   Dali::Property::Index arg2 ;
12773   Dali::PropertyCondition *arg3 = 0 ;
12774   Dali::PropertyNotification result;
12775
12776   arg1 = (Dali::Handle *)jarg1;
12777   arg2 = (Dali::Property::Index)jarg2;
12778   arg3 = (Dali::PropertyCondition *)jarg3;
12779   if (!arg3) {
12780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12781     return 0;
12782   }
12783   {
12784     try {
12785       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
12786     } CALL_CATCH_EXCEPTION(0);
12787   }
12788
12789   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12790   return jresult;
12791 }
12792
12793
12794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
12795   void * jresult ;
12796   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12797   Dali::Property::Index arg2 ;
12798   int arg3 ;
12799   Dali::PropertyCondition *arg4 = 0 ;
12800   Dali::PropertyNotification result;
12801
12802   arg1 = (Dali::Handle *)jarg1;
12803   arg2 = (Dali::Property::Index)jarg2;
12804   arg3 = (int)jarg3;
12805   arg4 = (Dali::PropertyCondition *)jarg4;
12806   if (!arg4) {
12807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12808     return 0;
12809   }
12810   {
12811     try {
12812       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
12813     } CALL_CATCH_EXCEPTION(0);
12814   }
12815
12816   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12817   return jresult;
12818 }
12819
12820
12821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
12822   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12823   Dali::PropertyNotification arg2 ;
12824   Dali::PropertyNotification *argp2 ;
12825
12826   arg1 = (Dali::Handle *)jarg1;
12827   argp2 = (Dali::PropertyNotification *)jarg2;
12828   if (!argp2) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
12830     return ;
12831   }
12832   arg2 = *argp2;
12833   {
12834     try {
12835       (arg1)->RemovePropertyNotification(arg2);
12836     } CALL_CATCH_EXCEPTION();
12837   }
12838
12839 }
12840
12841
12842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
12843   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12844
12845   arg1 = (Dali::Handle *)jarg1;
12846   {
12847     try {
12848       (arg1)->RemovePropertyNotifications();
12849     } CALL_CATCH_EXCEPTION();
12850   }
12851
12852 }
12853
12854
12855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
12856   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12857
12858   arg1 = (Dali::Handle *)jarg1;
12859   {
12860     try {
12861       (arg1)->RemoveConstraints();
12862     } CALL_CATCH_EXCEPTION();
12863   }
12864
12865 }
12866
12867
12868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
12869   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12870   unsigned int arg2 ;
12871
12872   arg1 = (Dali::Handle *)jarg1;
12873   arg2 = (unsigned int)jarg2;
12874   {
12875     try {
12876       (arg1)->RemoveConstraints(arg2);
12877     } CALL_CATCH_EXCEPTION();
12878   }
12879
12880 }
12881
12882
12883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
12884   int jresult ;
12885   Dali::Property::Index result;
12886
12887   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
12888   jresult = result;
12889   return jresult;
12890 }
12891
12892
12893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
12894   void * jresult ;
12895   Dali::Handle result;
12896
12897   {
12898     try {
12899       result = Dali::WeightObject::New();
12900     } CALL_CATCH_EXCEPTION(0);
12901   }
12902
12903   jresult = new Dali::Handle((const Dali::Handle &)result);
12904   return jresult;
12905 }
12906
12907
12908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
12909   void * jresult ;
12910   Dali::TypeInfo *result = 0 ;
12911
12912   {
12913     try {
12914       result = (Dali::TypeInfo *)new Dali::TypeInfo();
12915     } CALL_CATCH_EXCEPTION(0);
12916   }
12917
12918   jresult = (void *)result;
12919   return jresult;
12920 }
12921
12922
12923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
12924   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12925
12926   arg1 = (Dali::TypeInfo *)jarg1;
12927   {
12928     try {
12929       delete arg1;
12930     } CALL_CATCH_EXCEPTION();
12931   }
12932
12933 }
12934
12935
12936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
12937   void * jresult ;
12938   Dali::TypeInfo *arg1 = 0 ;
12939   Dali::TypeInfo *result = 0 ;
12940
12941   arg1 = (Dali::TypeInfo *)jarg1;
12942   if (!arg1) {
12943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
12944     return 0;
12945   }
12946   {
12947     try {
12948       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
12949     } CALL_CATCH_EXCEPTION(0);
12950   }
12951
12952   jresult = (void *)result;
12953   return jresult;
12954 }
12955
12956
12957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
12958   void * jresult ;
12959   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12960   Dali::TypeInfo *arg2 = 0 ;
12961   Dali::TypeInfo *result = 0 ;
12962
12963   arg1 = (Dali::TypeInfo *)jarg1;
12964   arg2 = (Dali::TypeInfo *)jarg2;
12965   if (!arg2) {
12966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
12967     return 0;
12968   }
12969   {
12970     try {
12971       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
12972     } CALL_CATCH_EXCEPTION(0);
12973   }
12974
12975   jresult = (void *)result;
12976   return jresult;
12977 }
12978
12979
12980 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
12981   char * jresult ;
12982   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12983   std::string *result = 0 ;
12984
12985   arg1 = (Dali::TypeInfo *)jarg1;
12986   {
12987     try {
12988       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
12989     } CALL_CATCH_EXCEPTION(0);
12990   }
12991
12992   jresult = SWIG_csharp_string_callback(result->c_str());
12993   return jresult;
12994 }
12995
12996
12997 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
12998   char * jresult ;
12999   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13000   std::string *result = 0 ;
13001
13002   arg1 = (Dali::TypeInfo *)jarg1;
13003   {
13004     try {
13005       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13006     } CALL_CATCH_EXCEPTION(0);
13007   }
13008
13009   jresult = SWIG_csharp_string_callback(result->c_str());
13010   return jresult;
13011 }
13012
13013
13014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13015   void * jresult ;
13016   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13017   Dali::BaseHandle result;
13018
13019   arg1 = (Dali::TypeInfo *)jarg1;
13020   {
13021     try {
13022       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13023     } CALL_CATCH_EXCEPTION(0);
13024   }
13025
13026   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13027   return jresult;
13028 }
13029
13030
13031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13032   unsigned long jresult ;
13033   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13034   size_t result;
13035
13036   arg1 = (Dali::TypeInfo *)jarg1;
13037   {
13038     try {
13039       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13040     } CALL_CATCH_EXCEPTION(0);
13041   }
13042
13043   jresult = (unsigned long)result;
13044   return jresult;
13045 }
13046
13047
13048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13049   char * jresult ;
13050   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13051   size_t arg2 ;
13052   std::string result;
13053
13054   arg1 = (Dali::TypeInfo *)jarg1;
13055   arg2 = (size_t)jarg2;
13056   {
13057     try {
13058       result = (arg1)->GetActionName(arg2);
13059     } CALL_CATCH_EXCEPTION(0);
13060   }
13061
13062   jresult = SWIG_csharp_string_callback((&result)->c_str());
13063   return jresult;
13064 }
13065
13066
13067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13068   unsigned long jresult ;
13069   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13070   size_t result;
13071
13072   arg1 = (Dali::TypeInfo *)jarg1;
13073   {
13074     try {
13075       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13076     } CALL_CATCH_EXCEPTION(0);
13077   }
13078
13079   jresult = (unsigned long)result;
13080   return jresult;
13081 }
13082
13083
13084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13085   char * jresult ;
13086   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13087   size_t arg2 ;
13088   std::string result;
13089
13090   arg1 = (Dali::TypeInfo *)jarg1;
13091   arg2 = (size_t)jarg2;
13092   {
13093     try {
13094       result = (arg1)->GetSignalName(arg2);
13095     } CALL_CATCH_EXCEPTION(0);
13096   }
13097
13098   jresult = SWIG_csharp_string_callback((&result)->c_str());
13099   return jresult;
13100 }
13101
13102
13103 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13104   unsigned long jresult ;
13105   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13106   size_t result;
13107
13108   arg1 = (Dali::TypeInfo *)jarg1;
13109   {
13110     try {
13111       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13112     } CALL_CATCH_EXCEPTION(0);
13113   }
13114
13115   jresult = (unsigned long)result;
13116   return jresult;
13117 }
13118
13119
13120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13121   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13122   Dali::Property::IndexContainer *arg2 = 0 ;
13123
13124   arg1 = (Dali::TypeInfo *)jarg1;
13125   arg2 = (Dali::Property::IndexContainer *)jarg2;
13126   if (!arg2) {
13127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13128     return ;
13129   }
13130   {
13131     try {
13132       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13133     } CALL_CATCH_EXCEPTION();
13134   }
13135
13136 }
13137
13138
13139 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13140   char * jresult ;
13141   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13142   Dali::Property::Index arg2 ;
13143   std::string_view result;
13144
13145   arg1 = (Dali::TypeInfo *)jarg1;
13146   arg2 = (Dali::Property::Index)jarg2;
13147   {
13148     try {
13149       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13150     } CALL_CATCH_EXCEPTION(0);
13151   }
13152
13153   jresult = SWIG_csharp_string_callback(result.data());
13154   return jresult;
13155 }
13156
13157
13158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13159   void * jresult ;
13160   Dali::TypeRegistry result;
13161
13162   {
13163     try {
13164       result = Dali::TypeRegistry::Get();
13165     } CALL_CATCH_EXCEPTION(0);
13166   }
13167
13168   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13169   return jresult;
13170 }
13171
13172
13173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13174   void * jresult ;
13175   Dali::TypeRegistry *result = 0 ;
13176
13177   {
13178     try {
13179       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13180     } CALL_CATCH_EXCEPTION(0);
13181   }
13182
13183   jresult = (void *)result;
13184   return jresult;
13185 }
13186
13187
13188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13189   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13190
13191   arg1 = (Dali::TypeRegistry *)jarg1;
13192   {
13193     try {
13194       delete arg1;
13195     } CALL_CATCH_EXCEPTION();
13196   }
13197
13198 }
13199
13200
13201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13202   void * jresult ;
13203   Dali::TypeRegistry *arg1 = 0 ;
13204   Dali::TypeRegistry *result = 0 ;
13205
13206   arg1 = (Dali::TypeRegistry *)jarg1;
13207   if (!arg1) {
13208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13209     return 0;
13210   }
13211   {
13212     try {
13213       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13214     } CALL_CATCH_EXCEPTION(0);
13215   }
13216
13217   jresult = (void *)result;
13218   return jresult;
13219 }
13220
13221
13222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13223   void * jresult ;
13224   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13225   Dali::TypeRegistry *arg2 = 0 ;
13226   Dali::TypeRegistry *result = 0 ;
13227
13228   arg1 = (Dali::TypeRegistry *)jarg1;
13229   arg2 = (Dali::TypeRegistry *)jarg2;
13230   if (!arg2) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13232     return 0;
13233   }
13234   {
13235     try {
13236       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13237     } CALL_CATCH_EXCEPTION(0);
13238   }
13239
13240   jresult = (void *)result;
13241   return jresult;
13242 }
13243
13244
13245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13246   void * jresult ;
13247   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13248   std::string *arg2 = 0 ;
13249   Dali::TypeInfo result;
13250
13251   arg1 = (Dali::TypeRegistry *)jarg1;
13252   if (!jarg2) {
13253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13254     return 0;
13255   }
13256   std::string arg2_str(jarg2);
13257   arg2 = &arg2_str;
13258   {
13259     try {
13260       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13261     } CALL_CATCH_EXCEPTION(0);
13262   }
13263
13264   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13265
13266   //argout typemap for const std::string&
13267
13268   return jresult;
13269 }
13270
13271
13272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13273   void * jresult ;
13274   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13275   std::type_info *arg2 = 0 ;
13276   Dali::TypeInfo result;
13277
13278   arg1 = (Dali::TypeRegistry *)jarg1;
13279   arg2 = (std::type_info *)jarg2;
13280   if (!arg2) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13282     return 0;
13283   }
13284   {
13285     try {
13286       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13287     } CALL_CATCH_EXCEPTION(0);
13288   }
13289
13290   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13296   unsigned long jresult ;
13297   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13298   size_t result;
13299
13300   arg1 = (Dali::TypeRegistry *)jarg1;
13301   {
13302     try {
13303       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13304     } CALL_CATCH_EXCEPTION(0);
13305   }
13306
13307   jresult = (unsigned long)result;
13308   return jresult;
13309 }
13310
13311
13312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13313   char * jresult ;
13314   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13315   size_t arg2 ;
13316   std::string result;
13317
13318   arg1 = (Dali::TypeRegistry *)jarg1;
13319   arg2 = (size_t)jarg2;
13320   {
13321     try {
13322       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13323     } CALL_CATCH_EXCEPTION(0);
13324   }
13325
13326   jresult = SWIG_csharp_string_callback((&result)->c_str());
13327   return jresult;
13328 }
13329
13330
13331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13332   void * jresult ;
13333   std::type_info *arg1 = 0 ;
13334   std::type_info *arg2 = 0 ;
13335   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13336   Dali::TypeRegistration *result = 0 ;
13337
13338   arg1 = (std::type_info *)jarg1;
13339   if (!arg1) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13341     return 0;
13342   }
13343   arg2 = (std::type_info *)jarg2;
13344   if (!arg2) {
13345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13346     return 0;
13347   }
13348   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13349   {
13350     try {
13351       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13352     } CALL_CATCH_EXCEPTION(0);
13353   }
13354
13355   jresult = (void *)result;
13356   return jresult;
13357 }
13358
13359
13360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
13361   void * jresult ;
13362   std::type_info *arg1 = 0 ;
13363   std::type_info *arg2 = 0 ;
13364   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13365   bool arg4 ;
13366   Dali::TypeRegistration *result = 0 ;
13367
13368   arg1 = (std::type_info *)jarg1;
13369   if (!arg1) {
13370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13371     return 0;
13372   }
13373   arg2 = (std::type_info *)jarg2;
13374   if (!arg2) {
13375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13376     return 0;
13377   }
13378   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13379   arg4 = jarg4 ? true : false;
13380   {
13381     try {
13382       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13383     } CALL_CATCH_EXCEPTION(0);
13384   }
13385
13386   jresult = (void *)result;
13387   return jresult;
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13392   void * jresult ;
13393   std::string *arg1 = 0 ;
13394   std::type_info *arg2 = 0 ;
13395   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13396   Dali::TypeRegistration *result = 0 ;
13397
13398   if (!jarg1) {
13399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13400     return 0;
13401   }
13402   std::string arg1_str(jarg1);
13403   arg1 = &arg1_str;
13404   arg2 = (std::type_info *)jarg2;
13405   if (!arg2) {
13406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13407     return 0;
13408   }
13409   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13410   {
13411     try {
13412       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13413     } CALL_CATCH_EXCEPTION(0);
13414   }
13415
13416   jresult = (void *)result;
13417
13418   //argout typemap for const std::string&
13419
13420   return jresult;
13421 }
13422
13423
13424 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
13425   char * jresult ;
13426   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13427   std::string result;
13428
13429   arg1 = (Dali::TypeRegistration *)jarg1;
13430   {
13431     try {
13432       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
13433     } CALL_CATCH_EXCEPTION(0);
13434   }
13435
13436   jresult = SWIG_csharp_string_callback((&result)->c_str());
13437   return jresult;
13438 }
13439
13440
13441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
13442   std::string *arg1 = 0 ;
13443   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13444
13445   if (!jarg1) {
13446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13447     return ;
13448   }
13449   std::string arg1_str(jarg1);
13450   arg1 = &arg1_str;
13451   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
13452   {
13453     try {
13454       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
13455     } CALL_CATCH_EXCEPTION();
13456   }
13457
13458
13459   //argout typemap for const std::string&
13460
13461 }
13462
13463
13464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13465   std::string *arg1 = 0 ;
13466   std::string *arg2 = 0 ;
13467   int arg3 ;
13468   Dali::Property::Type arg4 ;
13469   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
13470   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
13471
13472   if (!jarg1) {
13473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13474     return ;
13475   }
13476   std::string arg1_str(jarg1);
13477   arg1 = &arg1_str;
13478   if (!jarg2) {
13479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13480     return ;
13481   }
13482   std::string arg2_str(jarg2);
13483   arg2 = &arg2_str;
13484   arg3 = (int)jarg3;
13485   arg4 = (Dali::Property::Type)jarg4;
13486   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
13487   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
13488   {
13489     try {
13490       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13491     } CALL_CATCH_EXCEPTION();
13492   }
13493
13494
13495   //argout typemap for const std::string&
13496
13497
13498   //argout typemap for const std::string&
13499
13500 }
13501
13502
13503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
13504   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13505
13506   arg1 = (Dali::TypeRegistration *)jarg1;
13507   {
13508     try {
13509       delete arg1;
13510     } CALL_CATCH_EXCEPTION();
13511   }
13512
13513 }
13514
13515
13516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
13517   void * jresult ;
13518   Dali::TypeRegistration *arg1 = 0 ;
13519   std::string *arg2 = 0 ;
13520   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
13521   Dali::SignalConnectorType *result = 0 ;
13522
13523   arg1 = (Dali::TypeRegistration *)jarg1;
13524   if (!arg1) {
13525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13526     return 0;
13527   }
13528   if (!jarg2) {
13529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13530     return 0;
13531   }
13532   std::string arg2_str(jarg2);
13533   arg2 = &arg2_str;
13534   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
13535   {
13536     try {
13537       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
13538     } CALL_CATCH_EXCEPTION(0);
13539   }
13540
13541   jresult = (void *)result;
13542
13543   //argout typemap for const std::string&
13544
13545   return jresult;
13546 }
13547
13548
13549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
13550   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
13551
13552   arg1 = (Dali::SignalConnectorType *)jarg1;
13553   {
13554     try {
13555       delete arg1;
13556     } CALL_CATCH_EXCEPTION();
13557   }
13558
13559 }
13560
13561
13562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
13563   void * jresult ;
13564   Dali::TypeRegistration *arg1 = 0 ;
13565   std::string *arg2 = 0 ;
13566   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
13567   Dali::TypeAction *result = 0 ;
13568
13569   arg1 = (Dali::TypeRegistration *)jarg1;
13570   if (!arg1) {
13571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13572     return 0;
13573   }
13574   if (!jarg2) {
13575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13576     return 0;
13577   }
13578   std::string arg2_str(jarg2);
13579   arg2 = &arg2_str;
13580   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
13581   {
13582     try {
13583       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
13584     } CALL_CATCH_EXCEPTION(0);
13585   }
13586
13587   jresult = (void *)result;
13588
13589   //argout typemap for const std::string&
13590
13591   return jresult;
13592 }
13593
13594
13595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
13596   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
13597
13598   arg1 = (Dali::TypeAction *)jarg1;
13599   {
13600     try {
13601       delete arg1;
13602     } CALL_CATCH_EXCEPTION();
13603   }
13604
13605 }
13606
13607
13608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13609   void * jresult ;
13610   Dali::TypeRegistration *arg1 = 0 ;
13611   std::string *arg2 = 0 ;
13612   Dali::Property::Index arg3 ;
13613   Dali::Property::Type arg4 ;
13614   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
13615   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
13616   Dali::PropertyRegistration *result = 0 ;
13617
13618   arg1 = (Dali::TypeRegistration *)jarg1;
13619   if (!arg1) {
13620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13621     return 0;
13622   }
13623   if (!jarg2) {
13624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13625     return 0;
13626   }
13627   std::string arg2_str(jarg2);
13628   arg2 = &arg2_str;
13629   arg3 = (Dali::Property::Index)jarg3;
13630   arg4 = (Dali::Property::Type)jarg4;
13631   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
13632   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
13633   {
13634     try {
13635       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13636     } CALL_CATCH_EXCEPTION(0);
13637   }
13638
13639   jresult = (void *)result;
13640
13641   //argout typemap for const std::string&
13642
13643   return jresult;
13644 }
13645
13646
13647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
13648   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
13649
13650   arg1 = (Dali::PropertyRegistration *)jarg1;
13651   {
13652     try {
13653       delete arg1;
13654     } CALL_CATCH_EXCEPTION();
13655   }
13656
13657 }
13658
13659
13660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13661   void * jresult ;
13662   Dali::TypeRegistration *arg1 = 0 ;
13663   std::string *arg2 = 0 ;
13664   Dali::Property::Index arg3 ;
13665   Dali::Property::Type arg4 ;
13666   Dali::AnimatablePropertyRegistration *result = 0 ;
13667
13668   arg1 = (Dali::TypeRegistration *)jarg1;
13669   if (!arg1) {
13670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13671     return 0;
13672   }
13673   if (!jarg2) {
13674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13675     return 0;
13676   }
13677   std::string arg2_str(jarg2);
13678   arg2 = &arg2_str;
13679   arg3 = (Dali::Property::Index)jarg3;
13680   arg4 = (Dali::Property::Type)jarg4;
13681   {
13682     try {
13683       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13684     } CALL_CATCH_EXCEPTION(0);
13685   }
13686
13687   jresult = (void *)result;
13688
13689   //argout typemap for const std::string&
13690
13691   return jresult;
13692 }
13693
13694
13695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
13696   void * jresult ;
13697   Dali::TypeRegistration *arg1 = 0 ;
13698   std::string *arg2 = 0 ;
13699   Dali::Property::Index arg3 ;
13700   Dali::Property::Value *arg4 = 0 ;
13701   Dali::AnimatablePropertyRegistration *result = 0 ;
13702
13703   arg1 = (Dali::TypeRegistration *)jarg1;
13704   if (!arg1) {
13705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13706     return 0;
13707   }
13708   if (!jarg2) {
13709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13710     return 0;
13711   }
13712   std::string arg2_str(jarg2);
13713   arg2 = &arg2_str;
13714   arg3 = (Dali::Property::Index)jarg3;
13715   arg4 = (Dali::Property::Value *)jarg4;
13716   if (!arg4) {
13717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13718     return 0;
13719   }
13720   {
13721     try {
13722       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
13723     } CALL_CATCH_EXCEPTION(0);
13724   }
13725
13726   jresult = (void *)result;
13727
13728   //argout typemap for const std::string&
13729
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
13735   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
13736
13737   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
13738   {
13739     try {
13740       delete arg1;
13741     } CALL_CATCH_EXCEPTION();
13742   }
13743
13744 }
13745
13746
13747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
13748   void * jresult ;
13749   Dali::TypeRegistration *arg1 = 0 ;
13750   std::string *arg2 = 0 ;
13751   Dali::Property::Index arg3 ;
13752   Dali::Property::Index arg4 ;
13753   unsigned int arg5 ;
13754   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
13755
13756   arg1 = (Dali::TypeRegistration *)jarg1;
13757   if (!arg1) {
13758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13759     return 0;
13760   }
13761   if (!jarg2) {
13762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13763     return 0;
13764   }
13765   std::string arg2_str(jarg2);
13766   arg2 = &arg2_str;
13767   arg3 = (Dali::Property::Index)jarg3;
13768   arg4 = (Dali::Property::Index)jarg4;
13769   arg5 = (unsigned int)jarg5;
13770   {
13771     try {
13772       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
13773     } CALL_CATCH_EXCEPTION(0);
13774   }
13775
13776   jresult = (void *)result;
13777
13778   //argout typemap for const std::string&
13779
13780   return jresult;
13781 }
13782
13783
13784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
13785   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
13786
13787   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
13788   {
13789     try {
13790       delete arg1;
13791     } CALL_CATCH_EXCEPTION();
13792   }
13793
13794 }
13795
13796
13797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13798   void * jresult ;
13799   Dali::TypeRegistration *arg1 = 0 ;
13800   std::string *arg2 = 0 ;
13801   Dali::Property::Index arg3 ;
13802   Dali::Property::Type arg4 ;
13803   Dali::ChildPropertyRegistration *result = 0 ;
13804
13805   arg1 = (Dali::TypeRegistration *)jarg1;
13806   if (!arg1) {
13807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13808     return 0;
13809   }
13810   if (!jarg2) {
13811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13812     return 0;
13813   }
13814   std::string arg2_str(jarg2);
13815   arg2 = &arg2_str;
13816   arg3 = (Dali::Property::Index)jarg3;
13817   arg4 = (Dali::Property::Type)jarg4;
13818   {
13819     try {
13820       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13821     } CALL_CATCH_EXCEPTION(0);
13822   }
13823
13824   jresult = (void *)result;
13825
13826   //argout typemap for const std::string&
13827
13828   return jresult;
13829 }
13830
13831
13832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
13833   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
13834
13835   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
13836   {
13837     try {
13838       delete arg1;
13839     } CALL_CATCH_EXCEPTION();
13840   }
13841
13842 }
13843
13844
13845 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
13846   bool jresult ;
13847   std::string *arg1 = 0 ;
13848   std::type_info *arg2 = 0 ;
13849   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13850   bool result;
13851
13852   if (!jarg1) {
13853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13854     return 0;
13855   }
13856   std::string arg1_str(jarg1);
13857   arg1 = &arg1_str;
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   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
13864   {
13865     try {
13866       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13867     } CALL_CATCH_EXCEPTION(0);
13868   }
13869
13870   jresult = result;
13871
13872   //argout typemap for const std::string&
13873
13874   return jresult;
13875 }
13876
13877
13878 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13879   bool jresult ;
13880   std::string *arg1 = 0 ;
13881   std::string *arg2 = 0 ;
13882   Dali::Property::Index arg3 ;
13883   Dali::Property::Type arg4 ;
13884   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
13885   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
13886   bool result;
13887
13888   if (!jarg1) {
13889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13890     return 0;
13891   }
13892   std::string arg1_str(jarg1);
13893   arg1 = &arg1_str;
13894   if (!jarg2) {
13895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13896     return 0;
13897   }
13898   std::string arg2_str(jarg2);
13899   arg2 = &arg2_str;
13900   arg3 = (Dali::Property::Index)jarg3;
13901   arg4 = (Dali::Property::Type)jarg4;
13902   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
13903   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
13904   {
13905     try {
13906       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13907     } CALL_CATCH_EXCEPTION(0);
13908   }
13909
13910   jresult = result;
13911
13912   //argout typemap for const std::string&
13913
13914
13915   //argout typemap for const std::string&
13916
13917   return jresult;
13918 }
13919
13920
13921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
13922   float jresult ;
13923   float result;
13924
13925   result = (float)(float)Dali::ParentOrigin::TOP;
13926   jresult = result;
13927   return jresult;
13928 }
13929
13930
13931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
13932   float jresult ;
13933   float result;
13934
13935   result = (float)(float)Dali::ParentOrigin::BOTTOM;
13936   jresult = result;
13937   return jresult;
13938 }
13939
13940
13941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
13942   float jresult ;
13943   float result;
13944
13945   result = (float)(float)Dali::ParentOrigin::LEFT;
13946   jresult = result;
13947   return jresult;
13948 }
13949
13950
13951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
13952   float jresult ;
13953   float result;
13954
13955   result = (float)(float)Dali::ParentOrigin::RIGHT;
13956   jresult = result;
13957   return jresult;
13958 }
13959
13960
13961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
13962   float jresult ;
13963   float result;
13964
13965   result = (float)(float)Dali::ParentOrigin::MIDDLE;
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
13972   void * jresult ;
13973   Dali::Vector3 *result = 0 ;
13974
13975   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
13976   jresult = (void *)result;
13977   return jresult;
13978 }
13979
13980
13981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
13982   void * jresult ;
13983   Dali::Vector3 *result = 0 ;
13984
13985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
13986   jresult = (void *)result;
13987   return jresult;
13988 }
13989
13990
13991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
13992   void * jresult ;
13993   Dali::Vector3 *result = 0 ;
13994
13995   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
13996   jresult = (void *)result;
13997   return jresult;
13998 }
13999
14000
14001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14002   void * jresult ;
14003   Dali::Vector3 *result = 0 ;
14004
14005   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14006   jresult = (void *)result;
14007   return jresult;
14008 }
14009
14010
14011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14012   void * jresult ;
14013   Dali::Vector3 *result = 0 ;
14014
14015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14016   jresult = (void *)result;
14017   return jresult;
14018 }
14019
14020
14021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14022   void * jresult ;
14023   Dali::Vector3 *result = 0 ;
14024
14025   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14026   jresult = (void *)result;
14027   return jresult;
14028 }
14029
14030
14031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14032   void * jresult ;
14033   Dali::Vector3 *result = 0 ;
14034
14035   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14036   jresult = (void *)result;
14037   return jresult;
14038 }
14039
14040
14041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14042   void * jresult ;
14043   Dali::Vector3 *result = 0 ;
14044
14045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14046   jresult = (void *)result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14052   void * jresult ;
14053   Dali::Vector3 *result = 0 ;
14054
14055   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14056   jresult = (void *)result;
14057   return jresult;
14058 }
14059
14060
14061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14062   float jresult ;
14063   float result;
14064
14065   result = (float)(float)Dali::AnchorPoint::TOP;
14066   jresult = result;
14067   return jresult;
14068 }
14069
14070
14071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14072   float jresult ;
14073   float result;
14074
14075   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14076   jresult = result;
14077   return jresult;
14078 }
14079
14080
14081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14082   float jresult ;
14083   float result;
14084
14085   result = (float)(float)Dali::AnchorPoint::LEFT;
14086   jresult = result;
14087   return jresult;
14088 }
14089
14090
14091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14092   float jresult ;
14093   float result;
14094
14095   result = (float)(float)Dali::AnchorPoint::RIGHT;
14096   jresult = result;
14097   return jresult;
14098 }
14099
14100
14101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14102   float jresult ;
14103   float result;
14104
14105   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14106   jresult = result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14112   void * jresult ;
14113   Dali::Vector3 *result = 0 ;
14114
14115   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14116   jresult = (void *)result;
14117   return jresult;
14118 }
14119
14120
14121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14122   void * jresult ;
14123   Dali::Vector3 *result = 0 ;
14124
14125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14126   jresult = (void *)result;
14127   return jresult;
14128 }
14129
14130
14131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14132   void * jresult ;
14133   Dali::Vector3 *result = 0 ;
14134
14135   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14136   jresult = (void *)result;
14137   return jresult;
14138 }
14139
14140
14141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14142   void * jresult ;
14143   Dali::Vector3 *result = 0 ;
14144
14145   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14146   jresult = (void *)result;
14147   return jresult;
14148 }
14149
14150
14151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14152   void * jresult ;
14153   Dali::Vector3 *result = 0 ;
14154
14155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14156   jresult = (void *)result;
14157   return jresult;
14158 }
14159
14160
14161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14162   void * jresult ;
14163   Dali::Vector3 *result = 0 ;
14164
14165   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14166   jresult = (void *)result;
14167   return jresult;
14168 }
14169
14170
14171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14172   void * jresult ;
14173   Dali::Vector3 *result = 0 ;
14174
14175   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14176   jresult = (void *)result;
14177   return jresult;
14178 }
14179
14180
14181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14182   void * jresult ;
14183   Dali::Vector3 *result = 0 ;
14184
14185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14186   jresult = (void *)result;
14187   return jresult;
14188 }
14189
14190
14191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14192   void * jresult ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14196   jresult = (void *)result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() {
14202   void * jresult;
14203   Dali::Vector4 *result = 0 ;
14204
14205   result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE;
14206   jresult = (void *)result;
14207   return jresult;
14208 }
14209
14210
14211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() {
14212   void * jresult;
14213   Dali::Vector4 *result = 0 ;
14214
14215   result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE;
14216   jresult = (void *)result;
14217   return jresult;
14218 }
14219
14220
14221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() {
14222   void * jresult;
14223   Dali::Vector4 *result = 0 ;
14224
14225   result = (Dali::Vector4 *)&Dali::Color::AQUA;
14226   jresult = (void *)result;
14227   return jresult;
14228 }
14229
14230
14231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() {
14232   void * jresult;
14233   Dali::Vector4 *result = 0 ;
14234
14235   result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE;
14236   jresult = (void *)result;
14237   return jresult;
14238 }
14239
14240
14241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() {
14242   void * jresult;
14243   Dali::Vector4 *result = 0 ;
14244
14245   result = (Dali::Vector4 *)&Dali::Color::AZURE;
14246   jresult = (void *)result;
14247   return jresult;
14248 }
14249
14250
14251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() {
14252   void * jresult;
14253   Dali::Vector4 *result = 0 ;
14254
14255   result = (Dali::Vector4 *)&Dali::Color::BEIGE;
14256   jresult = (void *)result;
14257   return jresult;
14258 }
14259
14260
14261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() {
14262   void * jresult;
14263   Dali::Vector4 *result = 0 ;
14264
14265   result = (Dali::Vector4 *)&Dali::Color::BISQUE;
14266   jresult = (void *)result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14272   void * jresult;
14273   Dali::Vector4 *result = 0 ;
14274
14275   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14276   jresult = (void *)result;
14277   return jresult;
14278 }
14279
14280
14281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() {
14282   void * jresult;
14283   Dali::Vector4 *result = 0 ;
14284
14285   result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND;
14286   jresult = (void *)result;
14287   return jresult;
14288 }
14289
14290
14291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14292   void * jresult;
14293   Dali::Vector4 *result = 0 ;
14294
14295   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14296   jresult = (void *)result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() {
14302   void * jresult;
14303   Dali::Vector4 *result = 0 ;
14304
14305   result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET;
14306   jresult = (void *)result;
14307   return jresult;
14308 }
14309
14310
14311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() {
14312   void * jresult;
14313   Dali::Vector4 *result = 0 ;
14314
14315   result = (Dali::Vector4 *)&Dali::Color::BROWN;
14316   jresult = (void *)result;
14317   return jresult;
14318 }
14319
14320
14321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() {
14322   void * jresult;
14323   Dali::Vector4 *result = 0 ;
14324
14325   result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD;
14326   jresult = (void *)result;
14327   return jresult;
14328 }
14329
14330
14331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() {
14332   void * jresult;
14333   Dali::Vector4 *result = 0 ;
14334
14335   result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE;
14336   jresult = (void *)result;
14337   return jresult;
14338 }
14339
14340
14341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() {
14342   void * jresult;
14343   Dali::Vector4 *result = 0 ;
14344
14345   result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE;
14346   jresult = (void *)result;
14347   return jresult;
14348 }
14349
14350
14351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() {
14352   void * jresult;
14353   Dali::Vector4 *result = 0 ;
14354
14355   result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE;
14356   jresult = (void *)result;
14357   return jresult;
14358 }
14359
14360
14361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() {
14362   void * jresult;
14363   Dali::Vector4 *result = 0 ;
14364
14365   result = (Dali::Vector4 *)&Dali::Color::CORAL;
14366   jresult = (void *)result;
14367   return jresult;
14368 }
14369
14370
14371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() {
14372   void * jresult;
14373   Dali::Vector4 *result = 0 ;
14374
14375   result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE;
14376   jresult = (void *)result;
14377   return jresult;
14378 }
14379
14380
14381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() {
14382   void * jresult;
14383   Dali::Vector4 *result = 0 ;
14384
14385   result = (Dali::Vector4 *)&Dali::Color::CORNSILK;
14386   jresult = (void *)result;
14387   return jresult;
14388 }
14389
14390
14391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() {
14392   void * jresult;
14393   Dali::Vector4 *result = 0 ;
14394
14395   result = (Dali::Vector4 *)&Dali::Color::CRIMSON;
14396   jresult = (void *)result;
14397   return jresult;
14398 }
14399
14400
14401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14402   void * jresult;
14403   Dali::Vector4 *result = 0 ;
14404
14405   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14406   jresult = (void *)result;
14407   return jresult;
14408 }
14409
14410
14411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() {
14412   void * jresult;
14413   Dali::Vector4 *result = 0 ;
14414
14415   result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE;
14416   jresult = (void *)result;
14417   return jresult;
14418 }
14419
14420
14421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() {
14422   void * jresult;
14423   Dali::Vector4 *result = 0 ;
14424
14425   result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN;
14426   jresult = (void *)result;
14427   return jresult;
14428 }
14429
14430
14431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() {
14432   void * jresult;
14433   Dali::Vector4 *result = 0 ;
14434
14435   result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD;
14436   jresult = (void *)result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() {
14442   void * jresult;
14443   Dali::Vector4 *result = 0 ;
14444
14445   result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY;
14446   jresult = (void *)result;
14447   return jresult;
14448 }
14449
14450
14451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() {
14452   void * jresult;
14453   Dali::Vector4 *result = 0 ;
14454
14455   result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN;
14456   jresult = (void *)result;
14457   return jresult;
14458 }
14459
14460
14461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() {
14462   void * jresult;
14463   Dali::Vector4 *result = 0 ;
14464
14465   result = (Dali::Vector4 *)&Dali::Color::DARK_GREY;
14466   jresult = (void *)result;
14467   return jresult;
14468 }
14469
14470
14471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() {
14472   void * jresult;
14473   Dali::Vector4 *result = 0 ;
14474
14475   result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI;
14476   jresult = (void *)result;
14477   return jresult;
14478 }
14479
14480
14481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() {
14482   void * jresult;
14483   Dali::Vector4 *result = 0 ;
14484
14485   result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA;
14486   jresult = (void *)result;
14487   return jresult;
14488 }
14489
14490
14491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() {
14492   void * jresult;
14493   Dali::Vector4 *result = 0 ;
14494
14495   result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN;
14496   jresult = (void *)result;
14497   return jresult;
14498 }
14499
14500
14501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() {
14502   void * jresult;
14503   Dali::Vector4 *result = 0 ;
14504
14505   result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE;
14506   jresult = (void *)result;
14507   return jresult;
14508 }
14509
14510
14511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() {
14512   void * jresult;
14513   Dali::Vector4 *result = 0 ;
14514
14515   result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID;
14516   jresult = (void *)result;
14517   return jresult;
14518 }
14519
14520
14521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() {
14522   void * jresult;
14523   Dali::Vector4 *result = 0 ;
14524
14525   result = (Dali::Vector4 *)&Dali::Color::DARK_RED;
14526   jresult = (void *)result;
14527   return jresult;
14528 }
14529
14530
14531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() {
14532   void * jresult;
14533   Dali::Vector4 *result = 0 ;
14534
14535   result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON;
14536   jresult = (void *)result;
14537   return jresult;
14538 }
14539
14540
14541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() {
14542   void * jresult;
14543   Dali::Vector4 *result = 0 ;
14544
14545   result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN;
14546   jresult = (void *)result;
14547   return jresult;
14548 }
14549
14550
14551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() {
14552   void * jresult;
14553   Dali::Vector4 *result = 0 ;
14554
14555   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE;
14556   jresult = (void *)result;
14557   return jresult;
14558 }
14559
14560
14561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() {
14562   void * jresult;
14563   Dali::Vector4 *result = 0 ;
14564
14565   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY;
14566   jresult = (void *)result;
14567   return jresult;
14568 }
14569
14570
14571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() {
14572   void * jresult;
14573   Dali::Vector4 *result = 0 ;
14574
14575   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY;
14576   jresult = (void *)result;
14577   return jresult;
14578 }
14579
14580
14581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() {
14582   void * jresult;
14583   Dali::Vector4 *result = 0 ;
14584
14585   result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE;
14586   jresult = (void *)result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() {
14592   void * jresult;
14593   Dali::Vector4 *result = 0 ;
14594
14595   result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET;
14596   jresult = (void *)result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() {
14602   void * jresult;
14603   Dali::Vector4 *result = 0 ;
14604
14605   result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK;
14606   jresult = (void *)result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() {
14612   void * jresult;
14613   Dali::Vector4 *result = 0 ;
14614
14615   result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE;
14616   jresult = (void *)result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() {
14622   void * jresult;
14623   Dali::Vector4 *result = 0 ;
14624
14625   result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY;
14626   jresult = (void *)result;
14627   return jresult;
14628 }
14629
14630
14631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() {
14632   void * jresult;
14633   Dali::Vector4 *result = 0 ;
14634
14635   result = (Dali::Vector4 *)&Dali::Color::DIM_GREY;
14636   jresult = (void *)result;
14637   return jresult;
14638 }
14639
14640
14641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() {
14642   void * jresult;
14643   Dali::Vector4 *result = 0 ;
14644
14645   result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE;
14646   jresult = (void *)result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() {
14652   void * jresult;
14653   Dali::Vector4 *result = 0 ;
14654
14655   result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK;
14656   jresult = (void *)result;
14657   return jresult;
14658 }
14659
14660
14661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() {
14662   void * jresult;
14663   Dali::Vector4 *result = 0 ;
14664
14665   result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE;
14666   jresult = (void *)result;
14667   return jresult;
14668 }
14669
14670
14671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() {
14672   void * jresult;
14673   Dali::Vector4 *result = 0 ;
14674
14675   result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN;
14676   jresult = (void *)result;
14677   return jresult;
14678 }
14679
14680
14681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() {
14682   void * jresult;
14683   Dali::Vector4 *result = 0 ;
14684
14685   result = (Dali::Vector4 *)&Dali::Color::FUCHSIA;
14686   jresult = (void *)result;
14687   return jresult;
14688 }
14689
14690
14691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() {
14692   void * jresult;
14693   Dali::Vector4 *result = 0 ;
14694
14695   result = (Dali::Vector4 *)&Dali::Color::GAINSBORO;
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() {
14702   void * jresult;
14703   Dali::Vector4 *result = 0 ;
14704
14705   result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE;
14706   jresult = (void *)result;
14707   return jresult;
14708 }
14709
14710
14711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() {
14712   void * jresult;
14713   Dali::Vector4 *result = 0 ;
14714
14715   result = (Dali::Vector4 *)&Dali::Color::GOLD;
14716   jresult = (void *)result;
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() {
14722   void * jresult;
14723   Dali::Vector4 *result = 0 ;
14724
14725   result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD;
14726   jresult = (void *)result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() {
14732   void * jresult;
14733   Dali::Vector4 *result = 0 ;
14734
14735   result = (Dali::Vector4 *)&Dali::Color::GRAY;
14736   jresult = (void *)result;
14737   return jresult;
14738 }
14739
14740
14741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14742   void * jresult;
14743   Dali::Vector4 *result = 0 ;
14744
14745   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() {
14752   void * jresult;
14753   Dali::Vector4 *result = 0 ;
14754
14755   result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW;
14756   jresult = (void *)result;
14757   return jresult;
14758 }
14759
14760
14761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() {
14762   void * jresult;
14763   Dali::Vector4 *result = 0 ;
14764
14765   result = (Dali::Vector4 *)&Dali::Color::GREY;
14766   jresult = (void *)result;
14767   return jresult;
14768 }
14769
14770
14771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() {
14772   void * jresult;
14773   Dali::Vector4 *result = 0 ;
14774
14775   result = (Dali::Vector4 *)&Dali::Color::HONEYDEW;
14776   jresult = (void *)result;
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() {
14782   void * jresult;
14783   Dali::Vector4 *result = 0 ;
14784
14785   result = (Dali::Vector4 *)&Dali::Color::HOT_PINK;
14786   jresult = (void *)result;
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() {
14792   void * jresult;
14793   Dali::Vector4 *result = 0 ;
14794
14795   result = (Dali::Vector4 *)&Dali::Color::INDIANRED;
14796   jresult = (void *)result;
14797   return jresult;
14798 }
14799
14800
14801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() {
14802   void * jresult;
14803   Dali::Vector4 *result = 0 ;
14804
14805   result = (Dali::Vector4 *)&Dali::Color::INDIGO;
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() {
14812   void * jresult;
14813   Dali::Vector4 *result = 0 ;
14814
14815   result = (Dali::Vector4 *)&Dali::Color::IVORY;
14816   jresult = (void *)result;
14817   return jresult;
14818 }
14819
14820
14821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() {
14822   void * jresult;
14823   Dali::Vector4 *result = 0 ;
14824
14825   result = (Dali::Vector4 *)&Dali::Color::KHAKI;
14826   jresult = (void *)result;
14827   return jresult;
14828 }
14829
14830
14831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() {
14832   void * jresult;
14833   Dali::Vector4 *result = 0 ;
14834
14835   result = (Dali::Vector4 *)&Dali::Color::LAVENDER;
14836   jresult = (void *)result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() {
14842   void * jresult;
14843   Dali::Vector4 *result = 0 ;
14844
14845   result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH;
14846   jresult = (void *)result;
14847   return jresult;
14848 }
14849
14850
14851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() {
14852   void * jresult;
14853   Dali::Vector4 *result = 0 ;
14854
14855   result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN;
14856   jresult = (void *)result;
14857   return jresult;
14858 }
14859
14860
14861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() {
14862   void * jresult;
14863   Dali::Vector4 *result = 0 ;
14864
14865   result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON;
14866   jresult = (void *)result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() {
14872   void * jresult;
14873   Dali::Vector4 *result = 0 ;
14874
14875   result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE;
14876   jresult = (void *)result;
14877   return jresult;
14878 }
14879
14880
14881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() {
14882   void * jresult;
14883   Dali::Vector4 *result = 0 ;
14884
14885   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL;
14886   jresult = (void *)result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() {
14892   void * jresult;
14893   Dali::Vector4 *result = 0 ;
14894
14895   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN;
14896   jresult = (void *)result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() {
14902   void * jresult;
14903   Dali::Vector4 *result = 0 ;
14904
14905   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW;
14906   jresult = (void *)result;
14907   return jresult;
14908 }
14909
14910
14911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() {
14912   void * jresult;
14913   Dali::Vector4 *result = 0 ;
14914
14915   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY;
14916   jresult = (void *)result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() {
14922   void * jresult;
14923   Dali::Vector4 *result = 0 ;
14924
14925   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN;
14926   jresult = (void *)result;
14927   return jresult;
14928 }
14929
14930
14931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() {
14932   void * jresult;
14933   Dali::Vector4 *result = 0 ;
14934
14935   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY;
14936   jresult = (void *)result;
14937   return jresult;
14938 }
14939
14940
14941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() {
14942   void * jresult;
14943   Dali::Vector4 *result = 0 ;
14944
14945   result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK;
14946   jresult = (void *)result;
14947   return jresult;
14948 }
14949
14950
14951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() {
14952   void * jresult;
14953   Dali::Vector4 *result = 0 ;
14954
14955   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON;
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() {
14962   void * jresult;
14963   Dali::Vector4 *result = 0 ;
14964
14965   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN;
14966   jresult = (void *)result;
14967   return jresult;
14968 }
14969
14970
14971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() {
14972   void * jresult;
14973   Dali::Vector4 *result = 0 ;
14974
14975   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE;
14976   jresult = (void *)result;
14977   return jresult;
14978 }
14979
14980
14981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() {
14982   void * jresult;
14983   Dali::Vector4 *result = 0 ;
14984
14985   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY;
14986   jresult = (void *)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() {
14992   void * jresult;
14993   Dali::Vector4 *result = 0 ;
14994
14995   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY;
14996   jresult = (void *)result;
14997   return jresult;
14998 }
14999
15000
15001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() {
15002   void * jresult;
15003   Dali::Vector4 *result = 0 ;
15004
15005   result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE;
15006   jresult = (void *)result;
15007   return jresult;
15008 }
15009
15010
15011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() {
15012   void * jresult;
15013   Dali::Vector4 *result = 0 ;
15014
15015   result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW;
15016   jresult = (void *)result;
15017   return jresult;
15018 }
15019
15020
15021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() {
15022   void * jresult;
15023   Dali::Vector4 *result = 0 ;
15024
15025   result = (Dali::Vector4 *)&Dali::Color::LIME;
15026   jresult = (void *)result;
15027   return jresult;
15028 }
15029
15030
15031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() {
15032   void * jresult;
15033   Dali::Vector4 *result = 0 ;
15034
15035   result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN;
15036   jresult = (void *)result;
15037   return jresult;
15038 }
15039
15040
15041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() {
15042   void * jresult;
15043   Dali::Vector4 *result = 0 ;
15044
15045   result = (Dali::Vector4 *)&Dali::Color::LINEN;
15046   jresult = (void *)result;
15047   return jresult;
15048 }
15049
15050
15051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
15052   void * jresult;
15053   Dali::Vector4 *result = 0 ;
15054
15055   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
15056   jresult = (void *)result;
15057   return jresult;
15058 }
15059
15060
15061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() {
15062   void * jresult;
15063   Dali::Vector4 *result = 0 ;
15064
15065   result = (Dali::Vector4 *)&Dali::Color::MAROON;
15066   jresult = (void *)result;
15067   return jresult;
15068 }
15069
15070
15071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() {
15072   void * jresult;
15073   Dali::Vector4 *result = 0 ;
15074
15075   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE;
15076   jresult = (void *)result;
15077   return jresult;
15078 }
15079
15080
15081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() {
15082   void * jresult;
15083   Dali::Vector4 *result = 0 ;
15084
15085   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE;
15086   jresult = (void *)result;
15087   return jresult;
15088 }
15089
15090
15091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() {
15092   void * jresult;
15093   Dali::Vector4 *result = 0 ;
15094
15095   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID;
15096   jresult = (void *)result;
15097   return jresult;
15098 }
15099
15100
15101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() {
15102   void * jresult;
15103   Dali::Vector4 *result = 0 ;
15104
15105   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE;
15106   jresult = (void *)result;
15107   return jresult;
15108 }
15109
15110
15111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() {
15112   void * jresult;
15113   Dali::Vector4 *result = 0 ;
15114
15115   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN;
15116   jresult = (void *)result;
15117   return jresult;
15118 }
15119
15120
15121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() {
15122   void * jresult;
15123   Dali::Vector4 *result = 0 ;
15124
15125   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE;
15126   jresult = (void *)result;
15127   return jresult;
15128 }
15129
15130
15131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() {
15132   void * jresult;
15133   Dali::Vector4 *result = 0 ;
15134
15135   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN;
15136   jresult = (void *)result;
15137   return jresult;
15138 }
15139
15140
15141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() {
15142   void * jresult;
15143   Dali::Vector4 *result = 0 ;
15144
15145   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE;
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() {
15152   void * jresult;
15153   Dali::Vector4 *result = 0 ;
15154
15155   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED;
15156   jresult = (void *)result;
15157   return jresult;
15158 }
15159
15160
15161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() {
15162   void * jresult;
15163   Dali::Vector4 *result = 0 ;
15164
15165   result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE;
15166   jresult = (void *)result;
15167   return jresult;
15168 }
15169
15170
15171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() {
15172   void * jresult;
15173   Dali::Vector4 *result = 0 ;
15174
15175   result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM;
15176   jresult = (void *)result;
15177   return jresult;
15178 }
15179
15180
15181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() {
15182   void * jresult;
15183   Dali::Vector4 *result = 0 ;
15184
15185   result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE;
15186   jresult = (void *)result;
15187   return jresult;
15188 }
15189
15190
15191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() {
15192   void * jresult;
15193   Dali::Vector4 *result = 0 ;
15194
15195   result = (Dali::Vector4 *)&Dali::Color::MOCCASIN;
15196   jresult = (void *)result;
15197   return jresult;
15198 }
15199
15200
15201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() {
15202   void * jresult;
15203   Dali::Vector4 *result = 0 ;
15204
15205   result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE;
15206   jresult = (void *)result;
15207   return jresult;
15208 }
15209
15210
15211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() {
15212   void * jresult;
15213   Dali::Vector4 *result = 0 ;
15214
15215   result = (Dali::Vector4 *)&Dali::Color::NAVY;
15216   jresult = (void *)result;
15217   return jresult;
15218 }
15219
15220
15221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() {
15222   void * jresult;
15223   Dali::Vector4 *result = 0 ;
15224
15225   result = (Dali::Vector4 *)&Dali::Color::OLD_LACE;
15226   jresult = (void *)result;
15227   return jresult;
15228 }
15229
15230
15231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() {
15232   void * jresult;
15233   Dali::Vector4 *result = 0 ;
15234
15235   result = (Dali::Vector4 *)&Dali::Color::OLIVE;
15236   jresult = (void *)result;
15237   return jresult;
15238 }
15239
15240
15241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() {
15242   void * jresult;
15243   Dali::Vector4 *result = 0 ;
15244
15245   result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB;
15246   jresult = (void *)result;
15247   return jresult;
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() {
15252   void * jresult;
15253   Dali::Vector4 *result = 0 ;
15254
15255   result = (Dali::Vector4 *)&Dali::Color::ORANGE;
15256   jresult = (void *)result;
15257   return jresult;
15258 }
15259
15260
15261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() {
15262   void * jresult;
15263   Dali::Vector4 *result = 0 ;
15264
15265   result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED;
15266   jresult = (void *)result;
15267   return jresult;
15268 }
15269
15270
15271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() {
15272   void * jresult;
15273   Dali::Vector4 *result = 0 ;
15274
15275   result = (Dali::Vector4 *)&Dali::Color::ORCHID;
15276   jresult = (void *)result;
15277   return jresult;
15278 }
15279
15280
15281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() {
15282   void * jresult;
15283   Dali::Vector4 *result = 0 ;
15284
15285   result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD;
15286   jresult = (void *)result;
15287   return jresult;
15288 }
15289
15290
15291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() {
15292   void * jresult;
15293   Dali::Vector4 *result = 0 ;
15294
15295   result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN;
15296   jresult = (void *)result;
15297   return jresult;
15298 }
15299
15300
15301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() {
15302   void * jresult;
15303   Dali::Vector4 *result = 0 ;
15304
15305   result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE;
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() {
15312   void * jresult;
15313   Dali::Vector4 *result = 0 ;
15314
15315   result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED;
15316   jresult = (void *)result;
15317   return jresult;
15318 }
15319
15320
15321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() {
15322   void * jresult;
15323   Dali::Vector4 *result = 0 ;
15324
15325   result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP;
15326   jresult = (void *)result;
15327   return jresult;
15328 }
15329
15330
15331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() {
15332   void * jresult;
15333   Dali::Vector4 *result = 0 ;
15334
15335   result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF;
15336   jresult = (void *)result;
15337   return jresult;
15338 }
15339
15340
15341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() {
15342   void * jresult;
15343   Dali::Vector4 *result = 0 ;
15344
15345   result = (Dali::Vector4 *)&Dali::Color::PERU;
15346   jresult = (void *)result;
15347   return jresult;
15348 }
15349
15350
15351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() {
15352   void * jresult;
15353   Dali::Vector4 *result = 0 ;
15354
15355   result = (Dali::Vector4 *)&Dali::Color::PINK;
15356   jresult = (void *)result;
15357   return jresult;
15358 }
15359
15360
15361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() {
15362   void * jresult;
15363   Dali::Vector4 *result = 0 ;
15364
15365   result = (Dali::Vector4 *)&Dali::Color::PLUM;
15366   jresult = (void *)result;
15367   return jresult;
15368 }
15369
15370
15371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() {
15372   void * jresult;
15373   Dali::Vector4 *result = 0 ;
15374
15375   result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE;
15376   jresult = (void *)result;
15377   return jresult;
15378 }
15379
15380
15381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() {
15382   void * jresult;
15383   Dali::Vector4 *result = 0 ;
15384
15385   result = (Dali::Vector4 *)&Dali::Color::PURPLE;
15386   jresult = (void *)result;
15387   return jresult;
15388 }
15389
15390
15391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
15392   void * jresult;
15393   Dali::Vector4 *result = 0 ;
15394
15395   result = (Dali::Vector4 *)&Dali::Color::RED;
15396   jresult = (void *)result;
15397   return jresult;
15398 }
15399
15400
15401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() {
15402   void * jresult;
15403   Dali::Vector4 *result = 0 ;
15404
15405   result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN;
15406   jresult = (void *)result;
15407   return jresult;
15408 }
15409
15410
15411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() {
15412   void * jresult;
15413   Dali::Vector4 *result = 0 ;
15414
15415   result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE;
15416   jresult = (void *)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() {
15422   void * jresult;
15423   Dali::Vector4 *result = 0 ;
15424
15425   result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN;
15426   jresult = (void *)result;
15427   return jresult;
15428 }
15429
15430
15431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() {
15432   void * jresult;
15433   Dali::Vector4 *result = 0 ;
15434
15435   result = (Dali::Vector4 *)&Dali::Color::SALMON;
15436   jresult = (void *)result;
15437   return jresult;
15438 }
15439
15440
15441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() {
15442   void * jresult;
15443   Dali::Vector4 *result = 0 ;
15444
15445   result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN;
15446   jresult = (void *)result;
15447   return jresult;
15448 }
15449
15450
15451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() {
15452   void * jresult;
15453   Dali::Vector4 *result = 0 ;
15454
15455   result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN;
15456   jresult = (void *)result;
15457   return jresult;
15458 }
15459
15460
15461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() {
15462   void * jresult;
15463   Dali::Vector4 *result = 0 ;
15464
15465   result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL;
15466   jresult = (void *)result;
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() {
15472   void * jresult;
15473   Dali::Vector4 *result = 0 ;
15474
15475   result = (Dali::Vector4 *)&Dali::Color::SIENNA;
15476   jresult = (void *)result;
15477   return jresult;
15478 }
15479
15480
15481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() {
15482   void * jresult;
15483   Dali::Vector4 *result = 0 ;
15484
15485   result = (Dali::Vector4 *)&Dali::Color::SILVER;
15486   jresult = (void *)result;
15487   return jresult;
15488 }
15489
15490
15491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() {
15492   void * jresult;
15493   Dali::Vector4 *result = 0 ;
15494
15495   result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE;
15496   jresult = (void *)result;
15497   return jresult;
15498 }
15499
15500
15501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() {
15502   void * jresult;
15503   Dali::Vector4 *result = 0 ;
15504
15505   result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE;
15506   jresult = (void *)result;
15507   return jresult;
15508 }
15509
15510
15511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() {
15512   void * jresult;
15513   Dali::Vector4 *result = 0 ;
15514
15515   result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY;
15516   jresult = (void *)result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() {
15522   void * jresult;
15523   Dali::Vector4 *result = 0 ;
15524
15525   result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY;
15526   jresult = (void *)result;
15527   return jresult;
15528 }
15529
15530
15531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() {
15532   void * jresult;
15533   Dali::Vector4 *result = 0 ;
15534
15535   result = (Dali::Vector4 *)&Dali::Color::SNOW;
15536   jresult = (void *)result;
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() {
15542   void * jresult;
15543   Dali::Vector4 *result = 0 ;
15544
15545   result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN;
15546   jresult = (void *)result;
15547   return jresult;
15548 }
15549
15550
15551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() {
15552   void * jresult;
15553   Dali::Vector4 *result = 0 ;
15554
15555   result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE;
15556   jresult = (void *)result;
15557   return jresult;
15558 }
15559
15560
15561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() {
15562   void * jresult;
15563   Dali::Vector4 *result = 0 ;
15564
15565   result = (Dali::Vector4 *)&Dali::Color::TAN;
15566   jresult = (void *)result;
15567   return jresult;
15568 }
15569
15570
15571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() {
15572   void * jresult;
15573   Dali::Vector4 *result = 0 ;
15574
15575   result = (Dali::Vector4 *)&Dali::Color::TEAL;
15576   jresult = (void *)result;
15577   return jresult;
15578 }
15579
15580
15581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() {
15582   void * jresult;
15583   Dali::Vector4 *result = 0 ;
15584
15585   result = (Dali::Vector4 *)&Dali::Color::THISTLE;
15586   jresult = (void *)result;
15587   return jresult;
15588 }
15589
15590
15591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() {
15592   void * jresult;
15593   Dali::Vector4 *result = 0 ;
15594
15595   result = (Dali::Vector4 *)&Dali::Color::TOMATO;
15596   jresult = (void *)result;
15597   return jresult;
15598 }
15599
15600
15601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
15602   void * jresult;
15603   Dali::Vector4 *result = 0 ;
15604
15605   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
15606   jresult = (void *)result;
15607   return jresult;
15608 }
15609
15610
15611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() {
15612   void * jresult;
15613   Dali::Vector4 *result = 0 ;
15614
15615   result = (Dali::Vector4 *)&Dali::Color::TURQUOISE;
15616   jresult = (void *)result;
15617   return jresult;
15618 }
15619
15620
15621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() {
15622   void * jresult;
15623   Dali::Vector4 *result = 0 ;
15624
15625   result = (Dali::Vector4 *)&Dali::Color::VIOLET;
15626   jresult = (void *)result;
15627   return jresult;
15628 }
15629
15630
15631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() {
15632   void * jresult;
15633   Dali::Vector4 *result = 0 ;
15634
15635   result = (Dali::Vector4 *)&Dali::Color::WHEAT;
15636   jresult = (void *)result;
15637   return jresult;
15638 }
15639
15640
15641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
15642   void * jresult;
15643   Dali::Vector4 *result = 0 ;
15644
15645   result = (Dali::Vector4 *)&Dali::Color::WHITE;
15646   jresult = (void *)result;
15647   return jresult;
15648 }
15649
15650
15651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() {
15652   void * jresult;
15653   Dali::Vector4 *result = 0 ;
15654
15655   result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE;
15656   jresult = (void *)result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
15662   void * jresult;
15663   Dali::Vector4 *result = 0 ;
15664
15665   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
15666   jresult = (void *)result;
15667   return jresult;
15668 }
15669
15670
15671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() {
15672   void * jresult;
15673   Dali::Vector4 *result = 0 ;
15674
15675   result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN;
15676   jresult = (void *)result;
15677   return jresult;
15678 }
15679
15680
15681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
15682   float jresult ;
15683   float result;
15684
15685   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
15686   jresult = result;
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
15692   float jresult ;
15693   float result;
15694
15695   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
15696   jresult = result;
15697   return jresult;
15698 }
15699
15700
15701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
15702   float jresult ;
15703   float result;
15704
15705   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
15706   jresult = result;
15707   return jresult;
15708 }
15709
15710
15711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
15712   float jresult ;
15713   float result;
15714
15715   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
15716   jresult = result;
15717   return jresult;
15718 }
15719
15720
15721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
15722   float jresult ;
15723   float result;
15724
15725   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
15726   jresult = result;
15727   return jresult;
15728 }
15729
15730
15731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
15732   float jresult ;
15733   float result;
15734
15735   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
15736   jresult = result;
15737   return jresult;
15738 }
15739
15740
15741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
15742   float jresult ;
15743   float result;
15744
15745   result = (float)(float)Dali::Math::PI;
15746   jresult = result;
15747   return jresult;
15748 }
15749
15750
15751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
15752   float jresult ;
15753   float result;
15754
15755   result = (float)(float)Dali::Math::PI_2;
15756   jresult = result;
15757   return jresult;
15758 }
15759
15760
15761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
15762   float jresult ;
15763   float result;
15764
15765   result = (float)(float)Dali::Math::PI_4;
15766   jresult = result;
15767   return jresult;
15768 }
15769
15770
15771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
15772   float jresult ;
15773   float result;
15774
15775   result = (float)(float)Dali::Math::PI_OVER_180;
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
15782   float jresult ;
15783   float result;
15784
15785   result = (float)(float)Dali::Math::ONE80_OVER_PI;
15786   jresult = result;
15787   return jresult;
15788 }
15789
15790
15791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
15792   int jresult ;
15793   Dali::ResizePolicy::Type result;
15794
15795   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
15796   jresult = (int)result;
15797   return jresult;
15798 }
15799
15800
15801 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
15802   unsigned long jresult ;
15803   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15804   Dali::VectorBase::SizeType result;
15805
15806   arg1 = (Dali::VectorBase *)jarg1;
15807   {
15808     try {
15809       result = ((Dali::VectorBase const *)arg1)->Count();
15810     } CALL_CATCH_EXCEPTION(0);
15811   }
15812
15813   jresult = (unsigned long)result;
15814   return jresult;
15815 }
15816
15817
15818 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15819   unsigned long jresult ;
15820   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15821   Dali::VectorBase::SizeType result;
15822
15823   arg1 = (Dali::VectorBase *)jarg1;
15824   {
15825     try {
15826       result = ((Dali::VectorBase const *)arg1)->Size();
15827     } CALL_CATCH_EXCEPTION(0);
15828   }
15829
15830   jresult = (unsigned long)result;
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15836   bool jresult ;
15837   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15838   bool result;
15839
15840   arg1 = (Dali::VectorBase *)jarg1;
15841   {
15842     try {
15843       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15844     } CALL_CATCH_EXCEPTION(0);
15845   }
15846
15847   jresult = result;
15848   return jresult;
15849 }
15850
15851
15852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15853   unsigned long jresult ;
15854   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15855   Dali::VectorBase::SizeType result;
15856
15857   arg1 = (Dali::VectorBase *)jarg1;
15858   {
15859     try {
15860       result = ((Dali::VectorBase const *)arg1)->Capacity();
15861     } CALL_CATCH_EXCEPTION(0);
15862   }
15863
15864   jresult = (unsigned long)result;
15865   return jresult;
15866 }
15867
15868
15869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15870   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15871
15872   arg1 = (Dali::VectorBase *)jarg1;
15873   {
15874     try {
15875       (arg1)->Release();
15876     } CALL_CATCH_EXCEPTION();
15877   }
15878
15879 }
15880
15881
15882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15883   int jresult ;
15884   Dali::Pixel::Format result;
15885
15886   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15887   jresult = (int)result;
15888   return jresult;
15889 }
15890
15891
15892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15893   int jresult ;
15894   Dali::Pixel::Format result;
15895
15896   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15897   jresult = (int)result;
15898   return jresult;
15899 }
15900
15901
15902 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15903   bool jresult ;
15904   Dali::Pixel::Format arg1 ;
15905   bool result;
15906
15907   arg1 = (Dali::Pixel::Format)jarg1;
15908   {
15909     try {
15910       result = (bool)Dali::Pixel::HasAlpha(arg1);
15911     } CALL_CATCH_EXCEPTION(0);
15912   }
15913
15914   jresult = result;
15915   return jresult;
15916 }
15917
15918
15919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15920   unsigned int jresult ;
15921   Dali::Pixel::Format arg1 ;
15922   unsigned int result;
15923
15924   arg1 = (Dali::Pixel::Format)jarg1;
15925   {
15926     try {
15927       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15928     } CALL_CATCH_EXCEPTION(0);
15929   }
15930
15931   jresult = result;
15932   return jresult;
15933 }
15934
15935
15936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15937   Dali::Pixel::Format arg1 ;
15938   int *arg2 = 0 ;
15939   int *arg3 = 0 ;
15940
15941   arg1 = (Dali::Pixel::Format)jarg1;
15942   arg2 = (int *)jarg2;
15943   if (!arg2) {
15944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15945     return ;
15946   }
15947   arg3 = (int *)jarg3;
15948   if (!arg3) {
15949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15950     return ;
15951   }
15952   {
15953     try {
15954       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15955     } CALL_CATCH_EXCEPTION();
15956   }
15957
15958 }
15959
15960
15961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
15962   void * jresult ;
15963   Dali::PixelData result;
15964
15965   {
15966     unsigned char* copiedBuffer;
15967     try
15968     {
15969       copiedBuffer = new unsigned char[nuiBufferSize];
15970     } CALL_CATCH_EXCEPTION(0);
15971
15972     try
15973     {
15974       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
15975       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
15976       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
15977     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
15978   }
15979
15980   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15981
15982   return jresult;
15983 }
15984
15985
15986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15987   void * jresult ;
15988   Dali::PixelData *result = 0 ;
15989
15990   {
15991     try {
15992       result = (Dali::PixelData *)new Dali::PixelData();
15993     } CALL_CATCH_EXCEPTION(0);
15994   }
15995
15996   jresult = (void *)result;
15997   return jresult;
15998 }
15999
16000
16001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
16002   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16003
16004   pixelData = (Dali::PixelData *)nuiHandle;
16005   {
16006     try {
16007       delete pixelData;
16008     } CALL_CATCH_EXCEPTION();
16009   }
16010
16011 }
16012
16013
16014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
16015   void * jresult ;
16016   Dali::PixelData *pixelData = 0 ;
16017   Dali::PixelData *result = 0 ;
16018
16019   pixelData = (Dali::PixelData *)nuiHandle;
16020   if (!pixelData) {
16021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16022     return 0;
16023   }
16024   {
16025     try {
16026       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
16027     } CALL_CATCH_EXCEPTION(0);
16028   }
16029
16030   jresult = (void *)result;
16031   return jresult;
16032 }
16033
16034
16035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
16036   void * jresult ;
16037   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16038   Dali::PixelData *pixelDataSource = 0 ;
16039   Dali::PixelData *result = 0 ;
16040
16041   pixelData = (Dali::PixelData *)nuiHandle;
16042   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
16043   if (!pixelDataSource) {
16044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
16045     return 0;
16046   }
16047   {
16048     try {
16049       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
16050     } CALL_CATCH_EXCEPTION(0);
16051   }
16052
16053   jresult = (void *)result;
16054   return jresult;
16055 }
16056
16057
16058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
16059   unsigned int jresult ;
16060   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16061   unsigned int result;
16062
16063   pixelData = (Dali::PixelData *)nuiHandle;
16064   {
16065     try {
16066       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
16067     } CALL_CATCH_EXCEPTION(0);
16068   }
16069
16070   jresult = result;
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
16076   unsigned int jresult ;
16077   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16078   unsigned int result;
16079
16080   pixelData = (Dali::PixelData *)nuiHandle;
16081   {
16082     try {
16083       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
16084     } CALL_CATCH_EXCEPTION(0);
16085   }
16086
16087   jresult = result;
16088   return jresult;
16089 }
16090
16091
16092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
16093   int jresult ;
16094   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
16095   Dali::Pixel::Format result;
16096
16097   pixelData = (Dali::PixelData *)nuiHandle;
16098   {
16099     try {
16100       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
16101     } CALL_CATCH_EXCEPTION(0);
16102   }
16103
16104   jresult = (int)result;
16105   return jresult;
16106 }
16107
16108 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
16109 {
16110   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
16111   Dali::Toolkit::ImageUrl result;
16112   void *jresult;
16113
16114   if (!pixelData)
16115   {
16116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
16117     return 0;
16118   }
16119   {
16120     try
16121     {
16122       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
16123     } CALL_CATCH_EXCEPTION(0);
16124   }
16125
16126   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
16127   return jresult;
16128 }
16129
16130
16131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
16132   unsigned int jresult ;
16133   unsigned int result;
16134
16135   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
16136   jresult = result;
16137   return jresult;
16138 }
16139
16140
16141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
16142   unsigned int jresult ;
16143   unsigned int result;
16144
16145   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
16146   jresult = result;
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
16152   unsigned int jresult ;
16153   unsigned int result;
16154
16155   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
16156   jresult = result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
16162   unsigned int jresult ;
16163   unsigned int result;
16164
16165   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
16166   jresult = result;
16167   return jresult;
16168 }
16169
16170
16171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
16172   unsigned int jresult ;
16173   unsigned int result;
16174
16175   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
16176   jresult = result;
16177   return jresult;
16178 }
16179
16180
16181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
16182   unsigned int jresult ;
16183   unsigned int result;
16184
16185   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
16186   jresult = result;
16187   return jresult;
16188 }
16189
16190
16191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
16192   void * jresult ;
16193   Dali::TextureType::Type arg1 ;
16194   Dali::Pixel::Format arg2 ;
16195   unsigned int arg3 ;
16196   unsigned int arg4 ;
16197   Dali::Texture result;
16198
16199   arg1 = (Dali::TextureType::Type)jarg1;
16200   arg2 = (Dali::Pixel::Format)jarg2;
16201   arg3 = (unsigned int)jarg3;
16202   arg4 = (unsigned int)jarg4;
16203   {
16204     try {
16205       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
16206     } CALL_CATCH_EXCEPTION(0);
16207   }
16208
16209   jresult = new Dali::Texture((const Dali::Texture &)result);
16210   return jresult;
16211 }
16212
16213
16214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
16215   void * jresult ;
16216   NativeImageInterface *arg1 = 0 ;
16217   Dali::Texture result;
16218
16219   arg1 = (NativeImageInterface *)jarg1;
16220   if (!arg1) {
16221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
16222     return 0;
16223   }
16224   {
16225     try {
16226       result = Dali::Texture::New(*arg1);
16227     } CALL_CATCH_EXCEPTION(0);
16228   }
16229
16230   jresult = new Dali::Texture((const Dali::Texture &)result);
16231   return jresult;
16232 }
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
16235   void * jresult ;
16236   Dali::Texture *result = 0 ;
16237
16238   {
16239     try {
16240       result = (Dali::Texture *)new Dali::Texture();
16241     } CALL_CATCH_EXCEPTION(0);
16242   }
16243
16244   jresult = (void *)result;
16245   return jresult;
16246 }
16247
16248
16249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
16250   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16251
16252   arg1 = (Dali::Texture *)jarg1;
16253   {
16254     try {
16255       delete arg1;
16256     } CALL_CATCH_EXCEPTION();
16257   }
16258
16259 }
16260
16261
16262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
16263   void * jresult ;
16264   Dali::Texture *arg1 = 0 ;
16265   Dali::Texture *result = 0 ;
16266
16267   arg1 = (Dali::Texture *)jarg1;
16268   if (!arg1) {
16269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16270     return 0;
16271   }
16272   {
16273     try {
16274       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
16275     } CALL_CATCH_EXCEPTION(0);
16276   }
16277
16278   jresult = (void *)result;
16279   return jresult;
16280 }
16281
16282
16283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
16284   void * jresult ;
16285   Dali::BaseHandle arg1 ;
16286   Dali::BaseHandle *argp1 ;
16287   Dali::Texture result;
16288
16289   argp1 = (Dali::BaseHandle *)jarg1;
16290   if (!argp1) {
16291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16292     return 0;
16293   }
16294   arg1 = *argp1;
16295   {
16296     try {
16297       result = Dali::Texture::DownCast(arg1);
16298     } CALL_CATCH_EXCEPTION(0);
16299   }
16300
16301   jresult = new Dali::Texture((const Dali::Texture &)result);
16302   return jresult;
16303 }
16304
16305
16306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
16307   void * jresult ;
16308   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16309   Dali::Texture *arg2 = 0 ;
16310   Dali::Texture *result = 0 ;
16311
16312   arg1 = (Dali::Texture *)jarg1;
16313   arg2 = (Dali::Texture *)jarg2;
16314   if (!arg2) {
16315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16316     return 0;
16317   }
16318   {
16319     try {
16320       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
16321     } CALL_CATCH_EXCEPTION(0);
16322   }
16323
16324   jresult = (void *)result;
16325   return jresult;
16326 }
16327
16328
16329 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
16330   bool jresult ;
16331   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16332   Dali::PixelData arg2 ;
16333   Dali::PixelData *argp2 ;
16334   bool result;
16335
16336   arg1 = (Dali::Texture *)jarg1;
16337   argp2 = (Dali::PixelData *)jarg2;
16338   if (!argp2) {
16339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16340     return 0;
16341   }
16342   arg2 = *argp2;
16343   {
16344     try {
16345       result = (bool)(arg1)->Upload(arg2);
16346     } CALL_CATCH_EXCEPTION(0);
16347   }
16348
16349   jresult = result;
16350   return jresult;
16351 }
16352
16353
16354 SWIGEXPORT bool 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) {
16355   bool jresult ;
16356   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16357   Dali::PixelData arg2 ;
16358   unsigned int arg3 ;
16359   unsigned int arg4 ;
16360   unsigned int arg5 ;
16361   unsigned int arg6 ;
16362   unsigned int arg7 ;
16363   unsigned int arg8 ;
16364   Dali::PixelData *argp2 ;
16365   bool result;
16366
16367   arg1 = (Dali::Texture *)jarg1;
16368   argp2 = (Dali::PixelData *)jarg2;
16369   if (!argp2) {
16370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16371     return 0;
16372   }
16373   arg2 = *argp2;
16374   arg3 = (unsigned int)jarg3;
16375   arg4 = (unsigned int)jarg4;
16376   arg5 = (unsigned int)jarg5;
16377   arg6 = (unsigned int)jarg6;
16378   arg7 = (unsigned int)jarg7;
16379   arg8 = (unsigned int)jarg8;
16380   {
16381     try {
16382       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16383     } CALL_CATCH_EXCEPTION(0);
16384   }
16385
16386   jresult = result;
16387   return jresult;
16388 }
16389
16390
16391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
16392   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16393
16394   arg1 = (Dali::Texture *)jarg1;
16395   {
16396     try {
16397       (arg1)->GenerateMipmaps();
16398     } CALL_CATCH_EXCEPTION();
16399   }
16400
16401 }
16402
16403
16404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
16405   unsigned int jresult ;
16406   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16407   unsigned int result;
16408
16409   arg1 = (Dali::Texture *)jarg1;
16410   {
16411     try {
16412       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
16413     } CALL_CATCH_EXCEPTION(0);
16414   }
16415
16416   jresult = result;
16417   return jresult;
16418 }
16419
16420
16421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
16422   unsigned int jresult ;
16423   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16424   unsigned int result;
16425
16426   arg1 = (Dali::Texture *)jarg1;
16427   {
16428     try {
16429       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
16430     } CALL_CATCH_EXCEPTION(0);
16431   }
16432
16433   jresult = result;
16434   return jresult;
16435 }
16436
16437
16438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
16439   void * jresult ;
16440   Dali::Sampler result;
16441
16442   {
16443     try {
16444       result = Dali::Sampler::New();
16445     } CALL_CATCH_EXCEPTION(0);
16446   }
16447
16448   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16449   return jresult;
16450 }
16451
16452
16453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
16454   void * jresult ;
16455   Dali::Sampler *result = 0 ;
16456
16457   {
16458     try {
16459       result = (Dali::Sampler *)new Dali::Sampler();
16460     } CALL_CATCH_EXCEPTION(0);
16461   }
16462
16463   jresult = (void *)result;
16464   return jresult;
16465 }
16466
16467
16468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
16469   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16470
16471   arg1 = (Dali::Sampler *)jarg1;
16472   {
16473     try {
16474       delete arg1;
16475     } CALL_CATCH_EXCEPTION();
16476   }
16477
16478 }
16479
16480
16481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
16482   void * jresult ;
16483   Dali::Sampler *arg1 = 0 ;
16484   Dali::Sampler *result = 0 ;
16485
16486   arg1 = (Dali::Sampler *)jarg1;
16487   if (!arg1) {
16488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16489     return 0;
16490   }
16491   {
16492     try {
16493       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
16494     } CALL_CATCH_EXCEPTION(0);
16495   }
16496
16497   jresult = (void *)result;
16498   return jresult;
16499 }
16500
16501
16502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
16503   void * jresult ;
16504   Dali::BaseHandle arg1 ;
16505   Dali::BaseHandle *argp1 ;
16506   Dali::Sampler result;
16507
16508   argp1 = (Dali::BaseHandle *)jarg1;
16509   if (!argp1) {
16510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16511     return 0;
16512   }
16513   arg1 = *argp1;
16514   {
16515     try {
16516       result = Dali::Sampler::DownCast(arg1);
16517     } CALL_CATCH_EXCEPTION(0);
16518   }
16519
16520   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16521   return jresult;
16522 }
16523
16524
16525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
16526   void * jresult ;
16527   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16528   Dali::Sampler *arg2 = 0 ;
16529   Dali::Sampler *result = 0 ;
16530
16531   arg1 = (Dali::Sampler *)jarg1;
16532   arg2 = (Dali::Sampler *)jarg2;
16533   if (!arg2) {
16534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16535     return 0;
16536   }
16537   {
16538     try {
16539       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
16540     } CALL_CATCH_EXCEPTION(0);
16541   }
16542
16543   jresult = (void *)result;
16544   return jresult;
16545 }
16546
16547
16548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
16549   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16550   Dali::FilterMode::Type arg2 ;
16551   Dali::FilterMode::Type arg3 ;
16552
16553   arg1 = (Dali::Sampler *)jarg1;
16554   arg2 = (Dali::FilterMode::Type)jarg2;
16555   arg3 = (Dali::FilterMode::Type)jarg3;
16556   {
16557     try {
16558       (arg1)->SetFilterMode(arg2,arg3);
16559     } CALL_CATCH_EXCEPTION();
16560   }
16561
16562 }
16563
16564
16565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
16566   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16567   Dali::WrapMode::Type arg2 ;
16568   Dali::WrapMode::Type arg3 ;
16569
16570   arg1 = (Dali::Sampler *)jarg1;
16571   arg2 = (Dali::WrapMode::Type)jarg2;
16572   arg3 = (Dali::WrapMode::Type)jarg3;
16573   {
16574     try {
16575       (arg1)->SetWrapMode(arg2,arg3);
16576     } CALL_CATCH_EXCEPTION();
16577   }
16578
16579 }
16580
16581
16582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
16583   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16584   Dali::WrapMode::Type arg2 ;
16585   Dali::WrapMode::Type arg3 ;
16586   Dali::WrapMode::Type arg4 ;
16587
16588   arg1 = (Dali::Sampler *)jarg1;
16589   arg2 = (Dali::WrapMode::Type)jarg2;
16590   arg3 = (Dali::WrapMode::Type)jarg3;
16591   arg4 = (Dali::WrapMode::Type)jarg4;
16592   {
16593     try {
16594       (arg1)->SetWrapMode(arg2,arg3,arg4);
16595     } CALL_CATCH_EXCEPTION();
16596   }
16597
16598 }
16599
16600
16601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
16602   void * jresult ;
16603   Dali::TextureSet result;
16604
16605   {
16606     try {
16607       result = Dali::TextureSet::New();
16608     } CALL_CATCH_EXCEPTION(0);
16609   }
16610
16611   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16612   return jresult;
16613 }
16614
16615
16616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
16617   void * jresult ;
16618   Dali::TextureSet *result = 0 ;
16619
16620   {
16621     try {
16622       result = (Dali::TextureSet *)new Dali::TextureSet();
16623     } CALL_CATCH_EXCEPTION(0);
16624   }
16625
16626   jresult = (void *)result;
16627   return jresult;
16628 }
16629
16630
16631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
16632   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16633
16634   arg1 = (Dali::TextureSet *)jarg1;
16635   {
16636     try {
16637       delete arg1;
16638     } CALL_CATCH_EXCEPTION();
16639   }
16640
16641 }
16642
16643
16644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
16645   void * jresult ;
16646   Dali::TextureSet *arg1 = 0 ;
16647   Dali::TextureSet *result = 0 ;
16648
16649   arg1 = (Dali::TextureSet *)jarg1;
16650   if (!arg1) {
16651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16652     return 0;
16653   }
16654   {
16655     try {
16656       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
16657     } CALL_CATCH_EXCEPTION(0);
16658   }
16659
16660   jresult = (void *)result;
16661   return jresult;
16662 }
16663
16664
16665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
16666   void * jresult ;
16667   Dali::BaseHandle arg1 ;
16668   Dali::BaseHandle *argp1 ;
16669   Dali::TextureSet result;
16670
16671   argp1 = (Dali::BaseHandle *)jarg1;
16672   if (!argp1) {
16673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16674     return 0;
16675   }
16676   arg1 = *argp1;
16677   {
16678     try {
16679       result = Dali::TextureSet::DownCast(arg1);
16680     } CALL_CATCH_EXCEPTION(0);
16681   }
16682
16683   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16684   return jresult;
16685 }
16686
16687
16688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
16689   void * jresult ;
16690   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16691   Dali::TextureSet *arg2 = 0 ;
16692   Dali::TextureSet *result = 0 ;
16693
16694   arg1 = (Dali::TextureSet *)jarg1;
16695   arg2 = (Dali::TextureSet *)jarg2;
16696   if (!arg2) {
16697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16698     return 0;
16699   }
16700   {
16701     try {
16702       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
16703     } CALL_CATCH_EXCEPTION(0);
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
16712   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16713   size_t arg2 ;
16714   Dali::Texture arg3 ;
16715   Dali::Texture *argp3 ;
16716
16717   arg1 = (Dali::TextureSet *)jarg1;
16718   arg2 = (size_t)jarg2;
16719   argp3 = (Dali::Texture *)jarg3;
16720   if (!argp3) {
16721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
16722     return ;
16723   }
16724   arg3 = *argp3;
16725   {
16726     try {
16727       (arg1)->SetTexture(arg2,arg3);
16728     } CALL_CATCH_EXCEPTION();
16729   }
16730
16731 }
16732
16733
16734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
16735   void * jresult ;
16736   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16737   size_t arg2 ;
16738   Dali::Texture result;
16739
16740   arg1 = (Dali::TextureSet *)jarg1;
16741   arg2 = (size_t)jarg2;
16742   {
16743     try {
16744       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
16745     } CALL_CATCH_EXCEPTION(0);
16746   }
16747
16748   jresult = new Dali::Texture((const Dali::Texture &)result);
16749   return jresult;
16750 }
16751
16752
16753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
16754   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16755   size_t arg2 ;
16756   Dali::Sampler arg3 ;
16757   Dali::Sampler *argp3 ;
16758
16759   arg1 = (Dali::TextureSet *)jarg1;
16760   arg2 = (size_t)jarg2;
16761   argp3 = (Dali::Sampler *)jarg3;
16762   if (!argp3) {
16763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
16764     return ;
16765   }
16766   arg3 = *argp3;
16767   {
16768     try {
16769       (arg1)->SetSampler(arg2,arg3);
16770     } CALL_CATCH_EXCEPTION();
16771   }
16772
16773 }
16774
16775
16776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
16777   void * jresult ;
16778   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16779   size_t arg2 ;
16780   Dali::Sampler result;
16781
16782   arg1 = (Dali::TextureSet *)jarg1;
16783   arg2 = (size_t)jarg2;
16784   {
16785     try {
16786       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
16787     } CALL_CATCH_EXCEPTION(0);
16788   }
16789
16790   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
16796   unsigned long jresult ;
16797   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16798   size_t result;
16799
16800   arg1 = (Dali::TextureSet *)jarg1;
16801   {
16802     try {
16803       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
16804     } CALL_CATCH_EXCEPTION(0);
16805   }
16806
16807   jresult = (unsigned long)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
16813   void * jresult ;
16814   Dali::Property::Map *arg1 = 0 ;
16815   Dali::VertexBuffer result;
16816
16817   arg1 = (Dali::Property::Map *)jarg1;
16818   if (!arg1) {
16819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
16820     return 0;
16821   }
16822   {
16823     try {
16824       result = Dali::VertexBuffer::New(*arg1);
16825     } CALL_CATCH_EXCEPTION(0);
16826   }
16827
16828   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16829   return jresult;
16830 }
16831
16832
16833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16834   void * jresult ;
16835   Dali::VertexBuffer *result = 0 ;
16836
16837   {
16838     try {
16839       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16840     } CALL_CATCH_EXCEPTION(0);
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16849   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16850
16851   arg1 = (Dali::VertexBuffer *)jarg1;
16852   {
16853     try {
16854       delete arg1;
16855     } CALL_CATCH_EXCEPTION();
16856   }
16857
16858 }
16859
16860
16861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16862   void * jresult ;
16863   Dali::VertexBuffer *arg1 = 0 ;
16864   Dali::VertexBuffer *result = 0 ;
16865
16866   arg1 = (Dali::VertexBuffer *)jarg1;
16867   if (!arg1) {
16868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16869     return 0;
16870   }
16871   {
16872     try {
16873       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16874     } CALL_CATCH_EXCEPTION(0);
16875   }
16876
16877   jresult = (void *)result;
16878   return jresult;
16879 }
16880
16881
16882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16883   void * jresult ;
16884   Dali::BaseHandle arg1 ;
16885   Dali::BaseHandle *argp1 ;
16886   Dali::VertexBuffer result;
16887
16888   argp1 = (Dali::BaseHandle *)jarg1;
16889   if (!argp1) {
16890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16891     return 0;
16892   }
16893   arg1 = *argp1;
16894   {
16895     try {
16896       result = Dali::VertexBuffer::DownCast(arg1);
16897     } CALL_CATCH_EXCEPTION(0);
16898   }
16899
16900   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16901   return jresult;
16902 }
16903
16904
16905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16906   void * jresult ;
16907   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16908   Dali::VertexBuffer *arg2 = 0 ;
16909   Dali::VertexBuffer *result = 0 ;
16910
16911   arg1 = (Dali::VertexBuffer *)jarg1;
16912   arg2 = (Dali::VertexBuffer *)jarg2;
16913   if (!arg2) {
16914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16915     return 0;
16916   }
16917   {
16918     try {
16919       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16920     } CALL_CATCH_EXCEPTION(0);
16921   }
16922
16923   jresult = (void *)result;
16924   return jresult;
16925 }
16926
16927
16928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16929   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16930   void *arg2 = (void *) 0 ;
16931   std::size_t arg3 ;
16932
16933   arg1 = (Dali::VertexBuffer *)jarg1;
16934   arg2 = jarg2;
16935   arg3 = (std::size_t)jarg3;
16936   {
16937     try {
16938       (arg1)->SetData((void const *)arg2,arg3);
16939     } CALL_CATCH_EXCEPTION();
16940   }
16941
16942 }
16943
16944
16945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16946   unsigned long jresult ;
16947   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16948   std::size_t result;
16949
16950   arg1 = (Dali::VertexBuffer *)jarg1;
16951   {
16952     try {
16953       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16954     } CALL_CATCH_EXCEPTION(0);
16955   }
16956
16957   jresult = (unsigned long)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16963   void * jresult ;
16964   Dali::Geometry result;
16965
16966   {
16967     try {
16968       result = Dali::Geometry::New();
16969     } CALL_CATCH_EXCEPTION(0);
16970   }
16971
16972   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16973   return jresult;
16974 }
16975
16976
16977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16978   void * jresult ;
16979   Dali::Geometry *result = 0 ;
16980
16981   {
16982     try {
16983       result = (Dali::Geometry *)new Dali::Geometry();
16984     } CALL_CATCH_EXCEPTION(0);
16985   }
16986
16987   jresult = (void *)result;
16988   return jresult;
16989 }
16990
16991
16992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16993   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16994
16995   arg1 = (Dali::Geometry *)jarg1;
16996   {
16997     try {
16998       delete arg1;
16999     } CALL_CATCH_EXCEPTION();
17000   }
17001
17002 }
17003
17004
17005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
17006   void * jresult ;
17007   Dali::Geometry *arg1 = 0 ;
17008   Dali::Geometry *result = 0 ;
17009
17010   arg1 = (Dali::Geometry *)jarg1;
17011   if (!arg1) {
17012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17013     return 0;
17014   }
17015   {
17016     try {
17017       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
17018     } CALL_CATCH_EXCEPTION(0);
17019   }
17020
17021   jresult = (void *)result;
17022   return jresult;
17023 }
17024
17025
17026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
17027   void * jresult ;
17028   Dali::BaseHandle arg1 ;
17029   Dali::BaseHandle *argp1 ;
17030   Dali::Geometry result;
17031
17032   argp1 = (Dali::BaseHandle *)jarg1;
17033   if (!argp1) {
17034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17035     return 0;
17036   }
17037   arg1 = *argp1;
17038   {
17039     try {
17040       result = Dali::Geometry::DownCast(arg1);
17041     } CALL_CATCH_EXCEPTION(0);
17042   }
17043
17044   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17045   return jresult;
17046 }
17047
17048
17049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
17050   void * jresult ;
17051   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17052   Dali::Geometry *arg2 = 0 ;
17053   Dali::Geometry *result = 0 ;
17054
17055   arg1 = (Dali::Geometry *)jarg1;
17056   arg2 = (Dali::Geometry *)jarg2;
17057   if (!arg2) {
17058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
17059     return 0;
17060   }
17061   {
17062     try {
17063       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
17064     } CALL_CATCH_EXCEPTION(0);
17065   }
17066
17067   jresult = (void *)result;
17068   return jresult;
17069 }
17070
17071
17072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
17073   unsigned long jresult ;
17074   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17075   Dali::VertexBuffer *arg2 = 0 ;
17076   std::size_t result;
17077
17078   arg1 = (Dali::Geometry *)jarg1;
17079   arg2 = (Dali::VertexBuffer *)jarg2;
17080   if (!arg2) {
17081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
17082     return 0;
17083   }
17084   {
17085     try {
17086       result = (arg1)->AddVertexBuffer(*arg2);
17087     } CALL_CATCH_EXCEPTION(0);
17088   }
17089
17090   jresult = (unsigned long)result;
17091   return jresult;
17092 }
17093
17094
17095 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
17096   unsigned long jresult ;
17097   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17098   std::size_t result;
17099
17100   arg1 = (Dali::Geometry *)jarg1;
17101   {
17102     try {
17103       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
17104     } CALL_CATCH_EXCEPTION(0);
17105   }
17106
17107   jresult = (unsigned long)result;
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
17113   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17114   std::size_t arg2 ;
17115
17116   arg1 = (Dali::Geometry *)jarg1;
17117   arg2 = (std::size_t)jarg2;
17118   {
17119     try {
17120       (arg1)->RemoveVertexBuffer(arg2);
17121     } CALL_CATCH_EXCEPTION();
17122   }
17123
17124 }
17125
17126
17127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
17128   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17129   unsigned short *arg2 = (unsigned short *) 0 ;
17130   size_t arg3 ;
17131
17132   arg1 = (Dali::Geometry *)jarg1;
17133   arg2 = jarg2;
17134   arg3 = (size_t)jarg3;
17135   {
17136     try {
17137       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
17138     } CALL_CATCH_EXCEPTION();
17139   }
17140
17141
17142
17143 }
17144
17145
17146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
17147   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17148   Dali::Geometry::Type arg2 ;
17149
17150   arg1 = (Dali::Geometry *)jarg1;
17151   arg2 = (Dali::Geometry::Type)jarg2;
17152   {
17153     try {
17154       (arg1)->SetType(arg2);
17155     } CALL_CATCH_EXCEPTION();
17156   }
17157
17158 }
17159
17160
17161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
17162   int jresult ;
17163   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
17164   Dali::Geometry::Type result;
17165
17166   arg1 = (Dali::Geometry *)jarg1;
17167   {
17168     try {
17169       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
17170     } CALL_CATCH_EXCEPTION(0);
17171   }
17172
17173   jresult = (int)result;
17174   return jresult;
17175 }
17176
17177
17178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
17179   void * jresult ;
17180   Dali::Shader::Hint *result = 0 ;
17181
17182   {
17183     try {
17184       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
17185     } CALL_CATCH_EXCEPTION(0);
17186   }
17187
17188   jresult = (void *)result;
17189   return jresult;
17190 }
17191
17192
17193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
17194   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
17195
17196   arg1 = (Dali::Shader::Hint *)jarg1;
17197   {
17198     try {
17199       delete arg1;
17200     } CALL_CATCH_EXCEPTION();
17201   }
17202
17203 }
17204
17205
17206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
17207   int jresult ;
17208   int result;
17209
17210   result = (int)Dali::Shader::Property::PROGRAM;
17211   jresult = (int)result;
17212   return jresult;
17213 }
17214
17215
17216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
17217   void * jresult ;
17218   Dali::Shader::Property *result = 0 ;
17219
17220   {
17221     try {
17222       result = (Dali::Shader::Property *)new Dali::Shader::Property();
17223     } CALL_CATCH_EXCEPTION(0);
17224   }
17225
17226   jresult = (void *)result;
17227   return jresult;
17228 }
17229
17230
17231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
17232   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
17233
17234   arg1 = (Dali::Shader::Property *)jarg1;
17235   {
17236     try {
17237       delete arg1;
17238     } CALL_CATCH_EXCEPTION();
17239   }
17240
17241 }
17242
17243
17244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
17245   void * jresult ;
17246   std::string *arg1 = 0 ;
17247   std::string *arg2 = 0 ;
17248   Dali::Shader::Hint::Value arg3 ;
17249   Dali::Shader result;
17250
17251   if (!jarg1) {
17252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17253     return 0;
17254   }
17255   std::string arg1_str(jarg1);
17256   arg1 = &arg1_str;
17257   if (!jarg2) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17259     return 0;
17260   }
17261   std::string arg2_str(jarg2);
17262   arg2 = &arg2_str;
17263   arg3 = (Dali::Shader::Hint::Value)jarg3;
17264   {
17265     try {
17266       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
17267     } CALL_CATCH_EXCEPTION(0);
17268   }
17269
17270   jresult = new Dali::Shader((const Dali::Shader &)result);
17271
17272   //argout typemap for const std::string&
17273
17274
17275   //argout typemap for const std::string&
17276
17277   return jresult;
17278 }
17279
17280
17281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
17282   void * jresult ;
17283   std::string *arg1 = 0 ;
17284   std::string *arg2 = 0 ;
17285   Dali::Shader result;
17286
17287   if (!jarg1) {
17288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17289     return 0;
17290   }
17291   std::string arg1_str(jarg1);
17292   arg1 = &arg1_str;
17293   if (!jarg2) {
17294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17295     return 0;
17296   }
17297   std::string arg2_str(jarg2);
17298   arg2 = &arg2_str;
17299   {
17300     try {
17301       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
17302     } CALL_CATCH_EXCEPTION(0);
17303   }
17304
17305   jresult = new Dali::Shader((const Dali::Shader &)result);
17306
17307   //argout typemap for const std::string&
17308
17309
17310   //argout typemap for const std::string&
17311
17312   return jresult;
17313 }
17314
17315
17316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
17317   void * jresult ;
17318   Dali::Shader *result = 0 ;
17319
17320   {
17321     try {
17322       result = (Dali::Shader *)new Dali::Shader();
17323     } CALL_CATCH_EXCEPTION(0);
17324   }
17325
17326   jresult = (void *)result;
17327   return jresult;
17328 }
17329
17330
17331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
17332   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17333
17334   arg1 = (Dali::Shader *)jarg1;
17335   {
17336     try {
17337       delete arg1;
17338     } CALL_CATCH_EXCEPTION();
17339   }
17340
17341 }
17342
17343
17344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
17345   void * jresult ;
17346   Dali::Shader *arg1 = 0 ;
17347   Dali::Shader *result = 0 ;
17348
17349   arg1 = (Dali::Shader *)jarg1;
17350   if (!arg1) {
17351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17352     return 0;
17353   }
17354   {
17355     try {
17356       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
17357     } CALL_CATCH_EXCEPTION(0);
17358   }
17359
17360   jresult = (void *)result;
17361   return jresult;
17362 }
17363
17364
17365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
17366   void * jresult ;
17367   Dali::BaseHandle arg1 ;
17368   Dali::BaseHandle *argp1 ;
17369   Dali::Shader result;
17370
17371   argp1 = (Dali::BaseHandle *)jarg1;
17372   if (!argp1) {
17373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17374     return 0;
17375   }
17376   arg1 = *argp1;
17377   {
17378     try {
17379       result = Dali::Shader::DownCast(arg1);
17380     } CALL_CATCH_EXCEPTION(0);
17381   }
17382
17383   jresult = new Dali::Shader((const Dali::Shader &)result);
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
17389   void * jresult ;
17390   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17391   Dali::Shader *arg2 = 0 ;
17392   Dali::Shader *result = 0 ;
17393
17394   arg1 = (Dali::Shader *)jarg1;
17395   arg2 = (Dali::Shader *)jarg2;
17396   if (!arg2) {
17397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17398     return 0;
17399   }
17400   {
17401     try {
17402       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
17403     } CALL_CATCH_EXCEPTION(0);
17404   }
17405
17406   jresult = (void *)result;
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
17412   int jresult ;
17413   int result;
17414
17415   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
17416   jresult = (int)result;
17417   return jresult;
17418 }
17419
17420
17421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
17422   int jresult ;
17423   int result;
17424
17425   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
17426   jresult = (int)result;
17427   return jresult;
17428 }
17429
17430
17431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
17432   int jresult ;
17433   int result;
17434
17435   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
17436   jresult = (int)result;
17437   return jresult;
17438 }
17439
17440
17441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
17442   int jresult ;
17443   int result;
17444
17445   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
17446   jresult = (int)result;
17447   return jresult;
17448 }
17449
17450
17451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
17452   int jresult ;
17453   int result;
17454
17455   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
17456   jresult = (int)result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
17462   int jresult ;
17463   int result;
17464
17465   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
17466   jresult = (int)result;
17467   return jresult;
17468 }
17469
17470
17471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
17472   int jresult ;
17473   int result;
17474
17475   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
17476   jresult = (int)result;
17477   return jresult;
17478 }
17479
17480
17481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
17482   int jresult ;
17483   int result;
17484
17485   result = (int)Dali::Renderer::Property::BLEND_MODE;
17486   jresult = (int)result;
17487   return jresult;
17488 }
17489
17490
17491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
17492   int jresult ;
17493   int result;
17494
17495   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
17496   jresult = (int)result;
17497   return jresult;
17498 }
17499
17500
17501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
17502   int jresult ;
17503   int result;
17504
17505   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
17506   jresult = (int)result;
17507   return jresult;
17508 }
17509
17510
17511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
17512   int jresult ;
17513   int result;
17514
17515   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
17516   jresult = (int)result;
17517   return jresult;
17518 }
17519
17520
17521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
17522   int jresult ;
17523   int result;
17524
17525   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
17526   jresult = (int)result;
17527   return jresult;
17528 }
17529
17530
17531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
17532   int jresult ;
17533   int result;
17534
17535   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
17536   jresult = (int)result;
17537   return jresult;
17538 }
17539
17540
17541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
17542   int jresult ;
17543   int result;
17544
17545   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
17546   jresult = (int)result;
17547   return jresult;
17548 }
17549
17550
17551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
17552   int jresult ;
17553   int result;
17554
17555   result = (int)Dali::Renderer::Property::BLEND_COLOR;
17556   jresult = (int)result;
17557   return jresult;
17558 }
17559
17560
17561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
17562   int jresult ;
17563   int result;
17564
17565   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
17566   jresult = (int)result;
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
17572   int jresult ;
17573   int result;
17574
17575   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
17576   jresult = (int)result;
17577   return jresult;
17578 }
17579
17580
17581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
17582   int jresult ;
17583   int result;
17584
17585   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
17586   jresult = (int)result;
17587   return jresult;
17588 }
17589
17590
17591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
17592   int jresult ;
17593   int result;
17594
17595   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
17596   jresult = (int)result;
17597   return jresult;
17598 }
17599
17600
17601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
17602   int jresult ;
17603   int result;
17604
17605   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
17606   jresult = (int)result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
17612   int jresult ;
17613   int result;
17614
17615   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
17616   jresult = (int)result;
17617   return jresult;
17618 }
17619
17620
17621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
17622   int jresult ;
17623   int result;
17624
17625   result = (int)Dali::Renderer::Property::RENDER_MODE;
17626   jresult = (int)result;
17627   return jresult;
17628 }
17629
17630
17631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
17632   int jresult ;
17633   int result;
17634
17635   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
17636   jresult = (int)result;
17637   return jresult;
17638 }
17639
17640
17641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
17642   int jresult ;
17643   int result;
17644
17645   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
17646   jresult = (int)result;
17647   return jresult;
17648 }
17649
17650
17651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
17652   int jresult ;
17653   int result;
17654
17655   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
17656   jresult = (int)result;
17657   return jresult;
17658 }
17659
17660
17661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
17662   int jresult ;
17663   int result;
17664
17665   result = (int)Dali::Renderer::Property::STENCIL_MASK;
17666   jresult = (int)result;
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
17672   int jresult ;
17673   int result;
17674
17675   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
17676   jresult = (int)result;
17677   return jresult;
17678 }
17679
17680
17681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
17682   int jresult ;
17683   int result;
17684
17685   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
17686   jresult = (int)result;
17687   return jresult;
17688 }
17689
17690
17691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
17692   int jresult ;
17693   int result;
17694
17695   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
17696   jresult = (int)result;
17697   return jresult;
17698 }
17699
17700
17701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
17702   void * jresult ;
17703   Dali::Renderer::Property *result = 0 ;
17704
17705   {
17706     try {
17707       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
17708     } CALL_CATCH_EXCEPTION(0);
17709   }
17710
17711   jresult = (void *)result;
17712   return jresult;
17713 }
17714
17715
17716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
17717   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
17718
17719   arg1 = (Dali::Renderer::Property *)jarg1;
17720   {
17721     try {
17722       delete arg1;
17723     } CALL_CATCH_EXCEPTION();
17724   }
17725
17726 }
17727
17728
17729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
17730   void * jresult ;
17731   Dali::Geometry *arg1 = 0 ;
17732   Dali::Shader *arg2 = 0 ;
17733   Dali::Renderer result;
17734
17735   arg1 = (Dali::Geometry *)jarg1;
17736   if (!arg1) {
17737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17738     return 0;
17739   }
17740   arg2 = (Dali::Shader *)jarg2;
17741   if (!arg2) {
17742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17743     return 0;
17744   }
17745   {
17746     try {
17747       result = Dali::Renderer::New(*arg1,*arg2);
17748     } CALL_CATCH_EXCEPTION(0);
17749   }
17750
17751   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17752   return jresult;
17753 }
17754
17755
17756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
17757   void * jresult ;
17758   Dali::Renderer *result = 0 ;
17759
17760   {
17761     try {
17762       result = (Dali::Renderer *)new Dali::Renderer();
17763     } CALL_CATCH_EXCEPTION(0);
17764   }
17765
17766   jresult = (void *)result;
17767   return jresult;
17768 }
17769
17770
17771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
17772   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17773
17774   arg1 = (Dali::Renderer *)jarg1;
17775   {
17776     try {
17777       delete arg1;
17778     } CALL_CATCH_EXCEPTION();
17779   }
17780
17781 }
17782
17783
17784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
17785   void * jresult ;
17786   Dali::Renderer *arg1 = 0 ;
17787   Dali::Renderer *result = 0 ;
17788
17789   arg1 = (Dali::Renderer *)jarg1;
17790   if (!arg1) {
17791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17792     return 0;
17793   }
17794   {
17795     try {
17796       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
17797     } CALL_CATCH_EXCEPTION(0);
17798   }
17799
17800   jresult = (void *)result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
17806   void * jresult ;
17807   Dali::BaseHandle arg1 ;
17808   Dali::BaseHandle *argp1 ;
17809   Dali::Renderer result;
17810
17811   argp1 = (Dali::BaseHandle *)jarg1;
17812   if (!argp1) {
17813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17814     return 0;
17815   }
17816   arg1 = *argp1;
17817   {
17818     try {
17819       result = Dali::Renderer::DownCast(arg1);
17820     } CALL_CATCH_EXCEPTION(0);
17821   }
17822
17823   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17824   return jresult;
17825 }
17826
17827
17828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17829   void * jresult ;
17830   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17831   Dali::Renderer *arg2 = 0 ;
17832   Dali::Renderer *result = 0 ;
17833
17834   arg1 = (Dali::Renderer *)jarg1;
17835   arg2 = (Dali::Renderer *)jarg2;
17836   if (!arg2) {
17837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17838     return 0;
17839   }
17840   {
17841     try {
17842       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17843     } CALL_CATCH_EXCEPTION(0);
17844   }
17845
17846   jresult = (void *)result;
17847   return jresult;
17848 }
17849
17850
17851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17852   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17853   Dali::Geometry *arg2 = 0 ;
17854
17855   arg1 = (Dali::Renderer *)jarg1;
17856   arg2 = (Dali::Geometry *)jarg2;
17857   if (!arg2) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17859     return ;
17860   }
17861   {
17862     try {
17863       (arg1)->SetGeometry(*arg2);
17864     } CALL_CATCH_EXCEPTION();
17865   }
17866
17867 }
17868
17869
17870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17871   void * jresult ;
17872   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17873   Dali::Geometry result;
17874
17875   arg1 = (Dali::Renderer *)jarg1;
17876   {
17877     try {
17878       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17879     } CALL_CATCH_EXCEPTION(0);
17880   }
17881
17882   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17883   return jresult;
17884 }
17885
17886
17887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17888   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17889   int arg2 ;
17890   int arg3 ;
17891
17892   arg1 = (Dali::Renderer *)jarg1;
17893   arg2 = (int)jarg2;
17894   arg3 = (int)jarg3;
17895   {
17896     try {
17897       (arg1)->SetIndexRange(arg2,arg3);
17898     } CALL_CATCH_EXCEPTION();
17899   }
17900
17901 }
17902
17903
17904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17905   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17906   Dali::TextureSet *arg2 = 0 ;
17907
17908   arg1 = (Dali::Renderer *)jarg1;
17909   arg2 = (Dali::TextureSet *)jarg2;
17910   if (!arg2) {
17911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17912     return ;
17913   }
17914   {
17915     try {
17916       (arg1)->SetTextures(*arg2);
17917     } CALL_CATCH_EXCEPTION();
17918   }
17919
17920 }
17921
17922
17923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17924   void * jresult ;
17925   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17926   Dali::TextureSet result;
17927
17928   arg1 = (Dali::Renderer *)jarg1;
17929   {
17930     try {
17931       result = ((Dali::Renderer const *)arg1)->GetTextures();
17932     } CALL_CATCH_EXCEPTION(0);
17933   }
17934
17935   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17936   return jresult;
17937 }
17938
17939
17940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17941   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17942   Dali::Shader *arg2 = 0 ;
17943
17944   arg1 = (Dali::Renderer *)jarg1;
17945   arg2 = (Dali::Shader *)jarg2;
17946   if (!arg2) {
17947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17948     return ;
17949   }
17950   {
17951     try {
17952       (arg1)->SetShader(*arg2);
17953     } CALL_CATCH_EXCEPTION();
17954   }
17955
17956 }
17957
17958
17959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17960   void * jresult ;
17961   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17962   Dali::Shader result;
17963
17964   arg1 = (Dali::Renderer *)jarg1;
17965   {
17966     try {
17967       result = ((Dali::Renderer const *)arg1)->GetShader();
17968     } CALL_CATCH_EXCEPTION(0);
17969   }
17970
17971   jresult = new Dali::Shader((const Dali::Shader &)result);
17972   return jresult;
17973 }
17974
17975
17976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17977   void * jresult ;
17978   Dali::FrameBuffer::Attachment *result = 0 ;
17979
17980   {
17981     try {
17982       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17983     } CALL_CATCH_EXCEPTION(0);
17984   }
17985
17986   jresult = (void *)result;
17987   return jresult;
17988 }
17989
17990
17991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17992   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17993
17994   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17995   {
17996     try {
17997       delete arg1;
17998     } CALL_CATCH_EXCEPTION();
17999   }
18000
18001 }
18002
18003
18004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
18005   void * jresult ;
18006   unsigned int arg1 ;
18007   unsigned int arg2 ;
18008   unsigned int arg3 ;
18009   Dali::FrameBuffer result;
18010
18011   arg1 = (unsigned int)jarg1;
18012   arg2 = (unsigned int)jarg2;
18013   arg3 = (unsigned int)jarg3;
18014   {
18015     try {
18016       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
18017     } CALL_CATCH_EXCEPTION(0);
18018   }
18019
18020   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18021   return jresult;
18022 }
18023
18024
18025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
18026   void * jresult ;
18027   Dali::FrameBuffer *result = 0 ;
18028
18029   {
18030     try {
18031       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
18032     } CALL_CATCH_EXCEPTION(0);
18033   }
18034
18035   jresult = (void *)result;
18036   return jresult;
18037 }
18038
18039
18040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
18041   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18042
18043   arg1 = (Dali::FrameBuffer *)jarg1;
18044   {
18045     try {
18046       delete arg1;
18047     } CALL_CATCH_EXCEPTION();
18048   }
18049
18050 }
18051
18052
18053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
18054   void * jresult ;
18055   Dali::FrameBuffer *arg1 = 0 ;
18056   Dali::FrameBuffer *result = 0 ;
18057
18058   arg1 = (Dali::FrameBuffer *)jarg1;
18059   if (!arg1) {
18060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18061     return 0;
18062   }
18063   {
18064     try {
18065       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
18066     } CALL_CATCH_EXCEPTION(0);
18067   }
18068
18069   jresult = (void *)result;
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
18075   void * jresult ;
18076   Dali::BaseHandle arg1 ;
18077   Dali::BaseHandle *argp1 ;
18078   Dali::FrameBuffer result;
18079
18080   argp1 = (Dali::BaseHandle *)jarg1;
18081   if (!argp1) {
18082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18083     return 0;
18084   }
18085   arg1 = *argp1;
18086   {
18087     try {
18088       result = Dali::FrameBuffer::DownCast(arg1);
18089     } CALL_CATCH_EXCEPTION(0);
18090   }
18091
18092   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
18098   void * jresult ;
18099   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18100   Dali::FrameBuffer *arg2 = 0 ;
18101   Dali::FrameBuffer *result = 0 ;
18102
18103   arg1 = (Dali::FrameBuffer *)jarg1;
18104   arg2 = (Dali::FrameBuffer *)jarg2;
18105   if (!arg2) {
18106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
18107     return 0;
18108   }
18109   {
18110     try {
18111       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
18112     } CALL_CATCH_EXCEPTION(0);
18113   }
18114
18115   jresult = (void *)result;
18116   return jresult;
18117 }
18118
18119
18120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
18121   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18122   Dali::Texture *arg2 = 0 ;
18123
18124   arg1 = (Dali::FrameBuffer *)jarg1;
18125   arg2 = (Dali::Texture *)jarg2;
18126   if (!arg2) {
18127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18128     return ;
18129   }
18130   {
18131     try {
18132       (arg1)->AttachColorTexture(*arg2);
18133     } CALL_CATCH_EXCEPTION();
18134   }
18135
18136 }
18137
18138
18139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
18140   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18141   Dali::Texture *arg2 = 0 ;
18142   unsigned int arg3 ;
18143   unsigned int arg4 ;
18144
18145   arg1 = (Dali::FrameBuffer *)jarg1;
18146   arg2 = (Dali::Texture *)jarg2;
18147   if (!arg2) {
18148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
18149     return ;
18150   }
18151   arg3 = (unsigned int)jarg3;
18152   arg4 = (unsigned int)jarg4;
18153   {
18154     try {
18155       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
18156     } CALL_CATCH_EXCEPTION();
18157   }
18158
18159 }
18160
18161
18162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
18163   void * jresult ;
18164   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
18165   Dali::Texture result;
18166
18167   arg1 = (Dali::FrameBuffer *)jarg1;
18168   {
18169     try {
18170       result = (arg1)->GetColorTexture();
18171     } CALL_CATCH_EXCEPTION(0);
18172   }
18173
18174   jresult = new Dali::Texture((const Dali::Texture &)result);
18175   return jresult;
18176 }
18177
18178 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
18179 {
18180   void *jresult;
18181   Dali::Toolkit::ImageUrl result;
18182   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
18183
18184   if (!frameBuffer)
18185   {
18186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
18187     return 0;
18188   }
18189   {
18190     try
18191     {
18192       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
18193     }
18194     CALL_CATCH_EXCEPTION(0);
18195   }
18196
18197   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
18203   void * jresult ;
18204   Dali::RenderTaskList *result = 0 ;
18205
18206   {
18207     try {
18208       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
18209     } CALL_CATCH_EXCEPTION(0);
18210   }
18211
18212   jresult = (void *)result;
18213   return jresult;
18214 }
18215
18216
18217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
18218   void * jresult ;
18219   Dali::BaseHandle arg1 ;
18220   Dali::BaseHandle *argp1 ;
18221   Dali::RenderTaskList result;
18222
18223   argp1 = (Dali::BaseHandle *)jarg1;
18224   if (!argp1) {
18225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18226     return 0;
18227   }
18228   arg1 = *argp1;
18229   {
18230     try {
18231       result = Dali::RenderTaskList::DownCast(arg1);
18232     } CALL_CATCH_EXCEPTION(0);
18233   }
18234
18235   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
18236   return jresult;
18237 }
18238
18239
18240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
18241   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18242
18243   arg1 = (Dali::RenderTaskList *)jarg1;
18244   {
18245     try {
18246       delete arg1;
18247     } CALL_CATCH_EXCEPTION();
18248   }
18249
18250 }
18251
18252
18253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
18254   void * jresult ;
18255   Dali::RenderTaskList *arg1 = 0 ;
18256   Dali::RenderTaskList *result = 0 ;
18257
18258   arg1 = (Dali::RenderTaskList *)jarg1;
18259   if (!arg1) {
18260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18261     return 0;
18262   }
18263   {
18264     try {
18265       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
18266     } CALL_CATCH_EXCEPTION(0);
18267   }
18268
18269   jresult = (void *)result;
18270   return jresult;
18271 }
18272
18273
18274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
18275   void * jresult ;
18276   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18277   Dali::RenderTaskList *arg2 = 0 ;
18278   Dali::RenderTaskList *result = 0 ;
18279
18280   arg1 = (Dali::RenderTaskList *)jarg1;
18281   arg2 = (Dali::RenderTaskList *)jarg2;
18282   if (!arg2) {
18283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18284     return 0;
18285   }
18286   {
18287     try {
18288       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
18289     } CALL_CATCH_EXCEPTION(0);
18290   }
18291
18292   jresult = (void *)result;
18293   return jresult;
18294 }
18295
18296
18297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
18298   void * jresult ;
18299   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18300   Dali::RenderTask result;
18301
18302   arg1 = (Dali::RenderTaskList *)jarg1;
18303   {
18304     try {
18305       result = (arg1)->CreateTask();
18306     } CALL_CATCH_EXCEPTION(0);
18307   }
18308
18309   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18310   return jresult;
18311 }
18312
18313
18314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
18315   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18316   Dali::RenderTask arg2 ;
18317   Dali::RenderTask *argp2 ;
18318
18319   arg1 = (Dali::RenderTaskList *)jarg1;
18320   argp2 = (Dali::RenderTask *)jarg2;
18321   if (!argp2) {
18322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
18323     return ;
18324   }
18325   arg2 = *argp2;
18326   {
18327     try {
18328       (arg1)->RemoveTask(arg2);
18329     } CALL_CATCH_EXCEPTION();
18330   }
18331
18332 }
18333
18334
18335 //// ===============================================end part 1 =================
18336
18337 //// ========================= part 2 ===============================
18338
18339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
18340   unsigned int jresult ;
18341   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18342   unsigned int result;
18343
18344   arg1 = (Dali::RenderTaskList *)jarg1;
18345   {
18346     try {
18347       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
18348     } CALL_CATCH_EXCEPTION(0);
18349   }
18350
18351   jresult = result;
18352   return jresult;
18353 }
18354
18355
18356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
18357   void * jresult ;
18358   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18359   unsigned int arg2 ;
18360   Dali::RenderTask result;
18361
18362   arg1 = (Dali::RenderTaskList *)jarg1;
18363   arg2 = (unsigned int)jarg2;
18364   {
18365     try {
18366       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
18367     } CALL_CATCH_EXCEPTION(0);
18368   }
18369
18370   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18371   return jresult;
18372 }
18373
18374
18375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
18376   int jresult ;
18377   int result;
18378
18379   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
18380   jresult = (int)result;
18381   return jresult;
18382 }
18383
18384
18385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
18386   int jresult ;
18387   int result;
18388
18389   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
18390   jresult = (int)result;
18391   return jresult;
18392 }
18393
18394
18395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
18396   int jresult ;
18397   int result;
18398
18399   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
18400   jresult = (int)result;
18401   return jresult;
18402 }
18403
18404
18405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
18406   int jresult ;
18407   int result;
18408
18409   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
18410   jresult = (int)result;
18411   return jresult;
18412 }
18413
18414
18415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
18416   void * jresult ;
18417   Dali::RenderTask::Property *result = 0 ;
18418
18419   {
18420     try {
18421       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
18422     } CALL_CATCH_EXCEPTION(0);
18423   }
18424
18425   jresult = (void *)result;
18426   return jresult;
18427 }
18428
18429
18430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
18431   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
18432
18433   arg1 = (Dali::RenderTask::Property *)jarg1;
18434   {
18435     try {
18436       delete arg1;
18437     } CALL_CATCH_EXCEPTION();
18438   }
18439
18440 }
18441
18442
18443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
18444   void * jresult ;
18445   bool (*result)(Dali::Vector2 &) = 0 ;
18446
18447   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
18448   jresult = (void *)result;
18449   return jresult;
18450 }
18451
18452
18453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
18454   void * jresult ;
18455   bool (*result)(Dali::Vector2 &) = 0 ;
18456
18457   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
18458   jresult = (void *)result;
18459   return jresult;
18460 }
18461
18462
18463 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
18464   bool jresult ;
18465   bool result;
18466
18467   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
18468   jresult = result;
18469   return jresult;
18470 }
18471
18472
18473 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
18474   bool jresult ;
18475   bool result;
18476
18477   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
18478   jresult = result;
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
18484   void * jresult ;
18485   Dali::Vector4 *result = 0 ;
18486
18487   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
18488   jresult = (void *)result;
18489   return jresult;
18490 }
18491
18492
18493 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
18494   bool jresult ;
18495   bool result;
18496
18497   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
18498   jresult = result;
18499   return jresult;
18500 }
18501
18502
18503 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
18504   bool jresult ;
18505   bool result;
18506
18507   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
18508   jresult = result;
18509   return jresult;
18510 }
18511
18512
18513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
18514   unsigned int jresult ;
18515   unsigned int result;
18516
18517   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
18518   jresult = result;
18519   return jresult;
18520 }
18521
18522
18523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
18524   void * jresult ;
18525   Dali::RenderTask *result = 0 ;
18526
18527   {
18528     try {
18529       result = (Dali::RenderTask *)new Dali::RenderTask();
18530     } CALL_CATCH_EXCEPTION(0);
18531   }
18532
18533   jresult = (void *)result;
18534   return jresult;
18535 }
18536
18537
18538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
18539   void * jresult ;
18540   Dali::BaseHandle arg1 ;
18541   Dali::BaseHandle *argp1 ;
18542   Dali::RenderTask result;
18543
18544   argp1 = (Dali::BaseHandle *)jarg1;
18545   if (!argp1) {
18546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18547     return 0;
18548   }
18549   arg1 = *argp1;
18550   {
18551     try {
18552       result = Dali::RenderTask::DownCast(arg1);
18553     } CALL_CATCH_EXCEPTION(0);
18554   }
18555
18556   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18557   return jresult;
18558 }
18559
18560
18561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
18562   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18563
18564   arg1 = (Dali::RenderTask *)jarg1;
18565   {
18566     try {
18567       delete arg1;
18568     } CALL_CATCH_EXCEPTION();
18569   }
18570
18571 }
18572
18573
18574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
18575   void * jresult ;
18576   Dali::RenderTask *arg1 = 0 ;
18577   Dali::RenderTask *result = 0 ;
18578
18579   arg1 = (Dali::RenderTask *)jarg1;
18580   if (!arg1) {
18581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18582     return 0;
18583   }
18584   {
18585     try {
18586       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
18587     } CALL_CATCH_EXCEPTION(0);
18588   }
18589
18590   jresult = (void *)result;
18591   return jresult;
18592 }
18593
18594
18595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
18596   void * jresult ;
18597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18598   Dali::RenderTask *arg2 = 0 ;
18599   Dali::RenderTask *result = 0 ;
18600
18601   arg1 = (Dali::RenderTask *)jarg1;
18602   arg2 = (Dali::RenderTask *)jarg2;
18603   if (!arg2) {
18604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18605     return 0;
18606   }
18607   {
18608     try {
18609       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
18610     } CALL_CATCH_EXCEPTION(0);
18611   }
18612
18613   jresult = (void *)result;
18614   return jresult;
18615 }
18616
18617
18618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
18619   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18620   Dali::Actor arg2 ;
18621   Dali::Actor *argp2 ;
18622
18623   arg1 = (Dali::RenderTask *)jarg1;
18624   argp2 = (Dali::Actor *)jarg2;
18625   if (!argp2) {
18626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18627     return ;
18628   }
18629   arg2 = *argp2;
18630   {
18631     try {
18632       (arg1)->SetSourceActor(arg2);
18633     } CALL_CATCH_EXCEPTION();
18634   }
18635
18636 }
18637
18638
18639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
18640   void * jresult ;
18641   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18642   Dali::Actor result;
18643
18644   arg1 = (Dali::RenderTask *)jarg1;
18645   {
18646     try {
18647       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
18648     } CALL_CATCH_EXCEPTION(0);
18649   }
18650
18651   jresult = new Dali::Actor((const Dali::Actor &)result);
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
18657   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18658   bool arg2 ;
18659
18660   arg1 = (Dali::RenderTask *)jarg1;
18661   arg2 = jarg2 ? true : false;
18662   {
18663     try {
18664       (arg1)->SetExclusive(arg2);
18665     } CALL_CATCH_EXCEPTION();
18666   }
18667
18668 }
18669
18670
18671 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
18672   bool jresult ;
18673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18674   bool result;
18675
18676   arg1 = (Dali::RenderTask *)jarg1;
18677   {
18678     try {
18679       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
18680     } CALL_CATCH_EXCEPTION(0);
18681   }
18682
18683   jresult = result;
18684   return jresult;
18685 }
18686
18687
18688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
18689   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18690   bool arg2 ;
18691
18692   arg1 = (Dali::RenderTask *)jarg1;
18693   arg2 = jarg2 ? true : false;
18694   {
18695     try {
18696       (arg1)->SetInputEnabled(arg2);
18697     } CALL_CATCH_EXCEPTION();
18698   }
18699
18700 }
18701
18702
18703 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
18704   bool jresult ;
18705   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18706   bool result;
18707
18708   arg1 = (Dali::RenderTask *)jarg1;
18709   {
18710     try {
18711       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
18712     } CALL_CATCH_EXCEPTION(0);
18713   }
18714
18715   jresult = result;
18716   return jresult;
18717 }
18718
18719
18720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
18721   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18722   Dali::CameraActor arg2 ;
18723   Dali::CameraActor *argp2 ;
18724
18725   arg1 = (Dali::RenderTask *)jarg1;
18726   argp2 = (Dali::CameraActor *)jarg2;
18727   if (!argp2) {
18728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
18729     return ;
18730   }
18731   arg2 = *argp2;
18732   {
18733     try {
18734       (arg1)->SetCameraActor(arg2);
18735     } CALL_CATCH_EXCEPTION();
18736   }
18737
18738 }
18739
18740
18741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
18742   void * jresult ;
18743   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18744   Dali::CameraActor result;
18745
18746   arg1 = (Dali::RenderTask *)jarg1;
18747   {
18748     try {
18749       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
18750     } CALL_CATCH_EXCEPTION(0);
18751   }
18752
18753   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
18754   return jresult;
18755 }
18756
18757
18758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
18759   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18760   Dali::FrameBuffer arg2 ;
18761   Dali::FrameBuffer *argp2 ;
18762
18763   arg1 = (Dali::RenderTask *)jarg1;
18764   argp2 = (Dali::FrameBuffer *)jarg2;
18765   if (!argp2) {
18766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
18767     return ;
18768   }
18769   arg2 = *argp2;
18770   {
18771     try {
18772       (arg1)->SetFrameBuffer(arg2);
18773     } CALL_CATCH_EXCEPTION();
18774   }
18775
18776 }
18777
18778
18779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
18780   void * jresult ;
18781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18782   Dali::FrameBuffer result;
18783
18784   arg1 = (Dali::RenderTask *)jarg1;
18785   {
18786     try {
18787       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
18788     } CALL_CATCH_EXCEPTION(0);
18789   }
18790
18791   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18792   return jresult;
18793 }
18794
18795
18796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
18797   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18798   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
18799
18800   arg1 = (Dali::RenderTask *)jarg1;
18801   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
18802   {
18803     try {
18804       (arg1)->SetScreenToFrameBufferFunction(arg2);
18805     } CALL_CATCH_EXCEPTION();
18806   }
18807
18808 }
18809
18810
18811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
18812   void * jresult ;
18813   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18814   Dali::RenderTask::ScreenToFrameBufferFunction result;
18815
18816   arg1 = (Dali::RenderTask *)jarg1;
18817   {
18818     try {
18819       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
18820     } CALL_CATCH_EXCEPTION(0);
18821   }
18822
18823   jresult = (void *)result;
18824   return jresult;
18825 }
18826
18827
18828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
18829   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18830   Dali::Actor arg2 ;
18831   Dali::Actor *argp2 ;
18832
18833   arg1 = (Dali::RenderTask *)jarg1;
18834   argp2 = (Dali::Actor *)jarg2;
18835   if (!argp2) {
18836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18837     return ;
18838   }
18839   arg2 = *argp2;
18840   {
18841     try {
18842       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
18843     } CALL_CATCH_EXCEPTION();
18844   }
18845
18846 }
18847
18848
18849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18850   void * jresult ;
18851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18852   Dali::Actor result;
18853
18854   arg1 = (Dali::RenderTask *)jarg1;
18855   {
18856     try {
18857       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18858     } CALL_CATCH_EXCEPTION(0);
18859   }
18860
18861   jresult = new Dali::Actor((const Dali::Actor &)result);
18862   return jresult;
18863 }
18864
18865
18866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18867   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18868   Dali::Vector2 arg2 ;
18869   Dali::Vector2 *argp2 ;
18870
18871   arg1 = (Dali::RenderTask *)jarg1;
18872   argp2 = (Dali::Vector2 *)jarg2;
18873   if (!argp2) {
18874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18875     return ;
18876   }
18877   arg2 = *argp2;
18878   {
18879     try {
18880       (arg1)->SetViewportPosition(arg2);
18881     } CALL_CATCH_EXCEPTION();
18882   }
18883
18884 }
18885
18886
18887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18888   void * jresult ;
18889   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18890   Dali::Vector2 result;
18891
18892   arg1 = (Dali::RenderTask *)jarg1;
18893   {
18894     try {
18895       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18896     } CALL_CATCH_EXCEPTION(0);
18897   }
18898
18899   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18900   return jresult;
18901 }
18902
18903
18904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18905   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18906   Dali::Vector2 arg2 ;
18907   Dali::Vector2 *argp2 ;
18908
18909   arg1 = (Dali::RenderTask *)jarg1;
18910   argp2 = (Dali::Vector2 *)jarg2;
18911   if (!argp2) {
18912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18913     return ;
18914   }
18915   arg2 = *argp2;
18916   {
18917     try {
18918       (arg1)->SetViewportSize(arg2);
18919     } CALL_CATCH_EXCEPTION();
18920   }
18921
18922 }
18923
18924
18925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18926   void * jresult ;
18927   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18928   Dali::Vector2 result;
18929
18930   arg1 = (Dali::RenderTask *)jarg1;
18931   {
18932     try {
18933       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18934     } CALL_CATCH_EXCEPTION(0);
18935   }
18936
18937   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18938   return jresult;
18939 }
18940
18941
18942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18943   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18944   Dali::Viewport arg2 ;
18945   Dali::Viewport *argp2 ;
18946
18947   arg1 = (Dali::RenderTask *)jarg1;
18948   argp2 = (Dali::Viewport *)jarg2;
18949   if (!argp2) {
18950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18951     return ;
18952   }
18953   arg2 = *argp2;
18954   {
18955     try {
18956       (arg1)->SetViewport(arg2);
18957     } CALL_CATCH_EXCEPTION();
18958   }
18959
18960 }
18961
18962
18963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18964   void * jresult ;
18965   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18966   Dali::Viewport result;
18967
18968   arg1 = (Dali::RenderTask *)jarg1;
18969   {
18970     try {
18971       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18972     } CALL_CATCH_EXCEPTION(0);
18973   }
18974
18975   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18976   return jresult;
18977 }
18978
18979
18980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18981   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18982   Dali::Vector4 *arg2 = 0 ;
18983
18984   arg1 = (Dali::RenderTask *)jarg1;
18985   arg2 = (Dali::Vector4 *)jarg2;
18986   if (!arg2) {
18987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18988     return ;
18989   }
18990   {
18991     try {
18992       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18993     } CALL_CATCH_EXCEPTION();
18994   }
18995
18996 }
18997
18998
18999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
19000   void * jresult ;
19001   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19002   Dali::Vector4 result;
19003
19004   arg1 = (Dali::RenderTask *)jarg1;
19005   {
19006     try {
19007       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
19008     } CALL_CATCH_EXCEPTION(0);
19009   }
19010
19011   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19012   return jresult;
19013 }
19014
19015
19016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
19017   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19018   bool arg2 ;
19019
19020   arg1 = (Dali::RenderTask *)jarg1;
19021   arg2 = jarg2 ? true : false;
19022   {
19023     try {
19024       (arg1)->SetClearEnabled(arg2);
19025     } CALL_CATCH_EXCEPTION();
19026   }
19027
19028 }
19029
19030
19031 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
19032   bool jresult ;
19033   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19034   bool result;
19035
19036   arg1 = (Dali::RenderTask *)jarg1;
19037   {
19038     try {
19039       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
19040     } CALL_CATCH_EXCEPTION(0);
19041   }
19042
19043   jresult = result;
19044   return jresult;
19045 }
19046
19047
19048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
19049   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19050   bool arg2 ;
19051
19052   arg1 = (Dali::RenderTask *)jarg1;
19053   arg2 = jarg2 ? true : false;
19054   {
19055     try {
19056       (arg1)->SetCullMode(arg2);
19057     } CALL_CATCH_EXCEPTION();
19058   }
19059
19060 }
19061
19062
19063 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
19064   bool jresult ;
19065   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19066   bool result;
19067
19068   arg1 = (Dali::RenderTask *)jarg1;
19069   {
19070     try {
19071       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
19072     } CALL_CATCH_EXCEPTION(0);
19073   }
19074
19075   jresult = result;
19076   return jresult;
19077 }
19078
19079
19080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
19081   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19082   unsigned int arg2 ;
19083
19084   arg1 = (Dali::RenderTask *)jarg1;
19085   arg2 = (unsigned int)jarg2;
19086   {
19087     try {
19088       (arg1)->SetRefreshRate(arg2);
19089     } CALL_CATCH_EXCEPTION();
19090   }
19091
19092 }
19093
19094
19095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
19096   unsigned int jresult ;
19097   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19098   unsigned int result;
19099
19100   arg1 = (Dali::RenderTask *)jarg1;
19101   {
19102     try {
19103       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
19104     } CALL_CATCH_EXCEPTION(0);
19105   }
19106
19107   jresult = result;
19108   return jresult;
19109 }
19110
19111
19112 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
19113   bool jresult ;
19114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19115   Dali::Vector3 *arg2 = 0 ;
19116   float *arg3 = 0 ;
19117   float *arg4 = 0 ;
19118   bool result;
19119
19120   arg1 = (Dali::RenderTask *)jarg1;
19121   arg2 = (Dali::Vector3 *)jarg2;
19122   if (!arg2) {
19123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19124     return 0;
19125   }
19126   arg3 = (float *)jarg3;
19127   arg4 = (float *)jarg4;
19128   {
19129     try {
19130       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
19131     } CALL_CATCH_EXCEPTION(0);
19132   }
19133
19134   jresult = result;
19135   return jresult;
19136 }
19137
19138
19139 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
19140   bool jresult ;
19141   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19142   Dali::Actor arg2 ;
19143   float arg3 ;
19144   float arg4 ;
19145   float *arg5 = 0 ;
19146   float *arg6 = 0 ;
19147   Dali::Actor *argp2 ;
19148   bool result;
19149
19150   arg1 = (Dali::RenderTask *)jarg1;
19151   argp2 = (Dali::Actor *)jarg2;
19152   if (!argp2) {
19153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19154     return 0;
19155   }
19156   arg2 = *argp2;
19157   arg3 = (float)jarg3;
19158   arg4 = (float)jarg4;
19159   arg5 = (float *)jarg5;
19160   arg6 = (float *)jarg6;
19161   {
19162     try {
19163       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
19164     } CALL_CATCH_EXCEPTION(0);
19165   }
19166
19167   jresult = result;
19168   return jresult;
19169 }
19170
19171
19172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
19173   void * jresult ;
19174   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
19175   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
19176
19177   arg1 = (Dali::RenderTask *)jarg1;
19178   {
19179     try {
19180       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
19181     } CALL_CATCH_EXCEPTION(0);
19182   }
19183
19184   jresult = (void *)result;
19185   return jresult;
19186 }
19187
19188
19189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
19190   void * jresult ;
19191   int arg1 ;
19192   Dali::PointState::Type arg2 ;
19193   float arg3 ;
19194   float arg4 ;
19195   Dali::TouchPoint *result = 0 ;
19196
19197   arg1 = (int)jarg1;
19198   arg2 = (Dali::PointState::Type)jarg2;
19199   arg3 = (float)jarg3;
19200   arg4 = (float)jarg4;
19201   {
19202     try {
19203       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
19204     } CALL_CATCH_EXCEPTION(0);
19205   }
19206
19207   jresult = (void *)result;
19208   return jresult;
19209 }
19210
19211
19212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
19213   void * jresult ;
19214   int arg1 ;
19215   Dali::PointState::Type arg2 ;
19216   float arg3 ;
19217   float arg4 ;
19218   float arg5 ;
19219   float arg6 ;
19220   Dali::TouchPoint *result = 0 ;
19221
19222   arg1 = (int)jarg1;
19223   arg2 = (Dali::PointState::Type)jarg2;
19224   arg3 = (float)jarg3;
19225   arg4 = (float)jarg4;
19226   arg5 = (float)jarg5;
19227   arg6 = (float)jarg6;
19228   {
19229     try {
19230       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
19231     } CALL_CATCH_EXCEPTION(0);
19232   }
19233
19234   jresult = (void *)result;
19235   return jresult;
19236 }
19237
19238
19239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
19240   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19241
19242   arg1 = (Dali::TouchPoint *)jarg1;
19243   {
19244     try {
19245       delete arg1;
19246     } CALL_CATCH_EXCEPTION();
19247   }
19248
19249 }
19250
19251
19252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
19253   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19254   int arg2 ;
19255
19256   arg1 = (Dali::TouchPoint *)jarg1;
19257   arg2 = (int)jarg2;
19258   if (arg1) (arg1)->deviceId = arg2;
19259 }
19260
19261
19262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
19263   int jresult ;
19264   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19265   int result;
19266
19267   arg1 = (Dali::TouchPoint *)jarg1;
19268   result = (int) ((arg1)->deviceId);
19269   jresult = result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
19275   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19276   Dali::PointState::Type arg2 ;
19277
19278   arg1 = (Dali::TouchPoint *)jarg1;
19279   arg2 = (Dali::PointState::Type)jarg2;
19280   if (arg1) (arg1)->state = arg2;
19281 }
19282
19283
19284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
19285   int jresult ;
19286   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19287   Dali::PointState::Type result;
19288
19289   arg1 = (Dali::TouchPoint *)jarg1;
19290   result = (Dali::PointState::Type) ((arg1)->state);
19291   jresult = (int)result;
19292   return jresult;
19293 }
19294
19295
19296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
19297   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19298   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
19299
19300   arg1 = (Dali::TouchPoint *)jarg1;
19301   arg2 = (Dali::Actor *)jarg2;
19302   if (arg1) (arg1)->hitActor = *arg2;
19303 }
19304
19305
19306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
19307   void * jresult ;
19308   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19309   Dali::Actor *result = 0 ;
19310
19311   arg1 = (Dali::TouchPoint *)jarg1;
19312   result = (Dali::Actor *)& ((arg1)->hitActor);
19313   jresult = (void *)result;
19314   return jresult;
19315 }
19316
19317
19318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
19319   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19320   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19321
19322   arg1 = (Dali::TouchPoint *)jarg1;
19323   arg2 = (Dali::Vector2 *)jarg2;
19324   if (arg1) (arg1)->local = *arg2;
19325 }
19326
19327
19328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
19329   void * jresult ;
19330   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19331   Dali::Vector2 *result = 0 ;
19332
19333   arg1 = (Dali::TouchPoint *)jarg1;
19334   result = (Dali::Vector2 *)& ((arg1)->local);
19335   jresult = (void *)result;
19336   return jresult;
19337 }
19338
19339
19340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
19341   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19342   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19343
19344   arg1 = (Dali::TouchPoint *)jarg1;
19345   arg2 = (Dali::Vector2 *)jarg2;
19346   if (arg1) (arg1)->screen = *arg2;
19347 }
19348
19349
19350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
19351   void * jresult ;
19352   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19353   Dali::Vector2 *result = 0 ;
19354
19355   arg1 = (Dali::TouchPoint *)jarg1;
19356   result = (Dali::Vector2 *)& ((arg1)->screen);
19357   jresult = (void *)result;
19358   return jresult;
19359 }
19360
19361
19362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
19363   void * jresult ;
19364   Dali::TouchEvent *result = 0 ;
19365
19366   {
19367     try {
19368       result = (Dali::TouchEvent *)new Dali::TouchEvent();
19369     } CALL_CATCH_EXCEPTION(0);
19370   }
19371
19372   jresult = (void *)result;
19373   return jresult;
19374 }
19375
19376
19377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
19378   void * jresult ;
19379   Dali::TouchEvent *arg1 = 0 ;
19380   Dali::TouchEvent *result = 0 ;
19381
19382   arg1 = (Dali::TouchEvent *)jarg1;
19383   if (!arg1) {
19384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19385     return 0;
19386   }
19387   {
19388     try {
19389       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
19390     } CALL_CATCH_EXCEPTION(0);
19391   }
19392
19393   jresult = (void *)result;
19394   return jresult;
19395 }
19396
19397
19398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
19399   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19400
19401   arg1 = (Dali::TouchEvent *)jarg1;
19402   {
19403     try {
19404       delete arg1;
19405     } CALL_CATCH_EXCEPTION();
19406   }
19407
19408 }
19409
19410
19411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
19412   void * jresult ;
19413   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19414   Dali::TouchEvent *arg2 = 0 ;
19415   Dali::TouchEvent *result = 0 ;
19416
19417   arg1 = (Dali::TouchEvent *)jarg1;
19418   arg2 = (Dali::TouchEvent *)jarg2;
19419   if (!arg2) {
19420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19421     return 0;
19422   }
19423   {
19424     try {
19425       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
19426     } CALL_CATCH_EXCEPTION(0);
19427   }
19428
19429   jresult = (void *)result;
19430   return jresult;
19431 }
19432
19433
19434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
19435   unsigned long jresult ;
19436   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19437   unsigned long result;
19438
19439   arg1 = (Dali::TouchEvent *)jarg1;
19440   {
19441     try {
19442       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
19443     } CALL_CATCH_EXCEPTION(0);
19444   }
19445
19446   jresult = (unsigned long)result;
19447   return jresult;
19448 }
19449
19450
19451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
19452   unsigned long jresult ;
19453   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19454   std::size_t result;
19455
19456   arg1 = (Dali::TouchEvent *)jarg1;
19457   {
19458     try {
19459       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
19460     } CALL_CATCH_EXCEPTION(0);
19461   }
19462
19463   jresult = (unsigned long)result;
19464   return jresult;
19465 }
19466
19467
19468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
19469   int jresult ;
19470   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19471   std::size_t arg2 ;
19472   int32_t result;
19473
19474   arg1 = (Dali::TouchEvent *)jarg1;
19475   arg2 = (std::size_t)jarg2;
19476   {
19477     try {
19478       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
19479     } CALL_CATCH_EXCEPTION(0);
19480   }
19481
19482   jresult = result;
19483   return jresult;
19484 }
19485
19486
19487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
19488   int jresult ;
19489   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19490   std::size_t arg2 ;
19491   Dali::PointState::Type result;
19492
19493   arg1 = (Dali::TouchEvent *)jarg1;
19494   arg2 = (std::size_t)jarg2;
19495   {
19496     try {
19497       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
19498     } CALL_CATCH_EXCEPTION(0);
19499   }
19500
19501   jresult = (int)result;
19502   return jresult;
19503 }
19504
19505
19506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
19507   void * jresult ;
19508   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19509   std::size_t arg2 ;
19510   Dali::Actor result;
19511
19512   arg1 = (Dali::TouchEvent *)jarg1;
19513   arg2 = (std::size_t)jarg2;
19514   {
19515     try {
19516       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
19517     } CALL_CATCH_EXCEPTION(0);
19518   }
19519
19520   jresult = new Dali::Actor((const Dali::Actor &)result);
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19526   void * jresult ;
19527   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19528   std::size_t arg2 ;
19529   Dali::Vector2 *result = 0 ;
19530
19531   arg1 = (Dali::TouchEvent *)jarg1;
19532   arg2 = (std::size_t)jarg2;
19533   {
19534     try {
19535       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
19536     } CALL_CATCH_EXCEPTION(0);
19537   }
19538
19539   jresult = (void *)result;
19540   return jresult;
19541 }
19542
19543
19544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19545   void * jresult ;
19546   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19547   std::size_t arg2 ;
19548   Dali::Vector2 *result = 0 ;
19549
19550   arg1 = (Dali::TouchEvent *)jarg1;
19551   arg2 = (std::size_t)jarg2;
19552   {
19553     try {
19554       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
19555     } CALL_CATCH_EXCEPTION(0);
19556   }
19557
19558   jresult = (void *)result;
19559   return jresult;
19560 }
19561
19562
19563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
19564   float jresult ;
19565   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19566   std::size_t arg2 ;
19567   float result;
19568
19569   arg1 = (Dali::TouchEvent *)jarg1;
19570   arg2 = (std::size_t)jarg2;
19571   {
19572     try {
19573       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
19574     } CALL_CATCH_EXCEPTION(0);
19575   }
19576
19577   jresult = result;
19578   return jresult;
19579 }
19580
19581
19582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
19583   void * jresult ;
19584   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19585   std::size_t arg2 ;
19586   Dali::Vector2 *result = 0 ;
19587
19588   arg1 = (Dali::TouchEvent *)jarg1;
19589   arg2 = (std::size_t)jarg2;
19590   {
19591     try {
19592       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
19593     } CALL_CATCH_EXCEPTION(0);
19594   }
19595
19596   jresult = (void *)result;
19597   return jresult;
19598 }
19599
19600
19601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
19602   float jresult ;
19603   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19604   std::size_t arg2 ;
19605   float result;
19606
19607   arg1 = (Dali::TouchEvent *)jarg1;
19608   arg2 = (std::size_t)jarg2;
19609   {
19610     try {
19611       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
19612     } CALL_CATCH_EXCEPTION(0);
19613   }
19614
19615   jresult = result;
19616   return jresult;
19617 }
19618
19619
19620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
19621   void * jresult ;
19622   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19623   std::size_t arg2 ;
19624   Dali::Degree result;
19625
19626   arg1 = (Dali::TouchEvent *)jarg1;
19627   arg2 = (std::size_t)jarg2;
19628   {
19629     try {
19630       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
19631     } CALL_CATCH_EXCEPTION(0);
19632   }
19633
19634   jresult = new Dali::Degree((const Dali::Degree &)result);
19635   return jresult;
19636 }
19637
19638
19639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
19640   int jresult ;
19641   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19642   std::size_t arg2 ;
19643   Dali::MouseButton::Type result;
19644
19645   arg1 = (Dali::TouchEvent *)jarg1;
19646   arg2 = (std::size_t)jarg2;
19647   {
19648     try {
19649       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
19650     } CALL_CATCH_EXCEPTION(0);
19651   }
19652
19653   jresult = static_cast< int >(result);
19654   return jresult;
19655 }
19656
19657
19658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
19659   void * jresult ;
19660   Dali::GestureDetector *result = 0 ;
19661
19662   {
19663     try {
19664       result = (Dali::GestureDetector *)new Dali::GestureDetector();
19665     } CALL_CATCH_EXCEPTION(0);
19666   }
19667
19668   jresult = (void *)result;
19669   return jresult;
19670 }
19671
19672
19673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
19674   void * jresult ;
19675   Dali::BaseHandle arg1 ;
19676   Dali::BaseHandle *argp1 ;
19677   Dali::GestureDetector result;
19678
19679   argp1 = (Dali::BaseHandle *)jarg1;
19680   if (!argp1) {
19681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19682     return 0;
19683   }
19684   arg1 = *argp1;
19685   {
19686     try {
19687       result = Dali::GestureDetector::DownCast(arg1);
19688     } CALL_CATCH_EXCEPTION(0);
19689   }
19690
19691   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
19692   return jresult;
19693 }
19694
19695
19696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
19697   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19698
19699   arg1 = (Dali::GestureDetector *)jarg1;
19700   {
19701     try {
19702       delete arg1;
19703     } CALL_CATCH_EXCEPTION();
19704   }
19705
19706 }
19707
19708
19709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
19710   void * jresult ;
19711   Dali::GestureDetector *arg1 = 0 ;
19712   Dali::GestureDetector *result = 0 ;
19713
19714   arg1 = (Dali::GestureDetector *)jarg1;
19715   if (!arg1) {
19716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19717     return 0;
19718   }
19719   {
19720     try {
19721       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
19722     } CALL_CATCH_EXCEPTION(0);
19723   }
19724
19725   jresult = (void *)result;
19726   return jresult;
19727 }
19728
19729
19730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
19731   void * jresult ;
19732   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19733   Dali::GestureDetector *arg2 = 0 ;
19734   Dali::GestureDetector *result = 0 ;
19735
19736   arg1 = (Dali::GestureDetector *)jarg1;
19737   arg2 = (Dali::GestureDetector *)jarg2;
19738   if (!arg2) {
19739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19740     return 0;
19741   }
19742   {
19743     try {
19744       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
19745     } CALL_CATCH_EXCEPTION(0);
19746   }
19747
19748   jresult = (void *)result;
19749   return jresult;
19750 }
19751
19752
19753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
19754   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19755   Dali::Actor arg2 ;
19756   Dali::Actor *argp2 ;
19757
19758   arg1 = (Dali::GestureDetector *)jarg1;
19759   argp2 = (Dali::Actor *)jarg2;
19760   if (!argp2) {
19761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19762     return ;
19763   }
19764   arg2 = *argp2;
19765   {
19766     try {
19767       (arg1)->Attach(arg2);
19768     } CALL_CATCH_EXCEPTION();
19769   }
19770
19771 }
19772
19773
19774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
19775   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19776   Dali::Actor arg2 ;
19777   Dali::Actor *argp2 ;
19778
19779   arg1 = (Dali::GestureDetector *)jarg1;
19780   argp2 = (Dali::Actor *)jarg2;
19781   if (!argp2) {
19782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19783     return ;
19784   }
19785   arg2 = *argp2;
19786   {
19787     try {
19788       (arg1)->Detach(arg2);
19789     } CALL_CATCH_EXCEPTION();
19790   }
19791
19792 }
19793
19794
19795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
19796   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19797
19798   arg1 = (Dali::GestureDetector *)jarg1;
19799   {
19800     try {
19801       (arg1)->DetachAll();
19802     } CALL_CATCH_EXCEPTION();
19803   }
19804
19805 }
19806
19807
19808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
19809   unsigned long jresult ;
19810   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19811   size_t result;
19812
19813   arg1 = (Dali::GestureDetector *)jarg1;
19814   {
19815     try {
19816       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
19817     } CALL_CATCH_EXCEPTION(0);
19818   }
19819
19820   jresult = (unsigned long)result;
19821   return jresult;
19822 }
19823
19824
19825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
19826   void * jresult ;
19827   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19828   size_t arg2 ;
19829   Dali::Actor result;
19830
19831   arg1 = (Dali::GestureDetector *)jarg1;
19832   arg2 = (size_t)jarg2;
19833   {
19834     try {
19835       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
19836     } CALL_CATCH_EXCEPTION(0);
19837   }
19838
19839   jresult = new Dali::Actor((const Dali::Actor &)result);
19840   return jresult;
19841 }
19842
19843
19844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
19845   void * jresult ;
19846   Dali::Gesture *arg1 = 0 ;
19847   Dali::Gesture *result = 0 ;
19848
19849   arg1 = (Dali::Gesture *)jarg1;
19850   if (!arg1) {
19851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19852     return 0;
19853   }
19854   {
19855     try {
19856       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19857     } CALL_CATCH_EXCEPTION(0);
19858   }
19859
19860   jresult = (void *)result;
19861   return jresult;
19862 }
19863
19864
19865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19866   void * jresult ;
19867   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19868   Dali::Gesture *arg2 = 0 ;
19869   Dali::Gesture *result = 0 ;
19870
19871   arg1 = (Dali::Gesture *)jarg1;
19872   arg2 = (Dali::Gesture *)jarg2;
19873   if (!arg2) {
19874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19875     return 0;
19876   }
19877   {
19878     try {
19879       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19880     } CALL_CATCH_EXCEPTION(0);
19881   }
19882
19883   jresult = (void *)result;
19884   return jresult;
19885 }
19886
19887
19888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19889   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19890
19891   arg1 = (Dali::Gesture *)jarg1;
19892   {
19893     try {
19894       delete arg1;
19895     } CALL_CATCH_EXCEPTION();
19896   }
19897
19898 }
19899
19900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19901   int jresult ;
19902   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19903   Dali::GestureType::Value result;
19904
19905   arg1 = (Dali::Gesture *)jarg1;
19906   result = (Dali::GestureType::Value) ((arg1)->GetType());
19907   jresult = (int)result;
19908   return jresult;
19909 }
19910
19911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19912   int jresult ;
19913   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19914   Dali::GestureState result;
19915
19916   arg1 = (Dali::Gesture *)jarg1;
19917   result = (Dali::GestureState) ((arg1)->GetState());
19918   jresult = (int)result;
19919   return jresult;
19920 }
19921
19922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19923   unsigned int jresult ;
19924   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19925   unsigned int result;
19926
19927   arg1 = (Dali::Gesture *)jarg1;
19928   result = (unsigned int) ((arg1)->GetTime());
19929   jresult = result;
19930   return jresult;
19931 }
19932
19933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
19934   int jresult ;
19935   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
19936   Dali::GestureSourceType result;
19937
19938   if (!jGesture) {
19939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19940     return 0;
19941   }
19942   {
19943     try {
19944       result = (Dali::GestureSourceType)jGesture->GetSourceType();
19945     } CALL_CATCH_EXCEPTION(0);
19946   }
19947
19948   jresult = (int)result;
19949   return jresult;
19950 }
19951
19952
19953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
19954   int jresult ;
19955   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
19956   Dali::GestureSourceData result;
19957
19958   if (!jGesture) {
19959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
19960     return 0;
19961   }
19962   {
19963     try {
19964       result = (Dali::GestureSourceData)jGesture->GetSourceData();
19965     } CALL_CATCH_EXCEPTION(0);
19966   }
19967
19968   jresult = (int)result;
19969   return jresult;
19970 }
19971
19972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19973   void * jresult ;
19974   Dali::HoverEvent *result = 0 ;
19975
19976   {
19977     try {
19978       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19979     } CALL_CATCH_EXCEPTION(0);
19980   }
19981
19982   jresult = (void *)result;
19983   return jresult;
19984 }
19985
19986
19987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19988   void * jresult ;
19989   Dali::HoverEvent *arg1 = 0 ;
19990   Dali::HoverEvent *result = 0 ;
19991
19992   arg1 = (Dali::HoverEvent *)jarg1;
19993   if (!arg1) {
19994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19995     return 0;
19996   }
19997   {
19998     try {
19999       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
20000     } CALL_CATCH_EXCEPTION(0);
20001   }
20002
20003   jresult = (void *)result;
20004   return jresult;
20005 }
20006
20007
20008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
20009   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20010
20011   arg1 = (Dali::HoverEvent *)jarg1;
20012   {
20013     try {
20014       delete arg1;
20015     } CALL_CATCH_EXCEPTION();
20016   }
20017
20018 }
20019
20020
20021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
20022   void * jresult ;
20023   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20024   Dali::HoverEvent *arg2 = 0 ;
20025   Dali::HoverEvent *result = 0 ;
20026
20027   arg1 = (Dali::HoverEvent *)jarg1;
20028   arg2 = (Dali::HoverEvent *)jarg2;
20029   if (!arg2) {
20030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
20031     return 0;
20032   }
20033   {
20034     try {
20035       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
20036     } catch (std::out_of_range& e) {
20037       {
20038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20039       };
20040     } catch (std::exception& e) {
20041       {
20042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (Dali::DaliException e) {
20045       {
20046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20047       };
20048     } catch (...) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20051       };
20052     }
20053   }
20054
20055   jresult = (void *)result;
20056   return jresult;
20057 }
20058
20059
20060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
20061   void * jresult ;
20062   unsigned int arg1 ;
20063   Dali::HoverEvent result;
20064
20065   arg1 = (unsigned int)jarg1;
20066   {
20067     try {
20068       result = DevelHoverEvent::New(arg1);
20069     } CALL_CATCH_EXCEPTION(0);
20070   }
20071
20072   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
20073   return jresult;
20074 }
20075
20076
20077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
20078   unsigned long jresult ;
20079   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20080   unsigned long result;
20081
20082   arg1 = (Dali::HoverEvent *)jarg1;
20083   {
20084     try {
20085       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
20086     } catch (std::out_of_range& e) {
20087       {
20088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20089       };
20090     } catch (std::exception& e) {
20091       {
20092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20093       };
20094     } catch (Dali::DaliException e) {
20095       {
20096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20097       };
20098     } catch (...) {
20099       {
20100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20101       };
20102     }
20103   }
20104
20105   jresult = (unsigned long)result;
20106   return jresult;
20107 }
20108
20109
20110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
20111   unsigned long jresult ;
20112   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20113   std::size_t result;
20114
20115   arg1 = (Dali::HoverEvent *)jarg1;
20116   {
20117     try {
20118       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
20119     } catch (std::out_of_range& e) {
20120       {
20121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20122       };
20123     } catch (std::exception& e) {
20124       {
20125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20126       };
20127     } catch (Dali::DaliException e) {
20128       {
20129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20130       };
20131     } catch (...) {
20132       {
20133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20134       };
20135     }
20136   }
20137
20138   jresult = (unsigned long)result;
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
20144   int jresult ;
20145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20146   std::size_t arg2 ;
20147   int32_t result;
20148
20149   arg1 = (Dali::HoverEvent *)jarg1;
20150   arg2 = (std::size_t)jarg2;
20151   {
20152     try {
20153       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
20154     } catch (std::out_of_range& e) {
20155       {
20156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20157       };
20158     } catch (std::exception& e) {
20159       {
20160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20161       };
20162     } catch (Dali::DaliException e) {
20163       {
20164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20165       };
20166     } catch (...) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20169       };
20170     }
20171   }
20172
20173   jresult = result;
20174   return jresult;
20175 }
20176
20177
20178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
20179   int jresult ;
20180   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20181   std::size_t arg2 ;
20182   Dali::PointState::Type result;
20183
20184   arg1 = (Dali::HoverEvent *)jarg1;
20185   arg2 = (std::size_t)jarg2;
20186   {
20187     try {
20188       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
20189     } CALL_CATCH_EXCEPTION(0);
20190   }
20191
20192   jresult = (int)result;
20193   return jresult;
20194 }
20195
20196
20197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
20198   void * jresult ;
20199   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20200   std::size_t arg2 ;
20201   Dali::Actor result;
20202
20203   arg1 = (Dali::HoverEvent *)jarg1;
20204   arg2 = (std::size_t)jarg2;
20205   {
20206     try {
20207       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
20208     } catch (std::out_of_range& e) {
20209       {
20210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (std::exception& e) {
20213       {
20214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20215       };
20216     } catch (Dali::DaliException e) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20219       };
20220     } catch (...) {
20221       {
20222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20223       };
20224     }
20225   }
20226
20227   jresult = new Dali::Actor((const Dali::Actor &)result);
20228   return jresult;
20229 }
20230
20231
20232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
20233   void * jresult ;
20234   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20235   std::size_t arg2 ;
20236   Dali::Vector2 *result = 0 ;
20237
20238   arg1 = (Dali::HoverEvent *)jarg1;
20239   arg2 = (std::size_t)jarg2;
20240   {
20241     try {
20242       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
20243     } catch (std::out_of_range& e) {
20244       {
20245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20246       };
20247     } catch (std::exception& e) {
20248       {
20249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20250       };
20251     } catch (Dali::DaliException e) {
20252       {
20253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20254       };
20255     } catch (...) {
20256       {
20257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20258       };
20259     }
20260   }
20261
20262   jresult = (void *)result;
20263   return jresult;
20264 }
20265
20266
20267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
20268   void * jresult ;
20269   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
20270   std::size_t arg2 ;
20271   Dali::Vector2 *result = 0 ;
20272
20273   arg1 = (Dali::HoverEvent *)jarg1;
20274   arg2 = (std::size_t)jarg2;
20275   {
20276     try {
20277       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
20278     } CALL_CATCH_EXCEPTION(0);
20279   }
20280
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
20287   void * jresult ;
20288   Dali::KeyEvent *result = 0 ;
20289
20290   {
20291     try {
20292       result = (Dali::KeyEvent *)new Dali::KeyEvent();
20293     } CALL_CATCH_EXCEPTION(0);
20294   }
20295
20296   jresult = (void *)result;
20297   return jresult;
20298 }
20299
20300
20301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
20302   void * jresult ;
20303   Dali::KeyEvent *arg1 = 0 ;
20304   Dali::KeyEvent *result = 0 ;
20305
20306   arg1 = (Dali::KeyEvent *)jarg1;
20307   if (!arg1) {
20308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20309     return 0;
20310   }
20311   {
20312     try {
20313       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
20314     } CALL_CATCH_EXCEPTION(0);
20315   }
20316
20317   jresult = (void *)result;
20318   return jresult;
20319 }
20320
20321
20322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
20323   void * jresult ;
20324   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20325   Dali::KeyEvent *arg2 = 0 ;
20326   Dali::KeyEvent *result = 0 ;
20327
20328   arg1 = (Dali::KeyEvent *)jarg1;
20329   arg2 = (Dali::KeyEvent *)jarg2;
20330   if (!arg2) {
20331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20332     return 0;
20333   }
20334   {
20335     try {
20336       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
20337     } CALL_CATCH_EXCEPTION(0);
20338   }
20339
20340   jresult = (void *)result;
20341   return jresult;
20342 }
20343
20344
20345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
20346   void * jresult ;
20347   std::string *arg1 = 0 ;
20348   std::string *arg2 = 0 ;
20349   int arg3 ;
20350   int arg4 ;
20351   unsigned long arg5 ;
20352   Dali::KeyEvent::State *arg6 = 0 ;
20353   Dali::KeyEvent::State temp6 ;
20354   Dali::KeyEvent result;
20355
20356   if (!jarg1) {
20357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20358     return 0;
20359   }
20360   std::string arg1_str(jarg1);
20361   arg1 = &arg1_str;
20362   if (!jarg2) {
20363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20364     return 0;
20365   }
20366   std::string arg2_str(jarg2);
20367   arg2 = &arg2_str;
20368   arg3 = (int)jarg3;
20369   arg4 = (int)jarg4;
20370   arg5 = (unsigned long)jarg5;
20371   temp6 = (Dali::KeyEvent::State)jarg6;
20372   arg6 = &temp6;
20373   {
20374     try {
20375       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);
20376     } CALL_CATCH_EXCEPTION(0);
20377   }
20378
20379   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
20380
20381   //argout typemap for const std::string&
20382
20383
20384   //argout typemap for const std::string&
20385
20386   return jresult;
20387 }
20388
20389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
20390   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20391
20392   arg1 = (Dali::KeyEvent *)jarg1;
20393   {
20394     try {
20395       delete arg1;
20396     } CALL_CATCH_EXCEPTION();
20397   }
20398
20399 }
20400
20401
20402 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
20403   bool jresult ;
20404   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20405   bool result;
20406
20407   arg1 = (Dali::KeyEvent *)jarg1;
20408   {
20409     try {
20410       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
20411     } CALL_CATCH_EXCEPTION(0);
20412   }
20413
20414   jresult = result;
20415   return jresult;
20416 }
20417
20418
20419 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
20420   bool jresult ;
20421   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20422   bool result;
20423
20424   arg1 = (Dali::KeyEvent *)jarg1;
20425   {
20426     try {
20427       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
20428     } CALL_CATCH_EXCEPTION(0);
20429   }
20430
20431   jresult = result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
20437   bool jresult ;
20438   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20439   bool result;
20440
20441   arg1 = (Dali::KeyEvent *)jarg1;
20442   {
20443     try {
20444       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
20445     } CALL_CATCH_EXCEPTION(0);
20446   }
20447
20448   jresult = result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
20454   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20455   std::string *arg2 = 0 ;
20456
20457   argp1 = (Dali::KeyEvent *) jarg1;
20458   if (!argp1) {
20459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20460     return ;
20461   }
20462
20463   Dali::KeyEvent arg1 = *argp1;
20464   if (!jarg2) {
20465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20466     return ;
20467   }
20468   std::string arg2_str(jarg2);
20469   arg2 = &arg2_str;
20470
20471   {
20472     try {
20473       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
20474     } catch (std::out_of_range& e) {
20475       {
20476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20477       };
20478     } catch (std::exception& e) {
20479       {
20480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20481       };
20482     } catch (Dali::DaliException e) {
20483       {
20484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20485       };
20486     } catch (...) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20489       };
20490     }
20491   }
20492 }
20493
20494
20495 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
20496   char * jresult ;
20497
20498   if( jarg1 == NULL )
20499   {
20500     jresult = SWIG_csharp_string_callback( "" );
20501   }
20502   else
20503   {
20504     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20505     std::string *result = 0;
20506     std::string str = "";
20507
20508     arg1 = ( Dali::KeyEvent * )jarg1;
20509     {
20510       try {
20511         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
20512         result = (std::string *) &str;
20513         jresult = SWIG_csharp_string_callback(result->c_str());
20514       } catch (std::out_of_range& e) {
20515         {
20516           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20517         };
20518       } catch (std::exception& e) {
20519         {
20520           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20521         };
20522       } catch (Dali::DaliException e) {
20523         {
20524           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20525         };
20526       } catch (...) {
20527         {
20528           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20529         };
20530       }
20531     }
20532
20533   }
20534
20535   return jresult;
20536 }
20537
20538
20539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
20540   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20541   std::string *arg2 = 0 ;
20542
20543   argp1 = (Dali::KeyEvent *) jarg1;
20544   if (!argp1) {
20545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20546     return ;
20547   }
20548
20549   Dali::KeyEvent arg1 = *argp1;
20550   if (!jarg2) {
20551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20552     return ;
20553   }
20554   std::string arg2_str(jarg2);
20555   arg2 = &arg2_str;
20556
20557   {
20558     try {
20559       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
20560     } catch (std::out_of_range& e) {
20561       {
20562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20563       };
20564     } catch (std::exception& e) {
20565       {
20566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20567       };
20568     } catch (Dali::DaliException e) {
20569       {
20570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20571       };
20572     } catch (...) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20575       };
20576     }
20577   }
20578 }
20579
20580
20581 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
20582   char * jresult ;
20583
20584   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20585   std::string *result = 0;
20586   std::string str = "";
20587   arg1 = ( Dali::KeyEvent * )jarg1;
20588   {
20589     try {
20590       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
20591       result = (std::string *) &str;
20592       jresult = SWIG_csharp_string_callback(result->c_str());
20593     } catch (std::out_of_range& e) {
20594       {
20595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (std::exception& e) {
20598       {
20599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20600       };
20601     } catch (Dali::DaliException e) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20604       };
20605     } catch (...) {
20606       {
20607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20608       };
20609     }
20610   }
20611
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
20617   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20618   int arg2 ;
20619
20620   argp1 = (Dali::KeyEvent *) jarg1;
20621   if (!argp1) {
20622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20623     return ;
20624   }
20625
20626   Dali::KeyEvent arg1 = *argp1;
20627   arg2 = (int)jarg2;
20628   {
20629     try {
20630       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
20631     } catch (std::out_of_range& e) {
20632       {
20633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20634       };
20635     } catch (std::exception& e) {
20636       {
20637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20638       };
20639     } catch (Dali::DaliException e) {
20640       {
20641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20642       };
20643     } catch (...) {
20644       {
20645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20646       };
20647     }
20648   }
20649 }
20650
20651
20652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
20653   int jresult ;
20654   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20655   int result;
20656
20657   arg1 = (Dali::KeyEvent *)jarg1;
20658   {
20659     try {
20660       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
20686   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20687   int arg2 ;
20688
20689   argp1 = (Dali::KeyEvent *) jarg1;
20690   if (!argp1) {
20691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20692     return ;
20693   }
20694
20695   Dali::KeyEvent arg1 = *argp1;
20696   arg2 = (int)jarg2;
20697   {
20698     try {
20699       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
20700     } catch (std::out_of_range& e) {
20701       {
20702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20703       };
20704     } catch (std::exception& e) {
20705       {
20706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20707       };
20708     } catch (Dali::DaliException e) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20711       };
20712     } catch (...) {
20713       {
20714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20715       };
20716     }
20717   }
20718 }
20719
20720
20721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
20722   int jresult ;
20723   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20724   int result;
20725
20726   arg1 = (Dali::KeyEvent *)jarg1;
20727   {
20728     try {
20729       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20745       };
20746     }
20747   }
20748
20749   jresult = result;
20750   return jresult;
20751 }
20752
20753
20754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
20755   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20756   unsigned long arg2 ;
20757
20758   argp1 = (Dali::KeyEvent *) jarg1;
20759   if (!argp1) {
20760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20761     return ;
20762   }
20763
20764   Dali::KeyEvent arg1 = *argp1;
20765   arg2 = (int)jarg2;
20766   {
20767     try {
20768       Dali::DevelKeyEvent::SetTime(arg1, arg2);
20769     } catch (std::out_of_range& e) {
20770       {
20771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20772       };
20773     } catch (std::exception& e) {
20774       {
20775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20776       };
20777     } catch (Dali::DaliException e) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20780       };
20781     } catch (...) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20784       };
20785     }
20786   }
20787 }
20788
20789
20790 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
20791   unsigned long jresult ;
20792   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20793   unsigned long result;
20794
20795   arg1 = (Dali::KeyEvent *)jarg1;
20796   {
20797     try {
20798       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (Dali::DaliException e) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20810       };
20811     } catch (...) {
20812       {
20813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20814       };
20815     }
20816   }
20817
20818   jresult = result;
20819   return jresult;
20820 }
20821
20822
20823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
20824   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
20825   Dali::KeyEvent::State arg2;
20826
20827   argp1 = (Dali::KeyEvent *) jarg1;
20828   if (!argp1) {
20829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20830     return ;
20831   }
20832
20833   Dali::KeyEvent arg1 = *argp1;
20834   arg2 = (Dali::KeyEvent::State)jarg2;
20835   {
20836     try {
20837       Dali::DevelKeyEvent::SetState(arg1, arg2);
20838     } catch (std::out_of_range& e) {
20839       {
20840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20841       };
20842     } catch (std::exception& e) {
20843       {
20844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20845       };
20846     } catch (Dali::DaliException e) {
20847       {
20848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20849       };
20850     } catch (...) {
20851       {
20852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20853       };
20854     }
20855   }
20856 }
20857
20858
20859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
20860   int jresult ;
20861   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20862   Dali::KeyEvent::State result;
20863
20864   arg1 = (Dali::KeyEvent *)jarg1;
20865   {
20866     try {
20867       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (Dali::DaliException e) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886
20887   jresult = (int)result;
20888   return jresult;
20889
20890 }
20891
20892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
20893   char * jresult ;
20894
20895   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20896   std::string *result = 0;
20897   std::string str = "";
20898
20899   arg1 = ( Dali::KeyEvent * )jarg1;
20900   {
20901     try {
20902       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
20903       result = (std::string *) &str;
20904       jresult = SWIG_csharp_string_callback(result->c_str());
20905     } CALL_CATCH_EXCEPTION(0);
20906   }
20907
20908   return jresult;
20909 }
20910
20911
20912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
20913   void * jresult ;
20914   Dali::LongPressGestureDetector *result = 0 ;
20915
20916   {
20917     try {
20918       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
20919     } CALL_CATCH_EXCEPTION(0);
20920   }
20921
20922   jresult = (void *)result;
20923   return jresult;
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20928   void * jresult ;
20929   Dali::LongPressGestureDetector result;
20930
20931   {
20932     try {
20933       result = Dali::LongPressGestureDetector::New();
20934     } CALL_CATCH_EXCEPTION(0);
20935   }
20936
20937   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20938   return jresult;
20939 }
20940
20941
20942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20943   void * jresult ;
20944   unsigned int arg1 ;
20945   Dali::LongPressGestureDetector result;
20946
20947   arg1 = (unsigned int)jarg1;
20948   {
20949     try {
20950       result = Dali::LongPressGestureDetector::New(arg1);
20951     } CALL_CATCH_EXCEPTION(0);
20952   }
20953
20954   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20955   return jresult;
20956 }
20957
20958
20959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20960   void * jresult ;
20961   unsigned int arg1 ;
20962   unsigned int arg2 ;
20963   Dali::LongPressGestureDetector result;
20964
20965   arg1 = (unsigned int)jarg1;
20966   arg2 = (unsigned int)jarg2;
20967   {
20968     try {
20969       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20970     } CALL_CATCH_EXCEPTION(0);
20971   }
20972
20973   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20974   return jresult;
20975 }
20976
20977
20978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20979   void * jresult ;
20980   Dali::BaseHandle arg1 ;
20981   Dali::BaseHandle *argp1 ;
20982   Dali::LongPressGestureDetector result;
20983
20984   argp1 = (Dali::BaseHandle *)jarg1;
20985   if (!argp1) {
20986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20987     return 0;
20988   }
20989   arg1 = *argp1;
20990   {
20991     try {
20992       result = Dali::LongPressGestureDetector::DownCast(arg1);
20993     } CALL_CATCH_EXCEPTION(0);
20994   }
20995
20996   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20997   return jresult;
20998 }
20999
21000
21001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
21002   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21003
21004   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21005   {
21006     try {
21007       delete arg1;
21008     } CALL_CATCH_EXCEPTION();
21009   }
21010
21011 }
21012
21013
21014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
21015   void * jresult ;
21016   Dali::LongPressGestureDetector *arg1 = 0 ;
21017   Dali::LongPressGestureDetector *result = 0 ;
21018
21019   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21020   if (!arg1) {
21021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21022     return 0;
21023   }
21024   {
21025     try {
21026       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
21027     } CALL_CATCH_EXCEPTION(0);
21028   }
21029
21030   jresult = (void *)result;
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
21036   void * jresult ;
21037   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21038   Dali::LongPressGestureDetector *arg2 = 0 ;
21039   Dali::LongPressGestureDetector *result = 0 ;
21040
21041   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21042   arg2 = (Dali::LongPressGestureDetector *)jarg2;
21043   if (!arg2) {
21044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
21045     return 0;
21046   }
21047   {
21048     try {
21049       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
21050     } CALL_CATCH_EXCEPTION(0);
21051   }
21052
21053   jresult = (void *)result;
21054   return jresult;
21055 }
21056
21057
21058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
21059   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21060   unsigned int arg2 ;
21061
21062   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21063   arg2 = (unsigned int)jarg2;
21064   {
21065     try {
21066       (arg1)->SetTouchesRequired(arg2);
21067     } CALL_CATCH_EXCEPTION();
21068   }
21069
21070 }
21071
21072
21073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
21074   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21075   unsigned int arg2 ;
21076   unsigned int arg3 ;
21077
21078   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21079   arg2 = (unsigned int)jarg2;
21080   arg3 = (unsigned int)jarg3;
21081   {
21082     try {
21083       (arg1)->SetTouchesRequired(arg2,arg3);
21084     } CALL_CATCH_EXCEPTION();
21085   }
21086
21087 }
21088
21089
21090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
21091   unsigned int jresult ;
21092   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21093   unsigned int result;
21094
21095   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21096   {
21097     try {
21098       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
21099     } CALL_CATCH_EXCEPTION(0);
21100   }
21101
21102   jresult = result;
21103   return jresult;
21104 }
21105
21106
21107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
21108   unsigned int jresult ;
21109   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21110   unsigned int result;
21111
21112   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21113   {
21114     try {
21115       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
21116     } CALL_CATCH_EXCEPTION(0);
21117   }
21118
21119   jresult = result;
21120   return jresult;
21121 }
21122
21123
21124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
21125   void * jresult ;
21126   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
21127   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
21128
21129   arg1 = (Dali::LongPressGestureDetector *)jarg1;
21130   {
21131     try {
21132       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
21133     } CALL_CATCH_EXCEPTION(0);
21134   }
21135
21136   jresult = (void *)result;
21137   return jresult;
21138 }
21139
21140
21141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
21142   void * jresult ;
21143   Dali::LongPressGesture *result = 0 ;
21144
21145   {
21146     try {
21147       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
21148     } CALL_CATCH_EXCEPTION(0);
21149   }
21150
21151   jresult = (void *)result;
21152   return jresult;
21153 }
21154
21155
21156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
21157   void * jresult ;
21158   Dali::GestureState arg1 ;
21159   Dali::LongPressGesture result;
21160
21161   arg1 = (Dali::GestureState)jarg1;
21162   {
21163     try {
21164       result = DevelLongPressGesture::New(arg1);
21165     } CALL_CATCH_EXCEPTION(0);
21166   }
21167
21168   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
21169   return jresult;
21170 }
21171
21172
21173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
21174   void * jresult ;
21175   Dali::LongPressGesture *arg1 = 0 ;
21176   Dali::LongPressGesture *result = 0 ;
21177
21178   arg1 = (Dali::LongPressGesture *)jarg1;
21179   if (!arg1) {
21180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21181     return 0;
21182   }
21183   {
21184     try {
21185       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
21186     } CALL_CATCH_EXCEPTION(0);
21187   }
21188
21189   jresult = (void *)result;
21190   return jresult;
21191 }
21192
21193
21194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
21195   void * jresult ;
21196   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21197   Dali::LongPressGesture *arg2 = 0 ;
21198   Dali::LongPressGesture *result = 0 ;
21199
21200   arg1 = (Dali::LongPressGesture *)jarg1;
21201   arg2 = (Dali::LongPressGesture *)jarg2;
21202   if (!arg2) {
21203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
21204     return 0;
21205   }
21206   {
21207     try {
21208       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
21209     } CALL_CATCH_EXCEPTION(0);
21210   }
21211
21212   jresult = (void *)result;
21213   return jresult;
21214 }
21215
21216
21217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
21218   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21219
21220   arg1 = (Dali::LongPressGesture *)jarg1;
21221   {
21222     try {
21223       delete arg1;
21224     } CALL_CATCH_EXCEPTION();
21225   }
21226
21227 }
21228
21229
21230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
21231   unsigned int jresult ;
21232   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21233   unsigned int result;
21234
21235   arg1 = (Dali::LongPressGesture *)jarg1;
21236   result = (unsigned int) ((arg1)->GetNumberOfTouches());
21237   jresult = result;
21238   return jresult;
21239 }
21240
21241
21242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
21243   void * jresult ;
21244   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21245   Dali::Vector2 result;
21246
21247   arg1 = (Dali::LongPressGesture *)jarg1;
21248   {
21249     try {
21250       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (Dali::DaliException e) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21270   return jresult;
21271 }
21272
21273
21274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
21275   void * jresult ;
21276   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21277   Dali::Vector2 result;
21278
21279   arg1 = (Dali::LongPressGesture *)jarg1;
21280   {
21281     try {
21282       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
21283     } catch (std::out_of_range& e) {
21284       {
21285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21286       };
21287     } catch (std::exception& e) {
21288       {
21289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (Dali::DaliException e) {
21292       {
21293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21294       };
21295     } catch (...) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21298       };
21299     }
21300   }
21301   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
21307   void * jresult ;
21308   Dali::WheelEvent *result = 0 ;
21309
21310   {
21311     try {
21312       result = (Dali::WheelEvent *)new Dali::WheelEvent();
21313     } CALL_CATCH_EXCEPTION(0);
21314   }
21315
21316   jresult = (void *)result;
21317   return jresult;
21318 }
21319
21320
21321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
21322   void * jresult ;
21323   Dali::WheelEvent *arg1 = 0 ;
21324   Dali::WheelEvent *result = 0 ;
21325
21326   arg1 = (Dali::WheelEvent *)jarg1;
21327   if (!arg1) {
21328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21329     return 0;
21330   }
21331   {
21332     try {
21333       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
21334     } catch (std::out_of_range& e) {
21335       {
21336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21337       };
21338     } catch (std::exception& e) {
21339       {
21340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21341       };
21342     } catch (Dali::DaliException e) {
21343       {
21344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21345       };
21346     } catch (...) {
21347       {
21348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21349       };
21350     }
21351   }
21352
21353   jresult = (void *)result;
21354   return jresult;
21355 }
21356
21357
21358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
21359   void * jresult ;
21360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21361   Dali::WheelEvent *arg2 = 0 ;
21362   Dali::WheelEvent *result = 0 ;
21363
21364   arg1 = (Dali::WheelEvent *)jarg1;
21365   arg2 = (Dali::WheelEvent *)jarg2;
21366   if (!arg2) {
21367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21368     return 0;
21369   }
21370   {
21371     try {
21372       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
21373     } catch (std::out_of_range& e) {
21374       {
21375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21376       };
21377     } catch (std::exception& e) {
21378       {
21379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21380       };
21381     } catch (Dali::DaliException e) {
21382       {
21383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21384       };
21385     } catch (...) {
21386       {
21387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21388       };
21389     }
21390   }
21391
21392   jresult = (void *)result;
21393   return jresult;
21394 }
21395
21396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
21397   void * jresult ;
21398   Dali::WheelEvent::Type arg1 ;
21399   int arg2 ;
21400   unsigned int arg3 ;
21401   Dali::Vector2 arg4 ;
21402   int arg5 ;
21403   unsigned int arg6 ;
21404   Dali::Vector2 *argp4 ;
21405   Dali::WheelEvent result;
21406
21407   arg1 = (Dali::WheelEvent::Type)jarg1;
21408   arg2 = (int)jarg2;
21409   arg3 = (unsigned int)jarg3;
21410   argp4 = (Dali::Vector2 *)jarg4;
21411   if (!argp4) {
21412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
21413     return 0;
21414   }
21415   arg4 = *argp4;
21416   arg5 = (int)jarg5;
21417   arg6 = (unsigned int)jarg6;
21418   {
21419     try {
21420       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
21421     } CALL_CATCH_EXCEPTION(0);
21422   }
21423
21424   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
21425   return jresult;
21426 }
21427
21428
21429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
21430   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21431
21432   arg1 = (Dali::WheelEvent *)jarg1;
21433   {
21434     try {
21435       delete arg1;
21436     } CALL_CATCH_EXCEPTION();
21437   }
21438
21439 }
21440
21441
21442 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
21443   bool jresult ;
21444   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21445   bool result;
21446
21447   arg1 = (Dali::WheelEvent *)jarg1;
21448   {
21449     try {
21450       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
21451     } CALL_CATCH_EXCEPTION(0);
21452   }
21453
21454   jresult = result;
21455   return jresult;
21456 }
21457
21458
21459 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
21460   bool jresult ;
21461   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21462   bool result;
21463
21464   arg1 = (Dali::WheelEvent *)jarg1;
21465   {
21466     try {
21467       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
21468     } catch (std::out_of_range& e) {
21469       {
21470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21471       };
21472     } catch (std::exception& e) {
21473       {
21474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21475       };
21476     } catch (Dali::DaliException e) {
21477       {
21478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21479       };
21480     } catch (...) {
21481       {
21482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21483       };
21484     }
21485   }
21486
21487   jresult = result;
21488   return jresult;
21489 }
21490
21491
21492 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
21493   bool jresult ;
21494   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21495   bool result;
21496
21497   arg1 = (Dali::WheelEvent *)jarg1;
21498   {
21499     try {
21500       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
21501     } catch (std::out_of_range& e) {
21502       {
21503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21504       };
21505     } catch (std::exception& e) {
21506       {
21507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21508       };
21509     } catch (Dali::DaliException e) {
21510       {
21511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21512       };
21513     } catch (...) {
21514       {
21515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21516       };
21517     }
21518   }
21519
21520   jresult = result;
21521   return jresult;
21522 }
21523
21524
21525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
21526   int jresult ;
21527   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21528   Dali::WheelEvent::Type result;
21529
21530   arg1 = (Dali::WheelEvent *)jarg1;
21531   {
21532     try {
21533       result = ((Dali::WheelEvent const *)arg1)->GetType();
21534     } catch (std::out_of_range& e) {
21535       {
21536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21537       };
21538     } catch (std::exception& e) {
21539       {
21540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21541       };
21542     } catch (Dali::DaliException e) {
21543       {
21544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21545       };
21546     } catch (...) {
21547       {
21548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21549       };
21550     }
21551   }
21552
21553   jresult = (int)result;
21554   return jresult;
21555 }
21556
21557
21558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
21559   int jresult ;
21560   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21561   int result;
21562
21563   arg1 = (Dali::WheelEvent *)jarg1;
21564   {
21565     try {
21566       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
21567     } catch (std::out_of_range& e) {
21568       {
21569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21570       };
21571     } catch (std::exception& e) {
21572       {
21573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (Dali::DaliException e) {
21576       {
21577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21578       };
21579     } catch (...) {
21580       {
21581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21582       };
21583     }
21584   }
21585
21586   jresult = result;
21587   return jresult;
21588 }
21589
21590
21591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
21592   unsigned int jresult ;
21593   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21594   unsigned int result;
21595
21596   arg1 = (Dali::WheelEvent *)jarg1;
21597   {
21598     try {
21599       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
21600     } CALL_CATCH_EXCEPTION(0);
21601   }
21602
21603   jresult = result;
21604   return jresult;
21605 }
21606
21607
21608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
21609   void * jresult ;
21610   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21611   Dali::Vector2 *result = 0 ;
21612
21613   arg1 = (Dali::WheelEvent *)jarg1;
21614   {
21615     try {
21616       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
21617     } CALL_CATCH_EXCEPTION(0);
21618   }
21619
21620   jresult = (void *)result;
21621   return jresult;
21622 }
21623
21624
21625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
21626   int jresult ;
21627   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21628   int result;
21629
21630   arg1 = (Dali::WheelEvent *)jarg1;
21631   {
21632     try {
21633       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
21634     } catch (std::out_of_range& e) {
21635       {
21636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21637       };
21638     } catch (std::exception& e) {
21639       {
21640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21641       };
21642     } catch (Dali::DaliException e) {
21643       {
21644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21645       };
21646     } catch (...) {
21647       {
21648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21649       };
21650     }
21651   }
21652
21653   jresult = result;
21654   return jresult;
21655 }
21656
21657
21658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
21659   unsigned int jresult ;
21660   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21661   unsigned int result;
21662
21663   arg1 = (Dali::WheelEvent *)jarg1;
21664   {
21665     try {
21666       result = ((Dali::WheelEvent const *)arg1)->GetTime();
21667     } catch (std::out_of_range& e) {
21668       {
21669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21670       };
21671     } catch (std::exception& e) {
21672       {
21673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (Dali::DaliException e) {
21676       {
21677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21682       };
21683     }
21684   }
21685
21686   jresult = result;
21687   return jresult;
21688 }
21689
21690 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
21691   char * jresult ;
21692   Dali::KeyEvent *arg1 = 0 ;
21693   std::string result;
21694
21695   arg1 = (Dali::KeyEvent *)jarg1;
21696   if (!arg1) {
21697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21698     return 0;
21699   }
21700   {
21701     try {
21702       result = arg1->GetDeviceName();
21703     } CALL_CATCH_EXCEPTION(0);
21704   }
21705
21706   jresult = SWIG_csharp_string_callback((&result)->c_str());
21707   return jresult;
21708 }
21709
21710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
21711   int jresult ;
21712   Dali::KeyEvent *arg1 = 0 ;
21713   Dali::Device::Class::Type result;
21714
21715   arg1 = (Dali::KeyEvent *)jarg1;
21716   if (!arg1) {
21717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21718     return 0;
21719   }
21720   {
21721     try {
21722       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
21723     } CALL_CATCH_EXCEPTION(0);
21724   }
21725
21726   jresult = (int)result;
21727   return jresult;
21728 }
21729
21730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
21731   int jresult ;
21732   Dali::KeyEvent *arg1 = 0 ;
21733   Dali::Device::Subclass::Type result;
21734
21735   arg1 = (Dali::KeyEvent *)jarg1;
21736   if (!arg1) {
21737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21738     return 0;
21739   }
21740   {
21741     try {
21742       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
21743     } CALL_CATCH_EXCEPTION(0);
21744   }
21745
21746   jresult = (int)result;
21747   return jresult;
21748 }
21749
21750
21751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
21752   void * jresult ;
21753   Dali::Stage result;
21754
21755   {
21756     try {
21757       result = Dali::Stage::GetCurrent();
21758     } CALL_CATCH_EXCEPTION(0);
21759   }
21760
21761   jresult = new Dali::Stage((const Dali::Stage &)result);
21762   return jresult;
21763 }
21764
21765
21766 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
21767   bool jresult ;
21768   bool result;
21769
21770   {
21771     try {
21772       result = (bool)Dali::Stage::IsInstalled();
21773     } CALL_CATCH_EXCEPTION(0);
21774   }
21775
21776   jresult = result;
21777   return jresult;
21778 }
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
21781   void * jresult ;
21782   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21783   Dali::RenderTaskList result;
21784
21785   arg1 = (Dali::Stage *)jarg1;
21786   {
21787     try {
21788       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
21789     } CALL_CATCH_EXCEPTION(0);
21790   }
21791
21792   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
21793   return jresult;
21794 }
21795
21796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
21797   void * jresult ;
21798   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21799   Dali::Vector2 result;
21800
21801   arg1 = (Dali::Stage *)jarg1;
21802   {
21803     try {
21804       result = ((Dali::Stage const *)arg1)->GetDpi();
21805     } CALL_CATCH_EXCEPTION(0);
21806   }
21807
21808   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21809   return jresult;
21810 }
21811
21812
21813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
21814   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21815   float arg2 ;
21816
21817   arg1 = (Dali::Stage *)jarg1;
21818   arg2 = (float)jarg2;
21819   {
21820     try {
21821       (arg1)->KeepRendering(arg2);
21822     } CALL_CATCH_EXCEPTION();
21823   }
21824
21825 }
21826
21827
21828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
21829   void * jresult ;
21830   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21831   Dali::Stage::KeyEventSignalType *result = 0 ;
21832
21833   arg1 = (Dali::Stage *)jarg1;
21834   {
21835     try {
21836       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
21837     } CALL_CATCH_EXCEPTION(0);
21838   }
21839
21840   jresult = (void *)result;
21841   return jresult;
21842 }
21843
21844
21845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
21846   void * jresult ;
21847   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21848   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
21849
21850   arg1 = (Dali::Stage *)jarg1;
21851   {
21852     try {
21853       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
21854     } CALL_CATCH_EXCEPTION(0);
21855   }
21856
21857   jresult = (void *)result;
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
21863   void * jresult ;
21864   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21865   Dali::Stage::TouchEventSignalType *result = 0 ;
21866
21867   arg1 = (Dali::Stage *)jarg1;
21868   {
21869     try {
21870       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
21871     } CALL_CATCH_EXCEPTION(0);
21872   }
21873
21874   jresult = (void *)result;
21875   return jresult;
21876 }
21877
21878
21879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
21880   void * jresult ;
21881   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21882   Dali::Stage::WheelEventSignalType *result = 0 ;
21883
21884   arg1 = (Dali::Stage *)jarg1;
21885   {
21886     try {
21887       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
21888     } CALL_CATCH_EXCEPTION(0);
21889   }
21890
21891   jresult = (void *)result;
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
21897   void * jresult ;
21898   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21899   Dali::Stage::ContextStatusSignal *result = 0 ;
21900
21901   arg1 = (Dali::Stage *)jarg1;
21902   {
21903     try {
21904       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
21905     } CALL_CATCH_EXCEPTION(0);
21906   }
21907
21908   jresult = (void *)result;
21909   return jresult;
21910 }
21911
21912
21913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
21914   void * jresult ;
21915   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21916   Dali::Stage::ContextStatusSignal *result = 0 ;
21917
21918   arg1 = (Dali::Stage *)jarg1;
21919   {
21920     try {
21921       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
21922     } CALL_CATCH_EXCEPTION(0);
21923   }
21924
21925   jresult = (void *)result;
21926   return jresult;
21927 }
21928
21929
21930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
21931   void * jresult ;
21932   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21933   Dali::Stage::SceneCreatedSignalType *result = 0 ;
21934
21935   arg1 = (Dali::Stage *)jarg1;
21936   {
21937     try {
21938       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
21939     } CALL_CATCH_EXCEPTION(0);
21940   }
21941
21942   jresult = (void *)result;
21943   return jresult;
21944 }
21945
21946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
21947   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21948   Dali::DevelStage::Rendering arg2 ;
21949
21950   arg1 = (Dali::Stage *)jarg1;
21951   arg2 = (Dali::DevelStage::Rendering)jarg2;
21952   {
21953     try {
21954       DevelStage::SetRenderingBehavior(*arg1,arg2);
21955     } CALL_CATCH_EXCEPTION();
21956   }
21957
21958 }
21959
21960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
21961
21962   int jresult ;
21963   int result ;
21964   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
21965
21966   arg1 = (Dali::Stage *)jarg1;
21967   {
21968     try {
21969       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
21970     } CALL_CATCH_EXCEPTION(0);
21971   }
21972
21973   jresult = result;
21974   return jresult;
21975 }
21976
21977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
21978   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
21979
21980   arg1 = (Dali::RelayoutContainer *)jarg1;
21981   {
21982     try {
21983       delete arg1;
21984     } CALL_CATCH_EXCEPTION();
21985   }
21986
21987 }
21988
21989
21990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
21991   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
21992   Dali::Actor *arg2 = 0 ;
21993   Dali::Vector2 *arg3 = 0 ;
21994
21995   arg1 = (Dali::RelayoutContainer *)jarg1;
21996   arg2 = (Dali::Actor *)jarg2;
21997   if (!arg2) {
21998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21999     return ;
22000   }
22001   arg3 = (Dali::Vector2 *)jarg3;
22002   if (!arg3) {
22003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22004     return ;
22005   }
22006   {
22007     try {
22008       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
22009     } CALL_CATCH_EXCEPTION();
22010   }
22011
22012 }
22013
22014
22015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
22016   void * jresult ;
22017   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22018   Dali::CustomActor result;
22019
22020   arg1 = (Dali::CustomActorImpl *)jarg1;
22021   {
22022     try {
22023       result = ((Dali::CustomActorImpl const *)arg1)->Self();
22024     } CALL_CATCH_EXCEPTION(0);
22025   }
22026
22027   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
22028   return jresult;
22029 }
22030
22031
22032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
22033   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22034   int arg2 ;
22035
22036   arg1 = (Dali::CustomActorImpl *)jarg1;
22037   arg2 = (int)jarg2;
22038   {
22039     try {
22040       (arg1)->OnSceneConnection(arg2);
22041     } CALL_CATCH_EXCEPTION();
22042   }
22043
22044 }
22045
22046
22047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
22048   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22049
22050   arg1 = (Dali::CustomActorImpl *)jarg1;
22051   {
22052     try {
22053       (arg1)->OnSceneDisconnection();
22054     } CALL_CATCH_EXCEPTION();
22055   }
22056
22057 }
22058
22059
22060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
22061   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22062   Dali::Actor *arg2 = 0 ;
22063
22064   arg1 = (Dali::CustomActorImpl *)jarg1;
22065   arg2 = (Dali::Actor *)jarg2;
22066   if (!arg2) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
22068     return ;
22069   }
22070   {
22071     try {
22072       (arg1)->OnChildAdd(*arg2);
22073     } CALL_CATCH_EXCEPTION();
22074   }
22075
22076 }
22077
22078
22079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
22080   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22081   Dali::Actor *arg2 = 0 ;
22082
22083   arg1 = (Dali::CustomActorImpl *)jarg1;
22084   arg2 = (Dali::Actor *)jarg2;
22085   if (!arg2) {
22086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
22087     return ;
22088   }
22089   {
22090     try {
22091       (arg1)->OnChildRemove(*arg2);
22092     } CALL_CATCH_EXCEPTION();
22093   }
22094
22095 }
22096
22097
22098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
22099   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22100   Dali::Property::Index arg2 ;
22101   Dali::Property::Value arg3 ;
22102   Dali::Property::Value *argp3 ;
22103
22104   arg1 = (Dali::CustomActorImpl *)jarg1;
22105   arg2 = (Dali::Property::Index)jarg2;
22106   argp3 = (Dali::Property::Value *)jarg3;
22107   if (!argp3) {
22108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
22109     return ;
22110   }
22111   arg3 = *argp3;
22112   {
22113     try {
22114       (arg1)->OnPropertySet(arg2,arg3);
22115     } CALL_CATCH_EXCEPTION();
22116   }
22117
22118 }
22119
22120
22121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
22122   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22123   Dali::Vector3 *arg2 = 0 ;
22124
22125   arg1 = (Dali::CustomActorImpl *)jarg1;
22126   arg2 = (Dali::Vector3 *)jarg2;
22127   if (!arg2) {
22128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22129     return ;
22130   }
22131   {
22132     try {
22133       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
22134     } CALL_CATCH_EXCEPTION();
22135   }
22136
22137 }
22138
22139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
22140   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22141   Dali::Animation *arg2 = 0 ;
22142   Dali::Vector3 *arg3 = 0 ;
22143
22144   arg1 = (Dali::CustomActorImpl *)jarg1;
22145   arg2 = (Dali::Animation *)jarg2;
22146   if (!arg2) {
22147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
22148     return ;
22149   }
22150   arg3 = (Dali::Vector3 *)jarg3;
22151   if (!arg3) {
22152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22153     return ;
22154   }
22155   {
22156     try {
22157       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
22158     } CALL_CATCH_EXCEPTION();
22159   }
22160 }
22161
22162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
22163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22164   Dali::Vector2 *arg2 = 0 ;
22165   Dali::RelayoutContainer *arg3 = 0 ;
22166
22167   arg1 = (Dali::CustomActorImpl *)jarg1;
22168   arg2 = (Dali::Vector2 *)jarg2;
22169   if (!arg2) {
22170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22171     return ;
22172   }
22173   arg3 = (Dali::RelayoutContainer *)jarg3;
22174   if (!arg3) {
22175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
22176     return ;
22177   }
22178   {
22179     try {
22180       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
22181     } CALL_CATCH_EXCEPTION();
22182   }
22183
22184 }
22185
22186
22187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
22188   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22189   Dali::ResizePolicy::Type arg2 ;
22190   Dali::Dimension::Type arg3 ;
22191
22192   arg1 = (Dali::CustomActorImpl *)jarg1;
22193   arg2 = (Dali::ResizePolicy::Type)jarg2;
22194   arg3 = (Dali::Dimension::Type)jarg3;
22195   {
22196     try {
22197       (arg1)->OnSetResizePolicy(arg2,arg3);
22198     } CALL_CATCH_EXCEPTION();
22199   }
22200
22201 }
22202
22203
22204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
22205   void * jresult ;
22206   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22207   Dali::Vector3 result;
22208
22209   arg1 = (Dali::CustomActorImpl *)jarg1;
22210   {
22211     try {
22212       result = (arg1)->GetNaturalSize();
22213     } CALL_CATCH_EXCEPTION(0);
22214   }
22215
22216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22217   return jresult;
22218 }
22219
22220
22221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
22222   float jresult ;
22223   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22224   Dali::Actor *arg2 = 0 ;
22225   Dali::Dimension::Type arg3 ;
22226   float result;
22227
22228   arg1 = (Dali::CustomActorImpl *)jarg1;
22229   arg2 = (Dali::Actor *)jarg2;
22230   if (!arg2) {
22231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
22232     return 0;
22233   }
22234   arg3 = (Dali::Dimension::Type)jarg3;
22235   {
22236     try {
22237       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
22238     } CALL_CATCH_EXCEPTION(0);
22239   }
22240
22241   jresult = result;
22242   return jresult;
22243 }
22244
22245
22246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
22247   float jresult ;
22248   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22249   float arg2 ;
22250   float result;
22251
22252   arg1 = (Dali::CustomActorImpl *)jarg1;
22253   arg2 = (float)jarg2;
22254   {
22255     try {
22256       result = (float)(arg1)->GetHeightForWidth(arg2);
22257     } CALL_CATCH_EXCEPTION(0);
22258   }
22259
22260   jresult = result;
22261   return jresult;
22262 }
22263
22264
22265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
22266   float jresult ;
22267   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22268   float arg2 ;
22269   float result;
22270
22271   arg1 = (Dali::CustomActorImpl *)jarg1;
22272   arg2 = (float)jarg2;
22273   {
22274     try {
22275       result = (float)(arg1)->GetWidthForHeight(arg2);
22276     } CALL_CATCH_EXCEPTION(0);
22277   }
22278
22279   jresult = result;
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
22285   bool jresult ;
22286   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22287   Dali::Dimension::Type arg2 ;
22288   bool result;
22289
22290   arg1 = (Dali::CustomActorImpl *)jarg1;
22291   arg2 = (Dali::Dimension::Type)jarg2;
22292   {
22293     try {
22294       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
22295     } CALL_CATCH_EXCEPTION(0);
22296   }
22297
22298   jresult = result;
22299   return jresult;
22300 }
22301
22302
22303 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
22304   bool jresult ;
22305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22306   bool result;
22307
22308   arg1 = (Dali::CustomActorImpl *)jarg1;
22309   {
22310     try {
22311       result = (bool)(arg1)->RelayoutDependentOnChildren();
22312     } CALL_CATCH_EXCEPTION(0);
22313   }
22314
22315   jresult = result;
22316   return jresult;
22317 }
22318
22319
22320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
22321   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22322   Dali::Dimension::Type arg2 ;
22323
22324   arg1 = (Dali::CustomActorImpl *)jarg1;
22325   arg2 = (Dali::Dimension::Type)jarg2;
22326   {
22327     try {
22328       (arg1)->OnCalculateRelayoutSize(arg2);
22329     } CALL_CATCH_EXCEPTION();
22330   }
22331
22332 }
22333
22334
22335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
22336   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22337   float arg2 ;
22338   Dali::Dimension::Type arg3 ;
22339
22340   arg1 = (Dali::CustomActorImpl *)jarg1;
22341   arg2 = (float)jarg2;
22342   arg3 = (Dali::Dimension::Type)jarg3;
22343   {
22344     try {
22345       (arg1)->OnLayoutNegotiated(arg2,arg3);
22346     } CALL_CATCH_EXCEPTION();
22347   }
22348
22349 }
22350
22351 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
22352   bool jresult ;
22353   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
22354   bool result;
22355
22356   arg1 = (Dali::CustomActorImpl *)jarg1;
22357   {
22358     try {
22359       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
22360     } CALL_CATCH_EXCEPTION(0);
22361   }
22362
22363   jresult = result;
22364   return jresult;
22365 }
22366
22367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
22368   void * jresult ;
22369   Dali::CustomActor *result = 0 ;
22370
22371   {
22372     try {
22373       result = (Dali::CustomActor *)new Dali::CustomActor();
22374     } CALL_CATCH_EXCEPTION(0);
22375   }
22376
22377   jresult = (void *)result;
22378   return jresult;
22379 }
22380
22381
22382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
22383   void * jresult ;
22384   Dali::BaseHandle arg1 ;
22385   Dali::BaseHandle *argp1 ;
22386   Dali::CustomActor result;
22387
22388   argp1 = (Dali::BaseHandle *)jarg1;
22389   if (!argp1) {
22390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22391     return 0;
22392   }
22393   arg1 = *argp1;
22394   {
22395     try {
22396       result = Dali::CustomActor::DownCast(arg1);
22397     } CALL_CATCH_EXCEPTION(0);
22398   }
22399
22400   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
22401   return jresult;
22402 }
22403
22404
22405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
22406   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
22407
22408   arg1 = (Dali::CustomActor *)jarg1;
22409   {
22410     try {
22411       delete arg1;
22412     } CALL_CATCH_EXCEPTION();
22413   }
22414
22415 }
22416
22417
22418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
22419   void * jresult ;
22420   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
22421   Dali::CustomActorImpl *result = 0 ;
22422
22423   arg1 = (Dali::CustomActor *)jarg1;
22424   {
22425     try {
22426       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
22427     } CALL_CATCH_EXCEPTION(0);
22428   }
22429
22430   jresult = (void *)result;
22431   return jresult;
22432 }
22433
22434
22435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
22436   void * jresult ;
22437   Dali::CustomActorImpl *arg1 = 0 ;
22438   Dali::CustomActor *result = 0 ;
22439
22440   arg1 = (Dali::CustomActorImpl *)jarg1;
22441   if (!arg1) {
22442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
22443     return 0;
22444   }
22445   {
22446     try {
22447       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
22448     } CALL_CATCH_EXCEPTION(0);
22449   }
22450
22451   jresult = (void *)result;
22452   return jresult;
22453 }
22454
22455
22456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
22457   void * jresult ;
22458   Dali::CustomActor *arg1 = 0 ;
22459   Dali::CustomActor *result = 0 ;
22460
22461   arg1 = (Dali::CustomActor *)jarg1;
22462   if (!arg1) {
22463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
22464     return 0;
22465   }
22466   {
22467     try {
22468       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
22469     } CALL_CATCH_EXCEPTION(0);
22470   }
22471
22472   jresult = (void *)result;
22473   return jresult;
22474 }
22475
22476
22477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
22478   void * jresult ;
22479   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
22480   Dali::CustomActor *arg2 = 0 ;
22481   Dali::CustomActor *result = 0 ;
22482
22483   arg1 = (Dali::CustomActor *)jarg1;
22484   arg2 = (Dali::CustomActor *)jarg2;
22485   if (!arg2) {
22486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
22487     return 0;
22488   }
22489   {
22490     try {
22491       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
22492     } CALL_CATCH_EXCEPTION(0);
22493   }
22494
22495   jresult = (void *)result;
22496   return jresult;
22497 }
22498
22499
22500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
22501   int jresult ;
22502   int result;
22503
22504   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
22505   jresult = (int)result;
22506   return jresult;
22507 }
22508
22509
22510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
22511   int jresult ;
22512   int result;
22513
22514   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
22515   jresult = (int)result;
22516   return jresult;
22517 }
22518
22519
22520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
22521   int jresult ;
22522   int result;
22523
22524   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
22525   jresult = (int)result;
22526   return jresult;
22527 }
22528
22529
22530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
22531   int jresult ;
22532   int result;
22533
22534   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
22535   jresult = (int)result;
22536   return jresult;
22537 }
22538
22539
22540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
22541   int jresult ;
22542   int result;
22543
22544   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
22545   jresult = (int)result;
22546   return jresult;
22547 }
22548
22549
22550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
22551   int jresult ;
22552   int result;
22553
22554   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
22555   jresult = (int)result;
22556   return jresult;
22557 }
22558
22559
22560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
22561   int jresult ;
22562   int result;
22563
22564   result = (int)Dali::PanGestureDetector::Property::PANNING;
22565   jresult = (int)result;
22566   return jresult;
22567 }
22568
22569
22570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
22571   void * jresult ;
22572   Dali::PanGestureDetector::Property *result = 0 ;
22573
22574   {
22575     try {
22576       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
22577     } CALL_CATCH_EXCEPTION(0);
22578   }
22579
22580   jresult = (void *)result;
22581   return jresult;
22582 }
22583
22584
22585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
22586   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
22587
22588   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
22589   {
22590     try {
22591       delete arg1;
22592     } CALL_CATCH_EXCEPTION();
22593   }
22594
22595 }
22596
22597
22598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
22599   void * jresult ;
22600   Dali::Radian *result = 0 ;
22601
22602   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
22603   jresult = (void *)result;
22604   return jresult;
22605 }
22606
22607
22608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
22609   void * jresult ;
22610   Dali::Radian *result = 0 ;
22611
22612   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
22613   jresult = (void *)result;
22614   return jresult;
22615 }
22616
22617
22618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
22619   void * jresult ;
22620   Dali::Radian *result = 0 ;
22621
22622   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
22623   jresult = (void *)result;
22624   return jresult;
22625 }
22626
22627
22628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
22629   void * jresult ;
22630   Dali::Radian *result = 0 ;
22631
22632   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
22633   jresult = (void *)result;
22634   return jresult;
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
22639   void * jresult ;
22640   Dali::Radian *result = 0 ;
22641
22642   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
22643   jresult = (void *)result;
22644   return jresult;
22645 }
22646
22647
22648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
22649   void * jresult ;
22650   Dali::Radian *result = 0 ;
22651
22652   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
22653   jresult = (void *)result;
22654   return jresult;
22655 }
22656
22657
22658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
22659   void * jresult ;
22660   Dali::Radian *result = 0 ;
22661
22662   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
22663   jresult = (void *)result;
22664   return jresult;
22665 }
22666
22667
22668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
22669   void * jresult ;
22670   Dali::PanGestureDetector *result = 0 ;
22671
22672   {
22673     try {
22674       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
22675     } CALL_CATCH_EXCEPTION(0);
22676   }
22677
22678   jresult = (void *)result;
22679   return jresult;
22680 }
22681
22682
22683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
22684   void * jresult ;
22685   Dali::PanGestureDetector result;
22686
22687   {
22688     try {
22689       result = Dali::PanGestureDetector::New();
22690     } CALL_CATCH_EXCEPTION(0);
22691   }
22692
22693   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
22694   return jresult;
22695 }
22696
22697
22698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
22699   void * jresult ;
22700   Dali::BaseHandle arg1 ;
22701   Dali::BaseHandle *argp1 ;
22702   Dali::PanGestureDetector result;
22703
22704   argp1 = (Dali::BaseHandle *)jarg1;
22705   if (!argp1) {
22706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22707     return 0;
22708   }
22709   arg1 = *argp1;
22710   {
22711     try {
22712       result = Dali::PanGestureDetector::DownCast(arg1);
22713     } CALL_CATCH_EXCEPTION(0);
22714   }
22715
22716   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
22717   return jresult;
22718 }
22719
22720
22721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
22722   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22723
22724   arg1 = (Dali::PanGestureDetector *)jarg1;
22725   {
22726     try {
22727       delete arg1;
22728     } CALL_CATCH_EXCEPTION();
22729   }
22730
22731 }
22732
22733
22734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
22735   void * jresult ;
22736   Dali::PanGestureDetector *arg1 = 0 ;
22737   Dali::PanGestureDetector *result = 0 ;
22738
22739   arg1 = (Dali::PanGestureDetector *)jarg1;
22740   if (!arg1) {
22741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
22742     return 0;
22743   }
22744   {
22745     try {
22746       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
22747     } CALL_CATCH_EXCEPTION(0);
22748   }
22749
22750   jresult = (void *)result;
22751   return jresult;
22752 }
22753
22754
22755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
22756   void * jresult ;
22757   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22758   Dali::PanGestureDetector *arg2 = 0 ;
22759   Dali::PanGestureDetector *result = 0 ;
22760
22761   arg1 = (Dali::PanGestureDetector *)jarg1;
22762   arg2 = (Dali::PanGestureDetector *)jarg2;
22763   if (!arg2) {
22764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
22765     return 0;
22766   }
22767   {
22768     try {
22769       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
22770     } CALL_CATCH_EXCEPTION(0);
22771   }
22772
22773   jresult = (void *)result;
22774   return jresult;
22775 }
22776
22777
22778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
22779   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22780   unsigned int arg2 ;
22781
22782   arg1 = (Dali::PanGestureDetector *)jarg1;
22783   arg2 = (unsigned int)jarg2;
22784   {
22785     try {
22786       (arg1)->SetMinimumTouchesRequired(arg2);
22787     } CALL_CATCH_EXCEPTION();
22788   }
22789
22790 }
22791
22792
22793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
22794   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22795   unsigned int arg2 ;
22796
22797   arg1 = (Dali::PanGestureDetector *)jarg1;
22798   arg2 = (unsigned int)jarg2;
22799   {
22800     try {
22801       (arg1)->SetMaximumTouchesRequired(arg2);
22802     } CALL_CATCH_EXCEPTION();
22803   }
22804
22805 }
22806
22807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
22808   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22809   uint32_t arg2 ;
22810
22811   arg1 = (Dali::PanGestureDetector *)jarg1;
22812   arg2 = (uint32_t)jarg2;
22813   {
22814     try {
22815       (arg1)->SetMaximumMotionEventAge(arg2);
22816     } CALL_CATCH_EXCEPTION();
22817   }
22818
22819 }
22820
22821
22822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
22823   unsigned int jresult ;
22824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22825   unsigned int result;
22826
22827   arg1 = (Dali::PanGestureDetector *)jarg1;
22828   {
22829     try {
22830       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
22831     } CALL_CATCH_EXCEPTION(0);
22832   }
22833
22834   jresult = result;
22835   return jresult;
22836 }
22837
22838
22839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
22840   unsigned int jresult ;
22841   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22842   unsigned int result;
22843
22844   arg1 = (Dali::PanGestureDetector *)jarg1;
22845   {
22846     try {
22847       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
22848     } CALL_CATCH_EXCEPTION(0);
22849   }
22850
22851   jresult = result;
22852   return jresult;
22853 }
22854
22855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
22856   unsigned int jresult ;
22857   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22858   uint32_t result;
22859
22860   arg1 = (Dali::PanGestureDetector *)jarg1;
22861   {
22862     try {
22863       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
22864     } CALL_CATCH_EXCEPTION(0);
22865   }
22866
22867   jresult = result;
22868   return jresult;
22869 }
22870
22871
22872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22873   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22874   Dali::Radian arg2 ;
22875   Dali::Radian arg3 ;
22876   Dali::Radian *argp2 ;
22877   Dali::Radian *argp3 ;
22878
22879   arg1 = (Dali::PanGestureDetector *)jarg1;
22880   argp2 = (Dali::Radian *)jarg2;
22881   if (!argp2) {
22882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22883     return ;
22884   }
22885   arg2 = *argp2;
22886   argp3 = (Dali::Radian *)jarg3;
22887   if (!argp3) {
22888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22889     return ;
22890   }
22891   arg3 = *argp3;
22892   {
22893     try {
22894       (arg1)->AddAngle(arg2,arg3);
22895     } CALL_CATCH_EXCEPTION();
22896   }
22897
22898 }
22899
22900
22901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
22902   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22903   Dali::Radian arg2 ;
22904   Dali::Radian *argp2 ;
22905
22906   arg1 = (Dali::PanGestureDetector *)jarg1;
22907   argp2 = (Dali::Radian *)jarg2;
22908   if (!argp2) {
22909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22910     return ;
22911   }
22912   arg2 = *argp2;
22913   {
22914     try {
22915       (arg1)->AddAngle(arg2);
22916     } CALL_CATCH_EXCEPTION();
22917   }
22918
22919 }
22920
22921
22922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22923   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22924   Dali::Radian arg2 ;
22925   Dali::Radian arg3 ;
22926   Dali::Radian *argp2 ;
22927   Dali::Radian *argp3 ;
22928
22929   arg1 = (Dali::PanGestureDetector *)jarg1;
22930   argp2 = (Dali::Radian *)jarg2;
22931   if (!argp2) {
22932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22933     return ;
22934   }
22935   arg2 = *argp2;
22936   argp3 = (Dali::Radian *)jarg3;
22937   if (!argp3) {
22938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22939     return ;
22940   }
22941   arg3 = *argp3;
22942   {
22943     try {
22944       (arg1)->AddDirection(arg2,arg3);
22945     } CALL_CATCH_EXCEPTION();
22946   }
22947
22948 }
22949
22950
22951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
22952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22953   Dali::Radian arg2 ;
22954   Dali::Radian *argp2 ;
22955
22956   arg1 = (Dali::PanGestureDetector *)jarg1;
22957   argp2 = (Dali::Radian *)jarg2;
22958   if (!argp2) {
22959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
22960     return ;
22961   }
22962   arg2 = *argp2;
22963   {
22964     try {
22965       (arg1)->AddDirection(arg2);
22966     } CALL_CATCH_EXCEPTION();
22967   }
22968
22969 }
22970
22971
22972 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
22973   unsigned long jresult ;
22974   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22975   size_t result;
22976
22977   arg1 = (Dali::PanGestureDetector *)jarg1;
22978   {
22979     try {
22980       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
22981     } CALL_CATCH_EXCEPTION(0);
22982   }
22983
22984   jresult = (unsigned long)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
22990   void * jresult ;
22991   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
22992   size_t arg2 ;
22993   Dali::PanGestureDetector::AngleThresholdPair result;
22994
22995   arg1 = (Dali::PanGestureDetector *)jarg1;
22996   arg2 = (size_t)jarg2;
22997   {
22998     try {
22999       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
23000     } CALL_CATCH_EXCEPTION(0);
23001   }
23002
23003   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
23009   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
23010
23011   arg1 = (Dali::PanGestureDetector *)jarg1;
23012   {
23013     try {
23014       (arg1)->ClearAngles();
23015     } CALL_CATCH_EXCEPTION();
23016   }
23017
23018 }
23019
23020
23021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
23022   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
23023   Dali::Radian arg2 ;
23024   Dali::Radian *argp2 ;
23025
23026   arg1 = (Dali::PanGestureDetector *)jarg1;
23027   argp2 = (Dali::Radian *)jarg2;
23028   if (!argp2) {
23029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
23030     return ;
23031   }
23032   arg2 = *argp2;
23033   {
23034     try {
23035       (arg1)->RemoveAngle(arg2);
23036     } CALL_CATCH_EXCEPTION();
23037   }
23038
23039 }
23040
23041
23042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
23043   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
23044   Dali::Radian arg2 ;
23045   Dali::Radian *argp2 ;
23046
23047   arg1 = (Dali::PanGestureDetector *)jarg1;
23048   argp2 = (Dali::Radian *)jarg2;
23049   if (!argp2) {
23050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
23051     return ;
23052   }
23053   arg2 = *argp2;
23054   {
23055     try {
23056       (arg1)->RemoveDirection(arg2);
23057     } CALL_CATCH_EXCEPTION();
23058   }
23059
23060 }
23061
23062
23063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
23064   void * jresult ;
23065   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
23066   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
23067
23068   arg1 = (Dali::PanGestureDetector *)jarg1;
23069   {
23070     try {
23071       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
23072     } CALL_CATCH_EXCEPTION(0);
23073   }
23074
23075   jresult = (void *)result;
23076   return jresult;
23077 }
23078
23079
23080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
23081   Dali::PanGesture *arg1 = 0 ;
23082
23083   arg1 = (Dali::PanGesture *)jarg1;
23084   if (!arg1) {
23085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
23086     return ;
23087   }
23088   {
23089     try {
23090       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
23091     } CALL_CATCH_EXCEPTION();
23092   }
23093
23094 }
23095
23096
23097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
23098   void * jresult ;
23099   Dali::PanGesture *result = 0 ;
23100
23101   {
23102     try {
23103       result = (Dali::PanGesture *)new Dali::PanGesture();
23104     } CALL_CATCH_EXCEPTION(0);
23105   }
23106
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
23113   void * jresult ;
23114   Dali::GestureState arg1 ;
23115   Dali::PanGesture result;
23116
23117   arg1 = (Dali::GestureState)jarg1;
23118   {
23119     try {
23120       result = DevelPanGesture::New(arg1);
23121     } CALL_CATCH_EXCEPTION(0);
23122   }
23123
23124   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
23130   void * jresult ;
23131   Dali::PanGesture *arg1 = 0 ;
23132   Dali::PanGesture *result = 0 ;
23133
23134   arg1 = (Dali::PanGesture *)jarg1;
23135   if (!arg1) {
23136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
23137     return 0;
23138   }
23139   {
23140     try {
23141       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
23142     } CALL_CATCH_EXCEPTION(0);
23143   }
23144
23145   jresult = (void *)result;
23146   return jresult;
23147 }
23148
23149
23150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
23151   void * jresult ;
23152   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23153   Dali::PanGesture *arg2 = 0 ;
23154   Dali::PanGesture *result = 0 ;
23155
23156   arg1 = (Dali::PanGesture *)jarg1;
23157   arg2 = (Dali::PanGesture *)jarg2;
23158   if (!arg2) {
23159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
23160     return 0;
23161   }
23162   {
23163     try {
23164       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
23165     } CALL_CATCH_EXCEPTION(0);
23166   }
23167
23168   jresult = (void *)result;
23169   return jresult;
23170 }
23171
23172
23173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
23174   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23175
23176   arg1 = (Dali::PanGesture *)jarg1;
23177   {
23178     try {
23179       delete arg1;
23180     } CALL_CATCH_EXCEPTION();
23181   }
23182
23183 }
23184
23185
23186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
23187   void * jresult ;
23188   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23189   Dali::Vector2 result;
23190
23191   arg1 = (Dali::PanGesture *)jarg1;
23192   {
23193     try {
23194       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
23195     } catch (std::out_of_range& e) {
23196       {
23197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23198       };
23199     } catch (std::exception& e) {
23200       {
23201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23202       };
23203     } catch (Dali::DaliException e) {
23204       {
23205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23206       };
23207     } catch (...) {
23208       {
23209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23210       };
23211     }
23212   }
23213   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
23219   void * jresult ;
23220   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23221   Dali::Vector2 result;
23222
23223   arg1 = (Dali::PanGesture *)jarg1;
23224   {
23225     try {
23226       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
23227     } catch (std::out_of_range& e) {
23228       {
23229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23230       };
23231     } catch (std::exception& e) {
23232       {
23233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23234       };
23235     } catch (Dali::DaliException e) {
23236       {
23237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23238       };
23239     } catch (...) {
23240       {
23241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23242       };
23243     }
23244   }
23245   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23246   return jresult;
23247 }
23248
23249
23250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
23251   void * jresult ;
23252   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23253   Dali::Vector2 result;
23254
23255   arg1 = (Dali::PanGesture *)jarg1;
23256   {
23257     try {
23258       result = ((Dali::PanGesture const *)arg1)->GetPosition();
23259     } catch (std::out_of_range& e) {
23260       {
23261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23262       };
23263     } catch (std::exception& e) {
23264       {
23265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23266       };
23267     } catch (Dali::DaliException e) {
23268       {
23269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23270       };
23271     } catch (...) {
23272       {
23273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23274       };
23275     }
23276   }
23277   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23278   return jresult;
23279 }
23280
23281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
23282   void * jresult ;
23283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23284   Dali::Vector2 result;
23285
23286   arg1 = (Dali::PanGesture *)jarg1;
23287   {
23288     try {
23289       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
23290     } catch (std::out_of_range& e) {
23291       {
23292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23293       };
23294     } catch (std::exception& e) {
23295       {
23296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23297       };
23298     } catch (Dali::DaliException e) {
23299       {
23300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23301       };
23302     } catch (...) {
23303       {
23304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23305       };
23306     }
23307   }
23308   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23309   return jresult;
23310 }
23311
23312
23313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
23314   void * jresult ;
23315   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23316   Dali::Vector2 result;
23317
23318   arg1 = (Dali::PanGesture *)jarg1;
23319   {
23320     try {
23321       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
23322     } catch (std::out_of_range& e) {
23323       {
23324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23325       };
23326     } catch (std::exception& e) {
23327       {
23328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23329       };
23330     } catch (Dali::DaliException e) {
23331       {
23332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23333       };
23334     } catch (...) {
23335       {
23336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23337       };
23338     }
23339   }
23340   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
23346   void * jresult ;
23347   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23348   Dali::Vector2 result;
23349
23350   arg1 = (Dali::PanGesture *)jarg1;
23351   {
23352     try {
23353       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
23354     } catch (std::out_of_range& e) {
23355       {
23356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23357       };
23358     } catch (std::exception& e) {
23359       {
23360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23361       };
23362     } catch (Dali::DaliException e) {
23363       {
23364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23365       };
23366     } catch (...) {
23367       {
23368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23369       };
23370     }
23371   }
23372   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
23378   unsigned int jresult ;
23379   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23380   unsigned int result;
23381
23382   arg1 = (Dali::PanGesture *)jarg1;
23383   result = (unsigned int) ((arg1)->GetNumberOfTouches());
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
23390   float jresult ;
23391   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23392   float result;
23393
23394   arg1 = (Dali::PanGesture *)jarg1;
23395   {
23396     try {
23397       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
23398     } CALL_CATCH_EXCEPTION(0);
23399   }
23400
23401   jresult = result;
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
23407   float jresult ;
23408   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23409   float result;
23410
23411   arg1 = (Dali::PanGesture *)jarg1;
23412   {
23413     try {
23414       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
23415     } CALL_CATCH_EXCEPTION(0);
23416   }
23417
23418   jresult = result;
23419   return jresult;
23420 }
23421
23422
23423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
23424   float jresult ;
23425   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23426   float result;
23427
23428   arg1 = (Dali::PanGesture *)jarg1;
23429   {
23430     try {
23431       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
23432     } CALL_CATCH_EXCEPTION(0);
23433   }
23434
23435   jresult = result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
23441   float jresult ;
23442   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
23443   float result;
23444
23445   arg1 = (Dali::PanGesture *)jarg1;
23446   {
23447     try {
23448       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
23449     } CALL_CATCH_EXCEPTION(0);
23450   }
23451
23452   jresult = result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
23458   void * jresult ;
23459   Dali::PinchGestureDetector *result = 0 ;
23460
23461   {
23462     try {
23463       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
23464     } CALL_CATCH_EXCEPTION(0);
23465   }
23466
23467   jresult = (void *)result;
23468   return jresult;
23469 }
23470
23471
23472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
23473   void * jresult ;
23474   Dali::PinchGestureDetector result;
23475
23476   {
23477     try {
23478       result = Dali::PinchGestureDetector::New();
23479     } CALL_CATCH_EXCEPTION(0);
23480   }
23481
23482   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
23488   void * jresult ;
23489   Dali::BaseHandle arg1 ;
23490   Dali::BaseHandle *argp1 ;
23491   Dali::PinchGestureDetector result;
23492
23493   argp1 = (Dali::BaseHandle *)jarg1;
23494   if (!argp1) {
23495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23496     return 0;
23497   }
23498   arg1 = *argp1;
23499   {
23500     try {
23501       result = Dali::PinchGestureDetector::DownCast(arg1);
23502     } CALL_CATCH_EXCEPTION(0);
23503   }
23504
23505   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
23511   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
23512
23513   arg1 = (Dali::PinchGestureDetector *)jarg1;
23514   {
23515     try {
23516       delete arg1;
23517     } CALL_CATCH_EXCEPTION();
23518   }
23519
23520 }
23521
23522
23523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
23524   void * jresult ;
23525   Dali::PinchGestureDetector *arg1 = 0 ;
23526   Dali::PinchGestureDetector *result = 0 ;
23527
23528   arg1 = (Dali::PinchGestureDetector *)jarg1;
23529   if (!arg1) {
23530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
23531     return 0;
23532   }
23533   {
23534     try {
23535       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
23536     } CALL_CATCH_EXCEPTION(0);
23537   }
23538
23539   jresult = (void *)result;
23540   return jresult;
23541 }
23542
23543
23544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
23545   void * jresult ;
23546   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
23547   Dali::PinchGestureDetector *arg2 = 0 ;
23548   Dali::PinchGestureDetector *result = 0 ;
23549
23550   arg1 = (Dali::PinchGestureDetector *)jarg1;
23551   arg2 = (Dali::PinchGestureDetector *)jarg2;
23552   if (!arg2) {
23553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
23554     return 0;
23555   }
23556   {
23557     try {
23558       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
23559     } CALL_CATCH_EXCEPTION(0);
23560   }
23561
23562   jresult = (void *)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
23568   void * jresult ;
23569   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
23570   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
23571
23572   arg1 = (Dali::PinchGestureDetector *)jarg1;
23573   {
23574     try {
23575       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
23576     } CALL_CATCH_EXCEPTION(0);
23577   }
23578
23579   jresult = (void *)result;
23580   return jresult;
23581 }
23582
23583
23584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
23585   void * jresult ;
23586   Dali::PinchGesture *result = 0 ;
23587
23588   {
23589     try {
23590       result = (Dali::PinchGesture *)new Dali::PinchGesture();
23591     } CALL_CATCH_EXCEPTION(0);
23592   }
23593
23594   jresult = (void *)result;
23595   return jresult;
23596 }
23597
23598
23599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
23600   void * jresult ;
23601   Dali::GestureState arg1 ;
23602   Dali::PinchGesture result;
23603
23604   arg1 = (Dali::GestureState)jarg1;
23605   {
23606     try {
23607       result = DevelPinchGesture::New(arg1);
23608     } CALL_CATCH_EXCEPTION(0);
23609   }
23610
23611   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
23612   return jresult;
23613 }
23614
23615
23616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
23617   void * jresult ;
23618   Dali::PinchGesture *arg1 = 0 ;
23619   Dali::PinchGesture *result = 0 ;
23620
23621   arg1 = (Dali::PinchGesture *)jarg1;
23622   if (!arg1) {
23623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
23624     return 0;
23625   }
23626   {
23627     try {
23628       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
23629     } CALL_CATCH_EXCEPTION(0);
23630   }
23631
23632   jresult = (void *)result;
23633   return jresult;
23634 }
23635
23636
23637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
23638   void * jresult ;
23639   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23640   Dali::PinchGesture *arg2 = 0 ;
23641   Dali::PinchGesture *result = 0 ;
23642
23643   arg1 = (Dali::PinchGesture *)jarg1;
23644   arg2 = (Dali::PinchGesture *)jarg2;
23645   if (!arg2) {
23646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
23647     return 0;
23648   }
23649   {
23650     try {
23651       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
23652     } CALL_CATCH_EXCEPTION(0);
23653   }
23654
23655   jresult = (void *)result;
23656   return jresult;
23657 }
23658
23659
23660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
23661   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23662
23663   arg1 = (Dali::PinchGesture *)jarg1;
23664   {
23665     try {
23666       delete arg1;
23667     } CALL_CATCH_EXCEPTION();
23668   }
23669
23670 }
23671
23672
23673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
23674   float jresult ;
23675   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23676   float result;
23677
23678   arg1 = (Dali::PinchGesture *)jarg1;
23679   result = (float) ((arg1)->GetScale());
23680   jresult = result;
23681   return jresult;
23682 }
23683
23684
23685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
23686   float jresult ;
23687   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23688   float result;
23689
23690   arg1 = (Dali::PinchGesture *)jarg1;
23691   result = (float) ((arg1)->GetSpeed());
23692   jresult = result;
23693   return jresult;
23694 }
23695
23696
23697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
23698   void * jresult ;
23699   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23700   Dali::Vector2 result;
23701
23702   arg1 = (Dali::PinchGesture *)jarg1;
23703   {
23704     try {
23705       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
23706     } catch (std::out_of_range& e) {
23707       {
23708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23709       };
23710     } catch (std::exception& e) {
23711       {
23712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23713       };
23714     } catch (Dali::DaliException e) {
23715       {
23716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23717       };
23718     } catch (...) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23721       };
23722     }
23723   }
23724   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23725   return jresult;
23726 }
23727
23728
23729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
23730   void * jresult ;
23731   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
23732   Dali::Vector2 result;
23733
23734   arg1 = (Dali::PinchGesture *)jarg1;
23735   {
23736     try {
23737       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (Dali::DaliException e) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23749       };
23750     } catch (...) {
23751       {
23752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23753       };
23754     }
23755   }
23756   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23757   return jresult;
23758 }
23759
23760
23761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
23762   void * jresult ;
23763   Dali::TapGestureDetector *result = 0 ;
23764
23765   {
23766     try {
23767       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
23768     } CALL_CATCH_EXCEPTION(0);
23769   }
23770
23771   jresult = (void *)result;
23772   return jresult;
23773 }
23774
23775
23776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
23777   void * jresult ;
23778   Dali::TapGestureDetector result;
23779
23780   {
23781     try {
23782       result = Dali::TapGestureDetector::New();
23783     } CALL_CATCH_EXCEPTION(0);
23784   }
23785
23786   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
23787   return jresult;
23788 }
23789
23790
23791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
23792   void * jresult ;
23793   unsigned int arg1 ;
23794   Dali::TapGestureDetector result;
23795
23796   arg1 = (unsigned int)jarg1;
23797   {
23798     try {
23799       result = Dali::TapGestureDetector::New(arg1);
23800     } CALL_CATCH_EXCEPTION(0);
23801   }
23802
23803   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
23804   return jresult;
23805 }
23806
23807
23808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
23809   void * jresult ;
23810   Dali::BaseHandle arg1 ;
23811   Dali::BaseHandle *argp1 ;
23812   Dali::TapGestureDetector result;
23813
23814   argp1 = (Dali::BaseHandle *)jarg1;
23815   if (!argp1) {
23816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23817     return 0;
23818   }
23819   arg1 = *argp1;
23820   {
23821     try {
23822       result = Dali::TapGestureDetector::DownCast(arg1);
23823     } CALL_CATCH_EXCEPTION(0);
23824   }
23825
23826   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
23827   return jresult;
23828 }
23829
23830
23831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
23832   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23833
23834   arg1 = (Dali::TapGestureDetector *)jarg1;
23835   {
23836     try {
23837       delete arg1;
23838     } CALL_CATCH_EXCEPTION();
23839   }
23840
23841 }
23842
23843
23844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
23845   void * jresult ;
23846   Dali::TapGestureDetector *arg1 = 0 ;
23847   Dali::TapGestureDetector *result = 0 ;
23848
23849   arg1 = (Dali::TapGestureDetector *)jarg1;
23850   if (!arg1) {
23851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
23852     return 0;
23853   }
23854   {
23855     try {
23856       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
23857     } CALL_CATCH_EXCEPTION(0);
23858   }
23859
23860   jresult = (void *)result;
23861   return jresult;
23862 }
23863
23864
23865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
23866   void * jresult ;
23867   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23868   Dali::TapGestureDetector *arg2 = 0 ;
23869   Dali::TapGestureDetector *result = 0 ;
23870
23871   arg1 = (Dali::TapGestureDetector *)jarg1;
23872   arg2 = (Dali::TapGestureDetector *)jarg2;
23873   if (!arg2) {
23874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
23875     return 0;
23876   }
23877   {
23878     try {
23879       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
23880     } CALL_CATCH_EXCEPTION(0);
23881   }
23882
23883   jresult = (void *)result;
23884   return jresult;
23885 }
23886
23887
23888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
23889   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23890   unsigned int arg2 ;
23891
23892   arg1 = (Dali::TapGestureDetector *)jarg1;
23893   arg2 = (unsigned int)jarg2;
23894   {
23895     try {
23896       (arg1)->SetMinimumTapsRequired(arg2);
23897     } CALL_CATCH_EXCEPTION();
23898   }
23899
23900 }
23901
23902
23903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
23904   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23905   unsigned int arg2 ;
23906
23907   arg1 = (Dali::TapGestureDetector *)jarg1;
23908   arg2 = (unsigned int)jarg2;
23909   {
23910     try {
23911       (arg1)->SetMaximumTapsRequired(arg2);
23912     } CALL_CATCH_EXCEPTION();
23913   }
23914
23915 }
23916
23917
23918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
23919   unsigned int jresult ;
23920   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23921   unsigned int result;
23922
23923   arg1 = (Dali::TapGestureDetector *)jarg1;
23924   {
23925     try {
23926       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
23927     } CALL_CATCH_EXCEPTION(0);
23928   }
23929
23930   jresult = result;
23931   return jresult;
23932 }
23933
23934
23935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
23936   unsigned int jresult ;
23937   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23938   unsigned int result;
23939
23940   arg1 = (Dali::TapGestureDetector *)jarg1;
23941   {
23942     try {
23943       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
23944     } CALL_CATCH_EXCEPTION(0);
23945   }
23946
23947   jresult = result;
23948   return jresult;
23949 }
23950
23951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
23952   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
23953
23954   detector = (Dali::TapGestureDetector *)tapGestureDetector;
23955   if (!detector) {
23956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
23957     return;
23958   }
23959   {
23960     try {
23961       (detector)->ReceiveAllTapEvents(isReceive);
23962     } CALL_CATCH_EXCEPTION();
23963   }
23964
23965 }
23966
23967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
23968   void * jresult ;
23969   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
23970   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
23971
23972   arg1 = (Dali::TapGestureDetector *)jarg1;
23973   {
23974     try {
23975       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
23976     } CALL_CATCH_EXCEPTION(0);
23977   }
23978
23979   jresult = (void *)result;
23980   return jresult;
23981 }
23982
23983
23984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
23985   void * jresult ;
23986   Dali::TapGesture *result = 0 ;
23987
23988   {
23989     try {
23990       result = (Dali::TapGesture *)new Dali::TapGesture();
23991     } CALL_CATCH_EXCEPTION(0);
23992   }
23993
23994   jresult = (void *)result;
23995   return jresult;
23996 }
23997
23998
23999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
24000   void * jresult ;
24001   Dali::GestureState arg1 ;
24002   Dali::TapGesture result;
24003
24004   arg1 = (Dali::GestureState)jarg1;
24005   {
24006     try {
24007       result = DevelTapGesture::New(arg1);
24008     } CALL_CATCH_EXCEPTION(0);
24009   }
24010
24011   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
24012   return jresult;
24013 }
24014
24015
24016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
24017   void * jresult ;
24018   Dali::TapGesture *arg1 = 0 ;
24019   Dali::TapGesture *result = 0 ;
24020
24021   arg1 = (Dali::TapGesture *)jarg1;
24022   if (!arg1) {
24023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
24024     return 0;
24025   }
24026   {
24027     try {
24028       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
24029     } CALL_CATCH_EXCEPTION(0);
24030   }
24031
24032   jresult = (void *)result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
24038   void * jresult ;
24039   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24040   Dali::TapGesture *arg2 = 0 ;
24041   Dali::TapGesture *result = 0 ;
24042
24043   arg1 = (Dali::TapGesture *)jarg1;
24044   arg2 = (Dali::TapGesture *)jarg2;
24045   if (!arg2) {
24046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
24047     return 0;
24048   }
24049   {
24050     try {
24051       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
24052     } CALL_CATCH_EXCEPTION(0);
24053   }
24054
24055   jresult = (void *)result;
24056   return jresult;
24057 }
24058
24059
24060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
24061   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24062
24063   arg1 = (Dali::TapGesture *)jarg1;
24064   {
24065     try {
24066       delete arg1;
24067     } CALL_CATCH_EXCEPTION();
24068   }
24069
24070 }
24071
24072
24073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
24074   unsigned int jresult ;
24075   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24076   unsigned int result;
24077
24078   arg1 = (Dali::TapGesture *)jarg1;
24079   result = (unsigned int) ((arg1)->GetNumberOfTaps());
24080   jresult = result;
24081   return jresult;
24082 }
24083
24084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
24085   unsigned int jresult ;
24086   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24087   unsigned int result;
24088
24089   arg1 = (Dali::TapGesture *)jarg1;
24090   result = (unsigned int) ((arg1)->GetNumberOfTouches());
24091   jresult = result;
24092   return jresult;
24093 }
24094
24095
24096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
24097   void * jresult ;
24098   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24099   Dali::Vector2 result;
24100
24101   arg1 = (Dali::TapGesture *)jarg1;
24102   {
24103     try {
24104       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
24105     } catch (std::out_of_range& e) {
24106       {
24107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24108       };
24109     } catch (std::exception& e) {
24110       {
24111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24112       };
24113     } catch (Dali::DaliException e) {
24114       {
24115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24116       };
24117     } catch (...) {
24118       {
24119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24120       };
24121     }
24122   }
24123   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24124   return jresult;
24125 }
24126
24127
24128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
24129   void * jresult ;
24130   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
24131   Dali::Vector2 result;
24132
24133   arg1 = (Dali::TapGesture *)jarg1;
24134   {
24135     try {
24136       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
24137     } catch (std::out_of_range& e) {
24138       {
24139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24140       };
24141     } catch (std::exception& e) {
24142       {
24143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24144       };
24145     } catch (Dali::DaliException e) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24148       };
24149     } catch (...) {
24150       {
24151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24152       };
24153     }
24154   }
24155   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24156   return jresult;
24157 }
24158
24159
24160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
24161   void * jresult ;
24162   Dali::AlphaFunction *result = 0 ;
24163
24164   {
24165     try {
24166       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
24167     } CALL_CATCH_EXCEPTION(0);
24168   }
24169
24170   jresult = (void *)result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
24176   void * jresult ;
24177   Dali::AlphaFunction::BuiltinFunction arg1 ;
24178   Dali::AlphaFunction *result = 0 ;
24179
24180   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
24181   {
24182     try {
24183       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
24184     } CALL_CATCH_EXCEPTION(0);
24185   }
24186
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
24193   void * jresult ;
24194   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
24195   Dali::AlphaFunction *result = 0 ;
24196
24197   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
24198   {
24199     try {
24200       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
24201     } CALL_CATCH_EXCEPTION(0);
24202   }
24203
24204   jresult = (void *)result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
24210   void * jresult ;
24211   Dali::Vector2 *arg1 = 0 ;
24212   Dali::Vector2 *arg2 = 0 ;
24213   Dali::AlphaFunction *result = 0 ;
24214
24215   arg1 = (Dali::Vector2 *)jarg1;
24216   if (!arg1) {
24217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24218     return 0;
24219   }
24220   arg2 = (Dali::Vector2 *)jarg2;
24221   if (!arg2) {
24222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24223     return 0;
24224   }
24225   {
24226     try {
24227       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
24228     } CALL_CATCH_EXCEPTION(0);
24229   }
24230
24231   jresult = (void *)result;
24232   return jresult;
24233 }
24234
24235
24236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
24237   void * jresult ;
24238   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
24239   Dali::Vector4 result;
24240
24241   arg1 = (Dali::AlphaFunction *)jarg1;
24242   {
24243     try {
24244       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
24245     } CALL_CATCH_EXCEPTION(0);
24246   }
24247
24248   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
24249   return jresult;
24250 }
24251
24252
24253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
24254   void * jresult ;
24255   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
24256   Dali::AlphaFunctionPrototype result;
24257
24258   arg1 = (Dali::AlphaFunction *)jarg1;
24259   {
24260     try {
24261       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
24262     } CALL_CATCH_EXCEPTION(0);
24263   }
24264
24265   jresult = (void *)result;
24266   return jresult;
24267 }
24268
24269
24270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
24271   int jresult ;
24272   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
24273   Dali::AlphaFunction::BuiltinFunction result;
24274
24275   arg1 = (Dali::AlphaFunction *)jarg1;
24276   {
24277     try {
24278       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
24279     } CALL_CATCH_EXCEPTION(0);
24280   }
24281
24282   jresult = (int)result;
24283   return jresult;
24284 }
24285
24286
24287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
24288   int jresult ;
24289   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
24290   Dali::AlphaFunction::Mode result;
24291
24292   arg1 = (Dali::AlphaFunction *)jarg1;
24293   {
24294     try {
24295       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
24296     } CALL_CATCH_EXCEPTION(0);
24297   }
24298
24299   jresult = (int)result;
24300   return jresult;
24301 }
24302
24303
24304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
24305   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
24306
24307   arg1 = (Dali::AlphaFunction *)jarg1;
24308   {
24309     try {
24310       delete arg1;
24311     } CALL_CATCH_EXCEPTION();
24312   }
24313
24314 }
24315
24316
24317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
24318   void * jresult ;
24319   Dali::KeyFrames result;
24320
24321   {
24322     try {
24323       result = Dali::KeyFrames::New();
24324     } CALL_CATCH_EXCEPTION(0);
24325   }
24326
24327   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
24328   return jresult;
24329 }
24330
24331
24332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
24333   void * jresult ;
24334   Dali::BaseHandle arg1 ;
24335   Dali::BaseHandle *argp1 ;
24336   Dali::KeyFrames result;
24337
24338   argp1 = (Dali::BaseHandle *)jarg1;
24339   if (!argp1) {
24340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24341     return 0;
24342   }
24343   arg1 = *argp1;
24344   {
24345     try {
24346       result = Dali::KeyFrames::DownCast(arg1);
24347     } CALL_CATCH_EXCEPTION(0);
24348   }
24349
24350   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
24351   return jresult;
24352 }
24353
24354
24355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
24356   void * jresult ;
24357   Dali::KeyFrames *result = 0 ;
24358
24359   {
24360     try {
24361       result = (Dali::KeyFrames *)new Dali::KeyFrames();
24362     } CALL_CATCH_EXCEPTION(0);
24363   }
24364
24365   jresult = (void *)result;
24366   return jresult;
24367 }
24368
24369
24370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
24371   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
24372
24373   arg1 = (Dali::KeyFrames *)jarg1;
24374   {
24375     try {
24376       delete arg1;
24377     } CALL_CATCH_EXCEPTION();
24378   }
24379
24380 }
24381
24382
24383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
24384   void * jresult ;
24385   Dali::KeyFrames *arg1 = 0 ;
24386   Dali::KeyFrames *result = 0 ;
24387
24388   arg1 = (Dali::KeyFrames *)jarg1;
24389   if (!arg1) {
24390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
24391     return 0;
24392   }
24393   {
24394     try {
24395       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
24396     } CALL_CATCH_EXCEPTION(0);
24397   }
24398
24399   jresult = (void *)result;
24400   return jresult;
24401 }
24402
24403
24404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
24405   void * jresult ;
24406   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
24407   Dali::KeyFrames *arg2 = 0 ;
24408   Dali::KeyFrames *result = 0 ;
24409
24410   arg1 = (Dali::KeyFrames *)jarg1;
24411   arg2 = (Dali::KeyFrames *)jarg2;
24412   if (!arg2) {
24413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
24414     return 0;
24415   }
24416   {
24417     try {
24418       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
24419     } CALL_CATCH_EXCEPTION(0);
24420   }
24421
24422   jresult = (void *)result;
24423   return jresult;
24424 }
24425
24426
24427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
24428   int jresult ;
24429   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
24430   Dali::Property::Type result;
24431
24432   arg1 = (Dali::KeyFrames *)jarg1;
24433   {
24434     try {
24435       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
24436     } CALL_CATCH_EXCEPTION(0);
24437   }
24438
24439   jresult = (int)result;
24440   return jresult;
24441 }
24442
24443
24444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
24445   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
24446   float arg2 ;
24447   Dali::Property::Value arg3 ;
24448   Dali::Property::Value *argp3 ;
24449
24450   arg1 = (Dali::KeyFrames *)jarg1;
24451   arg2 = (float)jarg2;
24452   argp3 = (Dali::Property::Value *)jarg3;
24453   if (!argp3) {
24454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24455     return ;
24456   }
24457   arg3 = *argp3;
24458   {
24459     try {
24460       (arg1)->Add(arg2,arg3);
24461     } CALL_CATCH_EXCEPTION();
24462   }
24463
24464 }
24465
24466
24467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
24468   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
24469   float arg2 ;
24470   Dali::Property::Value arg3 ;
24471   Dali::AlphaFunction arg4 ;
24472   Dali::Property::Value *argp3 ;
24473   Dali::AlphaFunction *argp4 ;
24474
24475   arg1 = (Dali::KeyFrames *)jarg1;
24476   arg2 = (float)jarg2;
24477   argp3 = (Dali::Property::Value *)jarg3;
24478   if (!argp3) {
24479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24480     return ;
24481   }
24482   arg3 = *argp3;
24483   argp4 = (Dali::AlphaFunction *)jarg4;
24484   if (!argp4) {
24485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
24486     return ;
24487   }
24488   arg4 = *argp4;
24489   {
24490     try {
24491       (arg1)->Add(arg2,arg3,arg4);
24492     } CALL_CATCH_EXCEPTION();
24493   }
24494
24495 }
24496
24497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
24498 {
24499   return (unsigned int) Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
24500 }
24501
24502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
24503 {
24504   Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
24505 }
24506
24507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
24508   int jresult ;
24509   int result;
24510
24511   result = (int)Dali::Path::Property::POINTS;
24512   jresult = (int)result;
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
24518   int jresult ;
24519   int result;
24520
24521   result = (int)Dali::Path::Property::CONTROL_POINTS;
24522   jresult = (int)result;
24523   return jresult;
24524 }
24525
24526
24527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
24528   void * jresult ;
24529   Dali::Path::Property *result = 0 ;
24530
24531   {
24532     try {
24533       result = (Dali::Path::Property *)new Dali::Path::Property();
24534     } CALL_CATCH_EXCEPTION(0);
24535   }
24536
24537   jresult = (void *)result;
24538   return jresult;
24539 }
24540
24541
24542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
24543   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
24544
24545   arg1 = (Dali::Path::Property *)jarg1;
24546   {
24547     try {
24548       delete arg1;
24549     } CALL_CATCH_EXCEPTION();
24550   }
24551
24552 }
24553
24554
24555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
24556   void * jresult ;
24557   Dali::Path result;
24558
24559   {
24560     try {
24561       result = Dali::Path::New();
24562     } CALL_CATCH_EXCEPTION(0);
24563   }
24564
24565   jresult = new Dali::Path((const Dali::Path &)result);
24566   return jresult;
24567 }
24568
24569
24570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
24571   void * jresult ;
24572   Dali::BaseHandle arg1 ;
24573   Dali::BaseHandle *argp1 ;
24574   Dali::Path result;
24575
24576   argp1 = (Dali::BaseHandle *)jarg1;
24577   if (!argp1) {
24578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24579     return 0;
24580   }
24581   arg1 = *argp1;
24582   {
24583     try {
24584       result = Dali::Path::DownCast(arg1);
24585     } CALL_CATCH_EXCEPTION(0);
24586   }
24587
24588   jresult = new Dali::Path((const Dali::Path &)result);
24589   return jresult;
24590 }
24591
24592
24593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
24594   void * jresult ;
24595   Dali::Path *result = 0 ;
24596
24597   {
24598     try {
24599       result = (Dali::Path *)new Dali::Path();
24600     } CALL_CATCH_EXCEPTION(0);
24601   }
24602
24603   jresult = (void *)result;
24604   return jresult;
24605 }
24606
24607
24608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
24609   Dali::Path *arg1 = (Dali::Path *) 0 ;
24610
24611   arg1 = (Dali::Path *)jarg1;
24612   {
24613     try {
24614       delete arg1;
24615     } CALL_CATCH_EXCEPTION();
24616   }
24617
24618 }
24619
24620
24621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
24622   void * jresult ;
24623   Dali::Path *arg1 = 0 ;
24624   Dali::Path *result = 0 ;
24625
24626   arg1 = (Dali::Path *)jarg1;
24627   if (!arg1) {
24628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
24629     return 0;
24630   }
24631   {
24632     try {
24633       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
24634     } CALL_CATCH_EXCEPTION(0);
24635   }
24636
24637   jresult = (void *)result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
24643   void * jresult ;
24644   Dali::Path *arg1 = (Dali::Path *) 0 ;
24645   Dali::Path *arg2 = 0 ;
24646   Dali::Path *result = 0 ;
24647
24648   arg1 = (Dali::Path *)jarg1;
24649   arg2 = (Dali::Path *)jarg2;
24650   if (!arg2) {
24651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
24652     return 0;
24653   }
24654   {
24655     try {
24656       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
24657     } CALL_CATCH_EXCEPTION(0);
24658   }
24659
24660   jresult = (void *)result;
24661   return jresult;
24662 }
24663
24664
24665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
24666   Dali::Path *arg1 = (Dali::Path *) 0 ;
24667   Dali::Vector3 *arg2 = 0 ;
24668
24669   arg1 = (Dali::Path *)jarg1;
24670   arg2 = (Dali::Vector3 *)jarg2;
24671   if (!arg2) {
24672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24673     return ;
24674   }
24675   {
24676     try {
24677       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
24678     } CALL_CATCH_EXCEPTION();
24679   }
24680
24681 }
24682
24683
24684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
24685   Dali::Path *arg1 = (Dali::Path *) 0 ;
24686   Dali::Vector3 *arg2 = 0 ;
24687
24688   arg1 = (Dali::Path *)jarg1;
24689   arg2 = (Dali::Vector3 *)jarg2;
24690   if (!arg2) {
24691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24692     return ;
24693   }
24694   {
24695     try {
24696       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
24697     } CALL_CATCH_EXCEPTION();
24698   }
24699
24700 }
24701
24702
24703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
24704   Dali::Path *arg1 = (Dali::Path *) 0 ;
24705   float arg2 ;
24706
24707   arg1 = (Dali::Path *)jarg1;
24708   arg2 = (float)jarg2;
24709   {
24710     try {
24711       (arg1)->GenerateControlPoints(arg2);
24712     } CALL_CATCH_EXCEPTION();
24713   }
24714
24715 }
24716
24717
24718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
24719   Dali::Path *arg1 = (Dali::Path *) 0 ;
24720   float arg2 ;
24721   Dali::Vector3 *arg3 = 0 ;
24722   Dali::Vector3 *arg4 = 0 ;
24723
24724   arg1 = (Dali::Path *)jarg1;
24725   arg2 = (float)jarg2;
24726   arg3 = (Dali::Vector3 *)jarg3;
24727   if (!arg3) {
24728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
24729     return ;
24730   }
24731   arg4 = (Dali::Vector3 *)jarg4;
24732   if (!arg4) {
24733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
24734     return ;
24735   }
24736   {
24737     try {
24738       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
24739     } CALL_CATCH_EXCEPTION();
24740   }
24741
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
24746   void * jresult ;
24747   Dali::Path *arg1 = (Dali::Path *) 0 ;
24748   size_t arg2 ;
24749   Dali::Vector3 *result = 0 ;
24750
24751   arg1 = (Dali::Path *)jarg1;
24752   arg2 = (size_t)jarg2;
24753   {
24754     try {
24755       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
24756     } CALL_CATCH_EXCEPTION(0);
24757   }
24758
24759   jresult = (void *)result;
24760   return jresult;
24761 }
24762
24763
24764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
24765   void * jresult ;
24766   Dali::Path *arg1 = (Dali::Path *) 0 ;
24767   size_t arg2 ;
24768   Dali::Vector3 *result = 0 ;
24769
24770   arg1 = (Dali::Path *)jarg1;
24771   arg2 = (size_t)jarg2;
24772   {
24773     try {
24774       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
24775     } CALL_CATCH_EXCEPTION(0);
24776   }
24777
24778   jresult = (void *)result;
24779   return jresult;
24780 }
24781
24782
24783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
24784   unsigned long jresult ;
24785   Dali::Path *arg1 = (Dali::Path *) 0 ;
24786   size_t result;
24787
24788   arg1 = (Dali::Path *)jarg1;
24789   {
24790     try {
24791       result = ((Dali::Path const *)arg1)->GetPointCount();
24792     } CALL_CATCH_EXCEPTION(0);
24793   }
24794
24795   jresult = (unsigned long)result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
24801   void * jresult ;
24802   float arg1 ;
24803   Dali::TimePeriod *result = 0 ;
24804
24805   arg1 = (float)jarg1;
24806   {
24807     try {
24808       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
24809     } CALL_CATCH_EXCEPTION(0);
24810   }
24811
24812   jresult = (void *)result;
24813   return jresult;
24814 }
24815
24816
24817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
24818   void * jresult ;
24819   float arg1 ;
24820   float arg2 ;
24821   Dali::TimePeriod *result = 0 ;
24822
24823   arg1 = (float)jarg1;
24824   arg2 = (float)jarg2;
24825   {
24826     try {
24827       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
24828     } CALL_CATCH_EXCEPTION(0);
24829   }
24830
24831   jresult = (void *)result;
24832   return jresult;
24833 }
24834
24835
24836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
24837   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
24838
24839   arg1 = (Dali::TimePeriod *)jarg1;
24840   {
24841     try {
24842       delete arg1;
24843     } CALL_CATCH_EXCEPTION();
24844   }
24845
24846 }
24847
24848
24849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
24850   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
24851   float arg2 ;
24852
24853   arg1 = (Dali::TimePeriod *)jarg1;
24854   arg2 = (float)jarg2;
24855   if (arg1) (arg1)->delaySeconds = arg2;
24856 }
24857
24858
24859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
24860   float jresult ;
24861   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
24862   float result;
24863
24864   arg1 = (Dali::TimePeriod *)jarg1;
24865   result = (float) ((arg1)->delaySeconds);
24866   jresult = result;
24867   return jresult;
24868 }
24869
24870
24871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
24872   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
24873   float arg2 ;
24874
24875   arg1 = (Dali::TimePeriod *)jarg1;
24876   arg2 = (float)jarg2;
24877   if (arg1) (arg1)->durationSeconds = arg2;
24878 }
24879
24880
24881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
24882   float jresult ;
24883   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
24884   float result;
24885
24886   arg1 = (Dali::TimePeriod *)jarg1;
24887   result = (float) ((arg1)->durationSeconds);
24888   jresult = result;
24889   return jresult;
24890 }
24891
24892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
24893   int jresult ;
24894   int result;
24895
24896   result = (int)Dali::LinearConstrainer::Property::VALUE;
24897   jresult = (int)result;
24898   return jresult;
24899 }
24900
24901
24902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
24903   int jresult ;
24904   int result;
24905
24906   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
24907   jresult = (int)result;
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
24913   void * jresult ;
24914   Dali::LinearConstrainer::Property *result = 0 ;
24915
24916   {
24917     try {
24918       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
24919     } CALL_CATCH_EXCEPTION(0);
24920   }
24921
24922   jresult = (void *)result;
24923   return jresult;
24924 }
24925
24926
24927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
24928   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
24929
24930   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
24931   {
24932     try {
24933       delete arg1;
24934     } CALL_CATCH_EXCEPTION();
24935   }
24936
24937 }
24938
24939
24940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
24941   void * jresult ;
24942   Dali::LinearConstrainer result;
24943
24944   {
24945     try {
24946       result = Dali::LinearConstrainer::New();
24947     } CALL_CATCH_EXCEPTION(0);
24948   }
24949
24950   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
24951   return jresult;
24952 }
24953
24954
24955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
24956   void * jresult ;
24957   Dali::BaseHandle arg1 ;
24958   Dali::BaseHandle *argp1 ;
24959   Dali::LinearConstrainer result;
24960
24961   argp1 = (Dali::BaseHandle *)jarg1;
24962   if (!argp1) {
24963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24964     return 0;
24965   }
24966   arg1 = *argp1;
24967   {
24968     try {
24969       result = Dali::LinearConstrainer::DownCast(arg1);
24970     } CALL_CATCH_EXCEPTION(0);
24971   }
24972
24973   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
24974   return jresult;
24975 }
24976
24977
24978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
24979   void * jresult ;
24980   Dali::LinearConstrainer *result = 0 ;
24981
24982   {
24983     try {
24984       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
24985     } CALL_CATCH_EXCEPTION(0);
24986   }
24987
24988   jresult = (void *)result;
24989   return jresult;
24990 }
24991
24992
24993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
24994   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
24995
24996   arg1 = (Dali::LinearConstrainer *)jarg1;
24997   {
24998     try {
24999       delete arg1;
25000     } CALL_CATCH_EXCEPTION();
25001   }
25002
25003 }
25004
25005
25006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
25007   void * jresult ;
25008   Dali::LinearConstrainer *arg1 = 0 ;
25009   Dali::LinearConstrainer *result = 0 ;
25010
25011   arg1 = (Dali::LinearConstrainer *)jarg1;
25012   if (!arg1) {
25013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
25014     return 0;
25015   }
25016   {
25017     try {
25018       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
25019     } CALL_CATCH_EXCEPTION(0);
25020   }
25021
25022   jresult = (void *)result;
25023   return jresult;
25024 }
25025
25026
25027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
25028   void * jresult ;
25029   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
25030   Dali::LinearConstrainer *arg2 = 0 ;
25031   Dali::LinearConstrainer *result = 0 ;
25032
25033   arg1 = (Dali::LinearConstrainer *)jarg1;
25034   arg2 = (Dali::LinearConstrainer *)jarg2;
25035   if (!arg2) {
25036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
25037     return 0;
25038   }
25039   {
25040     try {
25041       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
25042     } CALL_CATCH_EXCEPTION(0);
25043   }
25044
25045   jresult = (void *)result;
25046   return jresult;
25047 }
25048
25049
25050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
25051   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
25052   SwigValueWrapper< Dali::Property > arg2 ;
25053   SwigValueWrapper< Dali::Property > arg3 ;
25054   Dali::Vector2 *arg4 = 0 ;
25055   Dali::Vector2 *arg5 = 0 ;
25056   Dali::Property *argp2 ;
25057   Dali::Property *argp3 ;
25058
25059   arg1 = (Dali::LinearConstrainer *)jarg1;
25060   argp2 = (Dali::Property *)jarg2;
25061   if (!argp2) {
25062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25063     return ;
25064   }
25065   arg2 = *argp2;
25066   argp3 = (Dali::Property *)jarg3;
25067   if (!argp3) {
25068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25069     return ;
25070   }
25071   arg3 = *argp3;
25072   arg4 = (Dali::Vector2 *)jarg4;
25073   if (!arg4) {
25074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25075     return ;
25076   }
25077   arg5 = (Dali::Vector2 *)jarg5;
25078   if (!arg5) {
25079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25080     return ;
25081   }
25082   {
25083     try {
25084       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
25085     } CALL_CATCH_EXCEPTION();
25086   }
25087
25088 }
25089
25090
25091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
25092   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
25093   SwigValueWrapper< Dali::Property > arg2 ;
25094   SwigValueWrapper< Dali::Property > arg3 ;
25095   Dali::Vector2 *arg4 = 0 ;
25096   Dali::Property *argp2 ;
25097   Dali::Property *argp3 ;
25098
25099   arg1 = (Dali::LinearConstrainer *)jarg1;
25100   argp2 = (Dali::Property *)jarg2;
25101   if (!argp2) {
25102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25103     return ;
25104   }
25105   arg2 = *argp2;
25106   argp3 = (Dali::Property *)jarg3;
25107   if (!argp3) {
25108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25109     return ;
25110   }
25111   arg3 = *argp3;
25112   arg4 = (Dali::Vector2 *)jarg4;
25113   if (!arg4) {
25114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25115     return ;
25116   }
25117   {
25118     try {
25119       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
25120     } CALL_CATCH_EXCEPTION();
25121   }
25122
25123 }
25124
25125
25126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
25127   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
25128   Dali::Handle *arg2 = 0 ;
25129
25130   arg1 = (Dali::LinearConstrainer *)jarg1;
25131   arg2 = (Dali::Handle *)jarg2;
25132   if (!arg2) {
25133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
25134     return ;
25135   }
25136   {
25137     try {
25138       (arg1)->Remove(*arg2);
25139     } CALL_CATCH_EXCEPTION();
25140   }
25141
25142 }
25143
25144
25145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
25146   int jresult ;
25147   int result;
25148
25149   result = (int)Dali::PathConstrainer::Property::FORWARD;
25150   jresult = (int)result;
25151   return jresult;
25152 }
25153
25154
25155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
25156   int jresult ;
25157   int result;
25158
25159   result = (int)Dali::PathConstrainer::Property::POINTS;
25160   jresult = (int)result;
25161   return jresult;
25162 }
25163
25164
25165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
25166   int jresult ;
25167   int result;
25168
25169   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
25170   jresult = (int)result;
25171   return jresult;
25172 }
25173
25174
25175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
25176   void * jresult ;
25177   Dali::PathConstrainer::Property *result = 0 ;
25178
25179   {
25180     try {
25181       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
25182     } CALL_CATCH_EXCEPTION(0);
25183   }
25184
25185   jresult = (void *)result;
25186   return jresult;
25187 }
25188
25189
25190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
25191   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
25192
25193   arg1 = (Dali::PathConstrainer::Property *)jarg1;
25194   {
25195     try {
25196       delete arg1;
25197     } CALL_CATCH_EXCEPTION();
25198   }
25199
25200 }
25201
25202
25203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
25204   void * jresult ;
25205   Dali::PathConstrainer result;
25206
25207   {
25208     try {
25209       result = Dali::PathConstrainer::New();
25210     } CALL_CATCH_EXCEPTION(0);
25211   }
25212
25213   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
25214   return jresult;
25215 }
25216
25217
25218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
25219   void * jresult ;
25220   Dali::BaseHandle arg1 ;
25221   Dali::BaseHandle *argp1 ;
25222   Dali::PathConstrainer result;
25223
25224   argp1 = (Dali::BaseHandle *)jarg1;
25225   if (!argp1) {
25226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25227     return 0;
25228   }
25229   arg1 = *argp1;
25230   {
25231     try {
25232       result = Dali::PathConstrainer::DownCast(arg1);
25233     } CALL_CATCH_EXCEPTION(0);
25234   }
25235
25236   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
25237   return jresult;
25238 }
25239
25240
25241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
25242   void * jresult ;
25243   Dali::PathConstrainer *result = 0 ;
25244
25245   {
25246     try {
25247       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
25248     } CALL_CATCH_EXCEPTION(0);
25249   }
25250
25251   jresult = (void *)result;
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
25257   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
25258
25259   arg1 = (Dali::PathConstrainer *)jarg1;
25260   {
25261     try {
25262       delete arg1;
25263     } CALL_CATCH_EXCEPTION();
25264   }
25265
25266 }
25267
25268
25269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
25270   void * jresult ;
25271   Dali::PathConstrainer *arg1 = 0 ;
25272   Dali::PathConstrainer *result = 0 ;
25273
25274   arg1 = (Dali::PathConstrainer *)jarg1;
25275   if (!arg1) {
25276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
25277     return 0;
25278   }
25279   {
25280     try {
25281       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
25282     } CALL_CATCH_EXCEPTION(0);
25283   }
25284
25285   jresult = (void *)result;
25286   return jresult;
25287 }
25288
25289
25290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
25291   void * jresult ;
25292   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
25293   Dali::PathConstrainer *arg2 = 0 ;
25294   Dali::PathConstrainer *result = 0 ;
25295
25296   arg1 = (Dali::PathConstrainer *)jarg1;
25297   arg2 = (Dali::PathConstrainer *)jarg2;
25298   if (!arg2) {
25299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
25300     return 0;
25301   }
25302   {
25303     try {
25304       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
25305     } CALL_CATCH_EXCEPTION(0);
25306   }
25307
25308   jresult = (void *)result;
25309   return jresult;
25310 }
25311
25312
25313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
25314   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
25315   SwigValueWrapper< Dali::Property > arg2 ;
25316   SwigValueWrapper< Dali::Property > arg3 ;
25317   Dali::Vector2 *arg4 = 0 ;
25318   Dali::Vector2 *arg5 = 0 ;
25319   Dali::Property *argp2 ;
25320   Dali::Property *argp3 ;
25321
25322   arg1 = (Dali::PathConstrainer *)jarg1;
25323   argp2 = (Dali::Property *)jarg2;
25324   if (!argp2) {
25325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25326     return ;
25327   }
25328   arg2 = *argp2;
25329   argp3 = (Dali::Property *)jarg3;
25330   if (!argp3) {
25331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25332     return ;
25333   }
25334   arg3 = *argp3;
25335   arg4 = (Dali::Vector2 *)jarg4;
25336   if (!arg4) {
25337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25338     return ;
25339   }
25340   arg5 = (Dali::Vector2 *)jarg5;
25341   if (!arg5) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25343     return ;
25344   }
25345   {
25346     try {
25347       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
25348     } CALL_CATCH_EXCEPTION();
25349   }
25350
25351 }
25352
25353
25354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
25355   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
25356   SwigValueWrapper< Dali::Property > arg2 ;
25357   SwigValueWrapper< Dali::Property > arg3 ;
25358   Dali::Vector2 *arg4 = 0 ;
25359   Dali::Property *argp2 ;
25360   Dali::Property *argp3 ;
25361
25362   arg1 = (Dali::PathConstrainer *)jarg1;
25363   argp2 = (Dali::Property *)jarg2;
25364   if (!argp2) {
25365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25366     return ;
25367   }
25368   arg2 = *argp2;
25369   argp3 = (Dali::Property *)jarg3;
25370   if (!argp3) {
25371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
25372     return ;
25373   }
25374   arg3 = *argp3;
25375   arg4 = (Dali::Vector2 *)jarg4;
25376   if (!arg4) {
25377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25378     return ;
25379   }
25380   {
25381     try {
25382       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
25383     } CALL_CATCH_EXCEPTION();
25384   }
25385
25386 }
25387
25388
25389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
25390   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
25391   Dali::Handle *arg2 = 0 ;
25392
25393   arg1 = (Dali::PathConstrainer *)jarg1;
25394   arg2 = (Dali::Handle *)jarg2;
25395   if (!arg2) {
25396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
25397     return ;
25398   }
25399   {
25400     try {
25401       (arg1)->Remove(*arg2);
25402     } CALL_CATCH_EXCEPTION();
25403   }
25404
25405 }
25406
25407
25408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
25409   int jresult ;
25410   Dali::FittingMode::Type result;
25411
25412   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
25413   jresult = (int)result;
25414   return jresult;
25415 }
25416
25417
25418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
25419   int jresult ;
25420   Dali::SamplingMode::Type result;
25421
25422   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
25423   jresult = (int)result;
25424   return jresult;
25425 }
25426
25427
25428 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
25429   bool jresult ;
25430   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25431   bool result;
25432
25433   arg1 = (Dali::NativeImageInterface *)jarg1;
25434   {
25435     try {
25436       result = (bool)(arg1)->CreateResource();
25437     } CALL_CATCH_EXCEPTION(0);
25438   }
25439
25440   jresult = result;
25441   return jresult;
25442 }
25443
25444
25445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
25446   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25447
25448   arg1 = (Dali::NativeImageInterface *)jarg1;
25449   {
25450     try {
25451       (arg1)->DestroyResource();
25452     } CALL_CATCH_EXCEPTION();
25453   }
25454
25455 }
25456
25457
25458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
25459   unsigned int jresult ;
25460   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25461   unsigned int result;
25462
25463   arg1 = (Dali::NativeImageInterface *)jarg1;
25464   {
25465     try {
25466       result = (unsigned int)(arg1)->TargetTexture();
25467     } CALL_CATCH_EXCEPTION(0);
25468   }
25469
25470   jresult = result;
25471   return jresult;
25472 }
25473
25474
25475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
25476   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25477
25478   arg1 = (Dali::NativeImageInterface *)jarg1;
25479   {
25480     try {
25481       (arg1)->PrepareTexture();
25482     } CALL_CATCH_EXCEPTION();
25483   }
25484
25485 }
25486
25487
25488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
25489   unsigned int jresult ;
25490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25491   unsigned int result;
25492
25493   arg1 = (Dali::NativeImageInterface *)jarg1;
25494   {
25495     try {
25496       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
25497     } CALL_CATCH_EXCEPTION(0);
25498   }
25499
25500   jresult = result;
25501   return jresult;
25502 }
25503
25504
25505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
25506   unsigned int jresult ;
25507   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25508   unsigned int result;
25509
25510   arg1 = (Dali::NativeImageInterface *)jarg1;
25511   {
25512     try {
25513       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
25514     } CALL_CATCH_EXCEPTION(0);
25515   }
25516
25517   jresult = result;
25518   return jresult;
25519 }
25520
25521
25522 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
25523   bool jresult ;
25524   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
25525   bool result;
25526
25527   arg1 = (Dali::NativeImageInterface *)jarg1;
25528   {
25529     try {
25530       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
25531     } CALL_CATCH_EXCEPTION(0);
25532   }
25533
25534   jresult = result;
25535   return jresult;
25536 }
25537
25538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
25539   int jresult ;
25540   int result;
25541
25542   result = (int)Dali::CameraActor::Property::TYPE;
25543   jresult = (int)result;
25544   return jresult;
25545 }
25546
25547
25548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
25549   int jresult ;
25550   int result;
25551
25552   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
25553   jresult = (int)result;
25554   return jresult;
25555 }
25556
25557
25558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
25559   int jresult ;
25560   int result;
25561
25562   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
25563   jresult = (int)result;
25564   return jresult;
25565 }
25566
25567
25568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
25569   int jresult ;
25570   int result;
25571
25572   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
25573   jresult = (int)result;
25574   return jresult;
25575 }
25576
25577
25578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
25579   int jresult ;
25580   int result;
25581
25582   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
25583   jresult = (int)result;
25584   return jresult;
25585 }
25586
25587
25588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
25589   int jresult ;
25590   int result;
25591
25592   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
25593   jresult = (int)result;
25594   return jresult;
25595 }
25596
25597
25598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
25599   int jresult ;
25600   int result;
25601
25602   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
25603   jresult = (int)result;
25604   return jresult;
25605 }
25606
25607
25608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
25609   int jresult ;
25610   int result;
25611
25612   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
25613   jresult = (int)result;
25614   return jresult;
25615 }
25616
25617
25618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
25619   int jresult ;
25620   int result;
25621
25622   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
25623   jresult = (int)result;
25624   return jresult;
25625 }
25626
25627
25628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
25629   int jresult ;
25630   int result;
25631
25632   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
25633   jresult = (int)result;
25634   return jresult;
25635 }
25636
25637
25638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
25639   int jresult ;
25640   int result;
25641
25642   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
25643   jresult = (int)result;
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
25649   int jresult ;
25650   int result;
25651
25652   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
25653   jresult = (int)result;
25654   return jresult;
25655 }
25656
25657
25658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
25659   int jresult ;
25660   int result;
25661
25662   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
25663   jresult = (int)result;
25664   return jresult;
25665 }
25666
25667
25668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
25669   int jresult ;
25670   int result;
25671
25672   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
25673   jresult = (int)result;
25674   return jresult;
25675 }
25676
25677
25678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
25679   int jresult ;
25680   int result;
25681
25682   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
25683   jresult = (int)result;
25684   return jresult;
25685 }
25686
25687
25688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
25689   int jresult ;
25690   int result;
25691
25692   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
25693   jresult = (int)result;
25694   return jresult;
25695 }
25696
25697
25698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
25699   void * jresult ;
25700   Dali::CameraActor::Property *result = 0 ;
25701
25702   {
25703     try {
25704       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
25705     } CALL_CATCH_EXCEPTION(0);
25706   }
25707
25708   jresult = (void *)result;
25709   return jresult;
25710 }
25711
25712
25713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
25714   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
25715
25716   arg1 = (Dali::CameraActor::Property *)jarg1;
25717   {
25718     try {
25719       delete arg1;
25720     } CALL_CATCH_EXCEPTION();
25721   }
25722
25723 }
25724
25725
25726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
25727   void * jresult ;
25728   Dali::CameraActor *result = 0 ;
25729
25730   {
25731     try {
25732       result = (Dali::CameraActor *)new Dali::CameraActor();
25733     } CALL_CATCH_EXCEPTION(0);
25734   }
25735
25736   jresult = (void *)result;
25737   return jresult;
25738 }
25739
25740
25741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
25742   void * jresult ;
25743   Dali::CameraActor result;
25744
25745   {
25746     try {
25747       result = Dali::CameraActor::New();
25748     } CALL_CATCH_EXCEPTION(0);
25749   }
25750
25751   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25752   return jresult;
25753 }
25754
25755
25756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
25757   void * jresult ;
25758   Dali::Size *arg1 = 0 ;
25759   Dali::CameraActor result;
25760
25761   arg1 = (Dali::Size *)jarg1;
25762   if (!arg1) {
25763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
25764     return 0;
25765   }
25766   {
25767     try {
25768       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
25769     } CALL_CATCH_EXCEPTION(0);
25770   }
25771
25772   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25773   return jresult;
25774 }
25775
25776
25777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
25778   void * jresult ;
25779   Dali::CameraActor result;
25780
25781   {
25782     try {
25783       result = Dali::CameraActor::New3DCamera();
25784     } CALL_CATCH_EXCEPTION(0);
25785   }
25786
25787   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25788   return jresult;
25789 }
25790
25791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
25792   void * jresult ;
25793   Dali::BaseHandle arg1 ;
25794   Dali::BaseHandle *argp1 ;
25795   Dali::CameraActor result;
25796
25797   argp1 = (Dali::BaseHandle *)jarg1;
25798   if (!argp1) {
25799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25800     return 0;
25801   }
25802   arg1 = *argp1;
25803   {
25804     try {
25805       result = Dali::CameraActor::DownCast(arg1);
25806     } CALL_CATCH_EXCEPTION(0);
25807   }
25808
25809   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25810   return jresult;
25811 }
25812
25813
25814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
25815   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25816
25817   arg1 = (Dali::CameraActor *)jarg1;
25818   {
25819     try {
25820       delete arg1;
25821     } CALL_CATCH_EXCEPTION();
25822   }
25823
25824 }
25825
25826
25827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
25828   void * jresult ;
25829   Dali::CameraActor *arg1 = 0 ;
25830   Dali::CameraActor *result = 0 ;
25831
25832   arg1 = (Dali::CameraActor *)jarg1;
25833   if (!arg1) {
25834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
25835     return 0;
25836   }
25837   {
25838     try {
25839       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
25840     } CALL_CATCH_EXCEPTION(0);
25841   }
25842
25843   jresult = (void *)result;
25844   return jresult;
25845 }
25846
25847
25848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
25849   void * jresult ;
25850   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25851   Dali::CameraActor *arg2 = 0 ;
25852   Dali::CameraActor *result = 0 ;
25853
25854   arg1 = (Dali::CameraActor *)jarg1;
25855   arg2 = (Dali::CameraActor *)jarg2;
25856   if (!arg2) {
25857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
25858     return 0;
25859   }
25860   {
25861     try {
25862       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
25863     } CALL_CATCH_EXCEPTION(0);
25864   }
25865
25866   jresult = (void *)result;
25867   return jresult;
25868 }
25869
25870
25871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
25872   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25873   Dali::Camera::Type arg2 ;
25874
25875   arg1 = (Dali::CameraActor *)jarg1;
25876   arg2 = (Dali::Camera::Type)jarg2;
25877   {
25878     try {
25879       (arg1)->SetType(arg2);
25880     } CALL_CATCH_EXCEPTION();
25881   }
25882
25883 }
25884
25885
25886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
25887   int jresult ;
25888   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25889   Dali::Camera::Type result;
25890
25891   arg1 = (Dali::CameraActor *)jarg1;
25892   {
25893     try {
25894       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
25895     } CALL_CATCH_EXCEPTION(0);
25896   }
25897
25898   jresult = (int)result;
25899   return jresult;
25900 }
25901
25902
25903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
25904   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25905   Dali::Camera::ProjectionMode arg2 ;
25906
25907   arg1 = (Dali::CameraActor *)jarg1;
25908   arg2 = (Dali::Camera::ProjectionMode)jarg2;
25909   {
25910     try {
25911       (arg1)->SetProjectionMode(arg2);
25912     } CALL_CATCH_EXCEPTION();
25913   }
25914
25915 }
25916
25917
25918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
25919   int jresult ;
25920   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25921   Dali::Camera::ProjectionMode result;
25922
25923   arg1 = (Dali::CameraActor *)jarg1;
25924   {
25925     try {
25926       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
25927     } CALL_CATCH_EXCEPTION(0);
25928   }
25929
25930   jresult = (int)result;
25931   return jresult;
25932 }
25933
25934
25935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
25936   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25937   float arg2 ;
25938
25939   arg1 = (Dali::CameraActor *)jarg1;
25940   arg2 = (float)jarg2;
25941   {
25942     try {
25943       (arg1)->SetFieldOfView(arg2);
25944     } CALL_CATCH_EXCEPTION();
25945   }
25946
25947 }
25948
25949
25950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
25951   float jresult ;
25952   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25953   float result;
25954
25955   arg1 = (Dali::CameraActor *)jarg1;
25956   {
25957     try {
25958       result = (float)(arg1)->GetFieldOfView();
25959     } CALL_CATCH_EXCEPTION(0);
25960   }
25961
25962   jresult = result;
25963   return jresult;
25964 }
25965
25966
25967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
25968   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25969   float arg2 ;
25970
25971   arg1 = (Dali::CameraActor *)jarg1;
25972   arg2 = (float)jarg2;
25973   {
25974     try {
25975       (arg1)->SetAspectRatio(arg2);
25976     } CALL_CATCH_EXCEPTION();
25977   }
25978
25979 }
25980
25981
25982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
25983   float jresult ;
25984   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
25985   float result;
25986
25987   arg1 = (Dali::CameraActor *)jarg1;
25988   {
25989     try {
25990       result = (float)(arg1)->GetAspectRatio();
25991     } CALL_CATCH_EXCEPTION(0);
25992   }
25993
25994   jresult = result;
25995   return jresult;
25996 }
25997
25998
25999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
26000   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26001   float arg2 ;
26002
26003   arg1 = (Dali::CameraActor *)jarg1;
26004   arg2 = (float)jarg2;
26005   {
26006     try {
26007       (arg1)->SetNearClippingPlane(arg2);
26008     } CALL_CATCH_EXCEPTION();
26009   }
26010
26011 }
26012
26013
26014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
26015   float jresult ;
26016   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26017   float result;
26018
26019   arg1 = (Dali::CameraActor *)jarg1;
26020   {
26021     try {
26022       result = (float)(arg1)->GetNearClippingPlane();
26023     } CALL_CATCH_EXCEPTION(0);
26024   }
26025
26026   jresult = result;
26027   return jresult;
26028 }
26029
26030
26031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
26032   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26033   float arg2 ;
26034
26035   arg1 = (Dali::CameraActor *)jarg1;
26036   arg2 = (float)jarg2;
26037   {
26038     try {
26039       (arg1)->SetFarClippingPlane(arg2);
26040     } CALL_CATCH_EXCEPTION();
26041   }
26042
26043 }
26044
26045
26046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
26047   float jresult ;
26048   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26049   float result;
26050
26051   arg1 = (Dali::CameraActor *)jarg1;
26052   {
26053     try {
26054       result = (float)(arg1)->GetFarClippingPlane();
26055     } CALL_CATCH_EXCEPTION(0);
26056   }
26057
26058   jresult = result;
26059   return jresult;
26060 }
26061
26062
26063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
26064   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26065   Dali::Vector3 *arg2 = 0 ;
26066
26067   arg1 = (Dali::CameraActor *)jarg1;
26068   arg2 = (Dali::Vector3 *)jarg2;
26069   if (!arg2) {
26070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26071     return ;
26072   }
26073   {
26074     try {
26075       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
26076     } CALL_CATCH_EXCEPTION();
26077   }
26078
26079 }
26080
26081
26082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
26083   void * jresult ;
26084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26085   Dali::Vector3 result;
26086
26087   arg1 = (Dali::CameraActor *)jarg1;
26088   {
26089     try {
26090       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
26091     } CALL_CATCH_EXCEPTION(0);
26092   }
26093
26094   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
26095   return jresult;
26096 }
26097
26098
26099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
26100   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26101   bool arg2 ;
26102
26103   arg1 = (Dali::CameraActor *)jarg1;
26104   arg2 = jarg2 ? true : false;
26105   {
26106     try {
26107       (arg1)->SetInvertYAxis(arg2);
26108     } CALL_CATCH_EXCEPTION();
26109   }
26110
26111 }
26112
26113
26114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
26115   bool jresult ;
26116   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26117   bool result;
26118
26119   arg1 = (Dali::CameraActor *)jarg1;
26120   {
26121     try {
26122       result = (bool)(arg1)->GetInvertYAxis();
26123     } CALL_CATCH_EXCEPTION(0);
26124   }
26125
26126   jresult = result;
26127   return jresult;
26128 }
26129
26130
26131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
26132   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26133   Dali::Size *arg2 = 0 ;
26134
26135   arg1 = (Dali::CameraActor *)jarg1;
26136   arg2 = (Dali::Size *)jarg2;
26137   if (!arg2) {
26138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
26139     return ;
26140   }
26141   {
26142     try {
26143       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
26144     } CALL_CATCH_EXCEPTION();
26145   }
26146
26147 }
26148
26149
26150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
26151   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
26152   Dali::Size *arg2 = 0 ;
26153
26154   arg1 = (Dali::CameraActor *)jarg1;
26155   arg2 = (Dali::Size *)jarg2;
26156   if (!arg2) {
26157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
26158     return ;
26159   }
26160   {
26161     try {
26162       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
26163     } CALL_CATCH_EXCEPTION();
26164   }
26165
26166 }
26167
26168
26169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
26170   void * jresult ;
26171   std::pair< std::string,Dali::Property::Value > *result = 0 ;
26172
26173   {
26174     try {
26175       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
26176     } CALL_CATCH_EXCEPTION(0);
26177   }
26178
26179   jresult = (void *)result;
26180   return jresult;
26181 }
26182
26183
26184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
26185   void * jresult ;
26186   std::string arg1 ;
26187   Dali::Property::Value arg2 ;
26188   Dali::Property::Value *argp2 ;
26189   std::pair< std::string,Dali::Property::Value > *result = 0 ;
26190
26191   if (!jarg1) {
26192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26193     return 0;
26194   }
26195   (&arg1)->assign(jarg1);
26196   argp2 = (Dali::Property::Value *)jarg2;
26197   if (!argp2) {
26198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26199     return 0;
26200   }
26201   arg2 = *argp2;
26202   {
26203     try {
26204       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
26205     } CALL_CATCH_EXCEPTION(0);
26206   }
26207
26208   jresult = (void *)result;
26209   return jresult;
26210 }
26211
26212
26213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
26214   void * jresult ;
26215   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
26216   std::pair< std::string,Dali::Property::Value > *result = 0 ;
26217
26218   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26219   if (!arg1) {
26220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
26221     return 0;
26222   }
26223   {
26224     try {
26225       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);
26226     } CALL_CATCH_EXCEPTION(0);
26227   }
26228
26229   jresult = (void *)result;
26230   return jresult;
26231 }
26232
26233
26234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
26235   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
26236   std::string *arg2 = 0 ;
26237
26238   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26239   if (!jarg2) {
26240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26241     return ;
26242   }
26243   std::string arg2_str(jarg2);
26244   arg2 = &arg2_str;
26245   if (arg1) (arg1)->first = *arg2;
26246
26247   //argout typemap for const std::string&
26248
26249 }
26250
26251
26252 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
26253   char * jresult ;
26254   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
26255   std::string *result = 0 ;
26256
26257   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26258   result = (std::string *) & ((arg1)->first);
26259   jresult = SWIG_csharp_string_callback(result->c_str());
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
26265   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
26266   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
26267
26268   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26269   arg2 = (Dali::Property::Value *)jarg2;
26270   if (arg1) (arg1)->second = *arg2;
26271 }
26272
26273
26274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
26275   void * jresult ;
26276   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
26277   Dali::Property::Value *result = 0 ;
26278
26279   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26280   result = (Dali::Property::Value *)& ((arg1)->second);
26281   jresult = (void *)result;
26282   return jresult;
26283 }
26284
26285
26286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
26287   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
26288
26289   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
26290   {
26291     try {
26292       delete arg1;
26293     } CALL_CATCH_EXCEPTION();
26294   }
26295
26296 }
26297
26298
26299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
26300   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26301
26302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26303   {
26304     try {
26305       (arg1)->clear();
26306     } CALL_CATCH_EXCEPTION();
26307   }
26308
26309 }
26310
26311
26312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
26313   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26314   Dali::TouchPoint *arg2 = 0 ;
26315
26316   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26317   arg2 = (Dali::TouchPoint *)jarg2;
26318   if (!arg2) {
26319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
26320     return ;
26321   }
26322   {
26323     try {
26324       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
26325     } CALL_CATCH_EXCEPTION();
26326   }
26327
26328 }
26329
26330
26331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
26332   unsigned long jresult ;
26333   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26334   std::vector< Dali::TouchPoint >::size_type result;
26335
26336   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26337   {
26338     try {
26339       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
26340     } CALL_CATCH_EXCEPTION(0);
26341   }
26342
26343   jresult = (unsigned long)result;
26344   return jresult;
26345 }
26346
26347
26348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
26349   unsigned long jresult ;
26350   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26351   std::vector< Dali::TouchPoint >::size_type result;
26352
26353   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26354   {
26355     try {
26356       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
26357     } CALL_CATCH_EXCEPTION(0);
26358   }
26359
26360   jresult = (unsigned long)result;
26361   return jresult;
26362 }
26363
26364
26365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
26366   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26367   std::vector< Dali::TouchPoint >::size_type arg2 ;
26368
26369   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26370   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
26371   {
26372     try {
26373       (arg1)->reserve(arg2);
26374     } CALL_CATCH_EXCEPTION();
26375   }
26376
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
26381   void * jresult ;
26382   std::vector< Dali::TouchPoint > *result = 0 ;
26383
26384   {
26385     try {
26386       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
26387     } CALL_CATCH_EXCEPTION(0);
26388   }
26389
26390   jresult = (void *)result;
26391   return jresult;
26392 }
26393
26394
26395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
26396   void * jresult ;
26397   std::vector< Dali::TouchPoint > *arg1 = 0 ;
26398   std::vector< Dali::TouchPoint > *result = 0 ;
26399
26400   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26401   if (!arg1) {
26402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
26403     return 0;
26404   }
26405   {
26406     try {
26407       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
26408     } CALL_CATCH_EXCEPTION(0);
26409   }
26410
26411   jresult = (void *)result;
26412   return jresult;
26413 }
26414
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
26417   void * jresult ;
26418   int arg1 ;
26419   std::vector< Dali::TouchPoint > *result = 0 ;
26420
26421   arg1 = (int)jarg1;
26422   {
26423     try {
26424       try {
26425         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
26426       }
26427       catch(std::out_of_range &_e) {
26428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26429         return 0;
26430       }
26431
26432     } CALL_CATCH_EXCEPTION(0);
26433   }
26434
26435   jresult = (void *)result;
26436   return jresult;
26437 }
26438
26439
26440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
26441   void * jresult ;
26442   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26443   int arg2 ;
26444   SwigValueWrapper< Dali::TouchPoint > result;
26445
26446   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26447   arg2 = (int)jarg2;
26448   {
26449     try {
26450       try {
26451         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
26452       }
26453       catch(std::out_of_range &_e) {
26454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26455         return 0;
26456       }
26457
26458     } CALL_CATCH_EXCEPTION(0);
26459   }
26460
26461   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
26462   return jresult;
26463 }
26464
26465
26466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
26467   void * jresult ;
26468   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26469   int arg2 ;
26470   Dali::TouchPoint *result = 0 ;
26471
26472   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26473   arg2 = (int)jarg2;
26474   {
26475     try {
26476       try {
26477         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
26478       }
26479       catch(std::out_of_range &_e) {
26480         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26481         return 0;
26482       }
26483
26484     } CALL_CATCH_EXCEPTION(0);
26485   }
26486
26487   jresult = (void *)result;
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
26493   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26494   int arg2 ;
26495   Dali::TouchPoint *arg3 = 0 ;
26496
26497   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26498   arg2 = (int)jarg2;
26499   arg3 = (Dali::TouchPoint *)jarg3;
26500   if (!arg3) {
26501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
26502     return ;
26503   }
26504   {
26505     try {
26506       try {
26507         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
26508       }
26509       catch(std::out_of_range &_e) {
26510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26511         return ;
26512       }
26513
26514     } CALL_CATCH_EXCEPTION();
26515   }
26516
26517 }
26518
26519
26520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
26521   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26522   std::vector< Dali::TouchPoint > *arg2 = 0 ;
26523
26524   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26525   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
26526   if (!arg2) {
26527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
26528     return ;
26529   }
26530   {
26531     try {
26532       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
26533     } CALL_CATCH_EXCEPTION();
26534   }
26535
26536 }
26537
26538
26539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
26540   void * jresult ;
26541   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26542   int arg2 ;
26543   int arg3 ;
26544   std::vector< Dali::TouchPoint > *result = 0 ;
26545
26546   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26547   arg2 = (int)jarg2;
26548   arg3 = (int)jarg3;
26549   {
26550     try {
26551       try {
26552         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
26553       }
26554       catch(std::out_of_range &_e) {
26555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26556         return 0;
26557       }
26558       catch(std::invalid_argument &_e) {
26559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26560         return 0;
26561       }
26562
26563     } CALL_CATCH_EXCEPTION(0);
26564   }
26565
26566   jresult = (void *)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
26572   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26573   int arg2 ;
26574   Dali::TouchPoint *arg3 = 0 ;
26575
26576   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26577   arg2 = (int)jarg2;
26578   arg3 = (Dali::TouchPoint *)jarg3;
26579   if (!arg3) {
26580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
26581     return ;
26582   }
26583   {
26584     try {
26585       try {
26586         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
26587       }
26588       catch(std::out_of_range &_e) {
26589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26590         return ;
26591       }
26592
26593     } CALL_CATCH_EXCEPTION();
26594   }
26595
26596 }
26597
26598
26599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26600   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26601   int arg2 ;
26602   std::vector< Dali::TouchPoint > *arg3 = 0 ;
26603
26604   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26605   arg2 = (int)jarg2;
26606   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
26607   if (!arg3) {
26608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
26609     return ;
26610   }
26611   {
26612     try {
26613       try {
26614         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
26615       }
26616       catch(std::out_of_range &_e) {
26617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26618         return ;
26619       }
26620
26621     } CALL_CATCH_EXCEPTION();
26622   }
26623
26624 }
26625
26626
26627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
26628   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26629   int arg2 ;
26630
26631   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26632   arg2 = (int)jarg2;
26633   {
26634     try {
26635       try {
26636         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
26637       }
26638       catch(std::out_of_range &_e) {
26639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26640         return ;
26641       }
26642
26643     } CALL_CATCH_EXCEPTION();
26644   }
26645
26646 }
26647
26648
26649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26650   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26651   int arg2 ;
26652   int arg3 ;
26653
26654   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26655   arg2 = (int)jarg2;
26656   arg3 = (int)jarg3;
26657   {
26658     try {
26659       try {
26660         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
26661       }
26662       catch(std::out_of_range &_e) {
26663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26664         return ;
26665       }
26666       catch(std::invalid_argument &_e) {
26667         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26668         return ;
26669       }
26670
26671     } CALL_CATCH_EXCEPTION();
26672   }
26673
26674 }
26675
26676
26677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
26678   void * jresult ;
26679   Dali::TouchPoint *arg1 = 0 ;
26680   int arg2 ;
26681   std::vector< Dali::TouchPoint > *result = 0 ;
26682
26683   arg1 = (Dali::TouchPoint *)jarg1;
26684   if (!arg1) {
26685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
26686     return 0;
26687   }
26688   arg2 = (int)jarg2;
26689   {
26690     try {
26691       try {
26692         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
26693       }
26694       catch(std::out_of_range &_e) {
26695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26696         return 0;
26697       }
26698
26699     } CALL_CATCH_EXCEPTION(0);
26700   }
26701
26702   jresult = (void *)result;
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
26708   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26709
26710   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26711   {
26712     try {
26713       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
26714     } CALL_CATCH_EXCEPTION();
26715   }
26716
26717 }
26718
26719
26720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26721   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26722   int arg2 ;
26723   int arg3 ;
26724
26725   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26726   arg2 = (int)jarg2;
26727   arg3 = (int)jarg3;
26728   {
26729     try {
26730       try {
26731         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26732       }
26733       catch(std::out_of_range &_e) {
26734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26735         return ;
26736       }
26737       catch(std::invalid_argument &_e) {
26738         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26739         return ;
26740       }
26741
26742     } CALL_CATCH_EXCEPTION();
26743   }
26744
26745 }
26746
26747
26748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26749   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26750   int arg2 ;
26751   std::vector< Dali::TouchPoint > *arg3 = 0 ;
26752
26753   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26754   arg2 = (int)jarg2;
26755   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
26756   if (!arg3) {
26757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
26758     return ;
26759   }
26760   {
26761     try {
26762       try {
26763         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
26764       }
26765       catch(std::out_of_range &_e) {
26766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26767         return ;
26768       }
26769
26770     } CALL_CATCH_EXCEPTION();
26771   }
26772
26773 }
26774
26775
26776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
26777   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
26778
26779   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
26780   {
26781     try {
26782       delete arg1;
26783     } CALL_CATCH_EXCEPTION();
26784   }
26785
26786 }
26787
26788
26789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
26790   void * jresult ;
26791   Dali::Rect< int > *result = 0 ;
26792
26793   {
26794     try {
26795       result = (Dali::Rect< int > *)new Dali::Rect< int >();
26796     } CALL_CATCH_EXCEPTION(0);
26797   }
26798
26799   jresult = (void *)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
26805   void * jresult ;
26806   int arg1 ;
26807   int arg2 ;
26808   int arg3 ;
26809   int arg4 ;
26810   Dali::Rect< int > *result = 0 ;
26811
26812   arg1 = (int)jarg1;
26813   arg2 = (int)jarg2;
26814   arg3 = (int)jarg3;
26815   arg4 = (int)jarg4;
26816   {
26817     try {
26818       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
26819     } CALL_CATCH_EXCEPTION(0);
26820   }
26821
26822   jresult = (void *)result;
26823   return jresult;
26824 }
26825
26826
26827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
26828   void * jresult ;
26829   Dali::Rect< int > *arg1 = 0 ;
26830   Dali::Rect< int > *result = 0 ;
26831
26832   arg1 = (Dali::Rect< int > *)jarg1;
26833   if (!arg1) {
26834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
26835     return 0;
26836   }
26837   {
26838     try {
26839       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
26840     } CALL_CATCH_EXCEPTION(0);
26841   }
26842
26843   jresult = (void *)result;
26844   return jresult;
26845 }
26846
26847
26848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
26849   void * jresult ;
26850   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26851   Dali::Rect< int > *arg2 = 0 ;
26852   Dali::Rect< int > *result = 0 ;
26853
26854   arg1 = (Dali::Rect< int > *)jarg1;
26855   arg2 = (Dali::Rect< int > *)jarg2;
26856   if (!arg2) {
26857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
26858     return 0;
26859   }
26860   {
26861     try {
26862       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
26863     } CALL_CATCH_EXCEPTION(0);
26864   }
26865
26866   jresult = (void *)result;
26867   return jresult;
26868 }
26869
26870
26871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
26872   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26873   int arg2 ;
26874   int arg3 ;
26875   int arg4 ;
26876   int arg5 ;
26877
26878   arg1 = (Dali::Rect< int > *)jarg1;
26879   arg2 = (int)jarg2;
26880   arg3 = (int)jarg3;
26881   arg4 = (int)jarg4;
26882   arg5 = (int)jarg5;
26883   {
26884     try {
26885       (arg1)->Set(arg2,arg3,arg4,arg5);
26886     } CALL_CATCH_EXCEPTION();
26887   }
26888
26889 }
26890
26891
26892 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
26893   bool jresult ;
26894   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26895   bool result;
26896
26897   arg1 = (Dali::Rect< int > *)jarg1;
26898   {
26899     try {
26900       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
26901     } CALL_CATCH_EXCEPTION(0);
26902   }
26903
26904   jresult = result;
26905   return jresult;
26906 }
26907
26908
26909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
26910   int jresult ;
26911   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26912   int result;
26913
26914   arg1 = (Dali::Rect< int > *)jarg1;
26915   {
26916     try {
26917       result = (int)((Dali::Rect< int > const *)arg1)->Left();
26918     } CALL_CATCH_EXCEPTION(0);
26919   }
26920
26921   jresult = result;
26922   return jresult;
26923 }
26924
26925
26926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
26927   int jresult ;
26928   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26929   int result;
26930
26931   arg1 = (Dali::Rect< int > *)jarg1;
26932   {
26933     try {
26934       result = (int)((Dali::Rect< int > const *)arg1)->Right();
26935     } CALL_CATCH_EXCEPTION(0);
26936   }
26937
26938   jresult = result;
26939   return jresult;
26940 }
26941
26942
26943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
26944   int jresult ;
26945   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26946   int result;
26947
26948   arg1 = (Dali::Rect< int > *)jarg1;
26949   {
26950     try {
26951       result = (int)((Dali::Rect< int > const *)arg1)->Top();
26952     } CALL_CATCH_EXCEPTION(0);
26953   }
26954
26955   jresult = result;
26956   return jresult;
26957 }
26958
26959
26960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
26961   int jresult ;
26962   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26963   int result;
26964
26965   arg1 = (Dali::Rect< int > *)jarg1;
26966   {
26967     try {
26968       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
26969     } CALL_CATCH_EXCEPTION(0);
26970   }
26971
26972   jresult = result;
26973   return jresult;
26974 }
26975
26976
26977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
26978   int jresult ;
26979   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26980   int result;
26981
26982   arg1 = (Dali::Rect< int > *)jarg1;
26983   {
26984     try {
26985       result = (int)((Dali::Rect< int > const *)arg1)->Area();
26986     } CALL_CATCH_EXCEPTION(0);
26987   }
26988
26989   jresult = result;
26990   return jresult;
26991 }
26992
26993
26994 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
26995   bool jresult ;
26996   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
26997   Dali::Rect< int > *arg2 = 0 ;
26998   bool result;
26999
27000   arg1 = (Dali::Rect< int > *)jarg1;
27001   arg2 = (Dali::Rect< int > *)jarg2;
27002   if (!arg2) {
27003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
27004     return 0;
27005   }
27006   {
27007     try {
27008       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
27009     } CALL_CATCH_EXCEPTION(0);
27010   }
27011
27012   jresult = result;
27013   return jresult;
27014 }
27015
27016
27017 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
27018   bool jresult ;
27019   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27020   Dali::Rect< int > *arg2 = 0 ;
27021   bool result;
27022
27023   arg1 = (Dali::Rect< int > *)jarg1;
27024   arg2 = (Dali::Rect< int > *)jarg2;
27025   if (!arg2) {
27026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
27027     return 0;
27028   }
27029   {
27030     try {
27031       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
27032     } CALL_CATCH_EXCEPTION(0);
27033   }
27034
27035   jresult = result;
27036   return jresult;
27037 }
27038
27039
27040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
27041   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27042   int arg2 ;
27043
27044   arg1 = (Dali::Rect< int > *)jarg1;
27045   arg2 = (int)jarg2;
27046   if (arg1) (arg1)->x = arg2;
27047 }
27048
27049
27050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
27051   int jresult ;
27052   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27053   int result;
27054
27055   arg1 = (Dali::Rect< int > *)jarg1;
27056   result = (int) ((arg1)->x);
27057   jresult = result;
27058   return jresult;
27059 }
27060
27061
27062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
27063   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27064   int arg2 ;
27065
27066   arg1 = (Dali::Rect< int > *)jarg1;
27067   arg2 = (int)jarg2;
27068   if (arg1) (arg1)->left = arg2;
27069 }
27070
27071
27072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
27073   int jresult ;
27074   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27075   int result;
27076
27077   arg1 = (Dali::Rect< int > *)jarg1;
27078   result = (int) ((arg1)->left);
27079   jresult = result;
27080   return jresult;
27081 }
27082
27083
27084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
27085   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27086   int arg2 ;
27087
27088   arg1 = (Dali::Rect< int > *)jarg1;
27089   arg2 = (int)jarg2;
27090   if (arg1) (arg1)->y = arg2;
27091 }
27092
27093
27094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
27095   int jresult ;
27096   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27097   int result;
27098
27099   arg1 = (Dali::Rect< int > *)jarg1;
27100   result = (int) ((arg1)->y);
27101   jresult = result;
27102   return jresult;
27103 }
27104
27105
27106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
27107   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27108   int arg2 ;
27109
27110   arg1 = (Dali::Rect< int > *)jarg1;
27111   arg2 = (int)jarg2;
27112   if (arg1) (arg1)->right = arg2;
27113 }
27114
27115
27116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
27117   int jresult ;
27118   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27119   int result;
27120
27121   arg1 = (Dali::Rect< int > *)jarg1;
27122   result = (int) ((arg1)->right);
27123   jresult = result;
27124   return jresult;
27125 }
27126
27127
27128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
27129   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27130   int arg2 ;
27131
27132   arg1 = (Dali::Rect< int > *)jarg1;
27133   arg2 = (int)jarg2;
27134   if (arg1) (arg1)->width = arg2;
27135 }
27136
27137
27138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
27139   int jresult ;
27140   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27141   int result;
27142
27143   arg1 = (Dali::Rect< int > *)jarg1;
27144   result = (int) ((arg1)->width);
27145   jresult = result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
27151   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27152   int arg2 ;
27153
27154   arg1 = (Dali::Rect< int > *)jarg1;
27155   arg2 = (int)jarg2;
27156   if (arg1) (arg1)->bottom = arg2;
27157 }
27158
27159
27160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
27161   int jresult ;
27162   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27163   int result;
27164
27165   arg1 = (Dali::Rect< int > *)jarg1;
27166   result = (int) ((arg1)->bottom);
27167   jresult = result;
27168   return jresult;
27169 }
27170
27171
27172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
27173   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27174   int arg2 ;
27175
27176   arg1 = (Dali::Rect< int > *)jarg1;
27177   arg2 = (int)jarg2;
27178   if (arg1) (arg1)->height = arg2;
27179 }
27180
27181
27182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
27183   int jresult ;
27184   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27185   int result;
27186
27187   arg1 = (Dali::Rect< int > *)jarg1;
27188   result = (int) ((arg1)->height);
27189   jresult = result;
27190   return jresult;
27191 }
27192
27193
27194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
27195   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27196   int arg2 ;
27197
27198   arg1 = (Dali::Rect< int > *)jarg1;
27199   arg2 = (int)jarg2;
27200   if (arg1) (arg1)->top = arg2;
27201 }
27202
27203
27204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
27205   int jresult ;
27206   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27207   int result;
27208
27209   arg1 = (Dali::Rect< int > *)jarg1;
27210   result = (int) ((arg1)->top);
27211   jresult = result;
27212   return jresult;
27213 }
27214
27215
27216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
27217   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
27218
27219   arg1 = (Dali::Rect< int > *)jarg1;
27220   {
27221     try {
27222       delete arg1;
27223     } CALL_CATCH_EXCEPTION();
27224   }
27225
27226 }
27227
27228
27229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
27230   void * jresult ;
27231   Dali::Rect< float > *result = 0 ;
27232
27233   {
27234     try {
27235       result = (Dali::Rect< float > *)new Dali::Rect< float >();
27236     } CALL_CATCH_EXCEPTION(0);
27237   }
27238
27239   jresult = (void *)result;
27240   return jresult;
27241 }
27242
27243
27244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
27245   void * jresult ;
27246   float arg1 ;
27247   float arg2 ;
27248   float arg3 ;
27249   float arg4 ;
27250   Dali::Rect< float > *result = 0 ;
27251
27252   arg1 = (float)jarg1;
27253   arg2 = (float)jarg2;
27254   arg3 = (float)jarg4;
27255   arg4 = (float)jarg3;
27256   {
27257     try {
27258       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
27259     } CALL_CATCH_EXCEPTION(0);
27260   }
27261
27262   jresult = (void *)result;
27263   return jresult;
27264 }
27265
27266
27267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
27268   void * jresult ;
27269   Dali::Rect< float > *arg1 = 0 ;
27270   Dali::Rect< float > *result = 0 ;
27271
27272   arg1 = (Dali::Rect< float > *)jarg1;
27273   if (!arg1) {
27274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
27275     return 0;
27276   }
27277   {
27278     try {
27279       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
27280     } CALL_CATCH_EXCEPTION(0);
27281   }
27282
27283   jresult = (void *)result;
27284   return jresult;
27285 }
27286
27287
27288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
27289   void * jresult ;
27290   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27291   Dali::Rect< float > *arg2 = 0 ;
27292   Dali::Rect< float > *result = 0 ;
27293
27294   arg1 = (Dali::Rect< float > *)jarg1;
27295   arg2 = (Dali::Rect< float > *)jarg2;
27296   if (!arg2) {
27297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
27298     return 0;
27299   }
27300   {
27301     try {
27302       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
27303     } CALL_CATCH_EXCEPTION(0);
27304   }
27305
27306   jresult = (void *)result;
27307   return jresult;
27308 }
27309
27310
27311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
27312   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27313   float arg2 ;
27314   float arg3 ;
27315   float arg4 ;
27316   float arg5 ;
27317
27318   arg1 = (Dali::Rect< float > *)jarg1;
27319   arg2 = (float)jarg2;
27320   arg3 = (float)jarg3;
27321   arg4 = (float)jarg5;
27322   arg5 = (float)jarg4;
27323   {
27324     try {
27325       (arg1)->Set(arg2,arg3,arg4,arg5);
27326     } CALL_CATCH_EXCEPTION();
27327   }
27328
27329 }
27330
27331
27332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
27333   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27334   float arg2 ;
27335
27336   arg1 = (Dali::Rect< float > *)jarg1;
27337   arg2 = (float)jarg2;
27338   if (arg1) (arg1)->left = arg2;
27339 }
27340
27341
27342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
27343   float jresult ;
27344   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27345   float result;
27346
27347   arg1 = (Dali::Rect< float > *)jarg1;
27348   result = (float) ((arg1)->left);
27349   jresult = result;
27350   return jresult;
27351 }
27352
27353
27354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
27355   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27356   float arg2 ;
27357
27358   arg1 = (Dali::Rect< float > *)jarg1;
27359   arg2 = (float)jarg2;
27360   if (arg1) (arg1)->left = arg2;
27361 }
27362
27363
27364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
27365   float jresult ;
27366   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27367   float result;
27368
27369   arg1 = (Dali::Rect< float > *)jarg1;
27370   result = (float) ((arg1)->left);
27371   jresult = result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
27377   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27378   float arg2 ;
27379
27380   arg1 = (Dali::Rect< float > *)jarg1;
27381   arg2 = (float)jarg2;
27382   if (arg1) (arg1)->right = arg2;
27383 }
27384
27385
27386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
27387   float jresult ;
27388   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27389   float result;
27390
27391   arg1 = (Dali::Rect< float > *)jarg1;
27392   result = (float) ((arg1)->right);
27393   jresult = result;
27394   return jresult;
27395 }
27396
27397
27398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
27399   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27400   float arg2 ;
27401
27402   arg1 = (Dali::Rect< float > *)jarg1;
27403   arg2 = (float)jarg2;
27404   if (arg1) (arg1)->right = arg2;
27405 }
27406
27407
27408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
27409   float jresult ;
27410   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27411   float result;
27412
27413   arg1 = (Dali::Rect< float > *)jarg1;
27414   result = (float) ((arg1)->right);
27415   jresult = result;
27416   return jresult;
27417 }
27418
27419
27420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
27421   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27422   float arg2 ;
27423
27424   arg1 = (Dali::Rect< float > *)jarg1;
27425   arg2 = (float)jarg2;
27426   if (arg1) (arg1)->bottom = arg2;
27427 }
27428
27429
27430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
27431   float jresult ;
27432   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27433   float result;
27434
27435   arg1 = (Dali::Rect< float > *)jarg1;
27436   result = (float) ((arg1)->bottom);
27437   jresult = result;
27438   return jresult;
27439 }
27440
27441
27442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
27443   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27444   float arg2 ;
27445
27446   arg1 = (Dali::Rect< float > *)jarg1;
27447   arg2 = (float)jarg2;
27448   if (arg1) (arg1)->top = arg2;
27449 }
27450
27451
27452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
27453   float jresult ;
27454   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27455   float result;
27456
27457   arg1 = (Dali::Rect< float > *)jarg1;
27458   result = (float) ((arg1)->top);
27459   jresult = result;
27460   return jresult;
27461 }
27462
27463
27464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
27465   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
27466
27467   arg1 = (Dali::Rect< float > *)jarg1;
27468   {
27469     try {
27470       delete arg1;
27471     } CALL_CATCH_EXCEPTION();
27472   }
27473
27474 }
27475
27476
27477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
27478   int jresult ;
27479   int result;
27480
27481   result = (int)Dali::Vector< int >::BaseType;
27482   jresult = (int)result;
27483   return jresult;
27484 }
27485
27486
27487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
27488   void * jresult ;
27489   Dali::Vector< int > *result = 0 ;
27490
27491   {
27492     try {
27493       result = (Dali::Vector< int > *)new Dali::Vector< int >();
27494     } CALL_CATCH_EXCEPTION(0);
27495   }
27496
27497   jresult = (void *)result;
27498   return jresult;
27499 }
27500
27501
27502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
27503   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27504
27505   arg1 = (Dali::Vector< int > *)jarg1;
27506   {
27507     try {
27508       delete arg1;
27509     } CALL_CATCH_EXCEPTION();
27510   }
27511
27512 }
27513
27514
27515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
27516   void * jresult ;
27517   Dali::Vector< int > *arg1 = 0 ;
27518   Dali::Vector< int > *result = 0 ;
27519
27520   arg1 = (Dali::Vector< int > *)jarg1;
27521   if (!arg1) {
27522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
27523     return 0;
27524   }
27525   {
27526     try {
27527       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
27528     } CALL_CATCH_EXCEPTION(0);
27529   }
27530
27531   jresult = (void *)result;
27532   return jresult;
27533 }
27534
27535
27536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
27537   void * jresult ;
27538   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27539   Dali::Vector< int > *arg2 = 0 ;
27540   Dali::Vector< int > *result = 0 ;
27541
27542   arg1 = (Dali::Vector< int > *)jarg1;
27543   arg2 = (Dali::Vector< int > *)jarg2;
27544   if (!arg2) {
27545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
27546     return 0;
27547   }
27548   {
27549     try {
27550       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
27551     } CALL_CATCH_EXCEPTION(0);
27552   }
27553
27554   jresult = (void *)result;
27555   return jresult;
27556 }
27557
27558
27559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
27560   void * jresult ;
27561   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27562   Dali::Vector< int >::Iterator result;
27563
27564   arg1 = (Dali::Vector< int > *)jarg1;
27565   {
27566     try {
27567       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
27568     } CALL_CATCH_EXCEPTION(0);
27569   }
27570
27571   jresult = (void *)result;
27572   return jresult;
27573 }
27574
27575
27576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
27577   void * jresult ;
27578   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27579   Dali::Vector< int >::Iterator result;
27580
27581   arg1 = (Dali::Vector< int > *)jarg1;
27582   {
27583     try {
27584       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
27585     } CALL_CATCH_EXCEPTION(0);
27586   }
27587
27588   jresult = (void *)result;
27589   return jresult;
27590 }
27591
27592
27593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
27594   void * jresult ;
27595   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27596   Dali::Vector< int >::SizeType arg2 ;
27597   Dali::Vector< int >::ItemType *result = 0 ;
27598
27599   arg1 = (Dali::Vector< int > *)jarg1;
27600   arg2 = (Dali::Vector< int >::SizeType)jarg2;
27601   {
27602     try {
27603       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
27604     } CALL_CATCH_EXCEPTION(0);
27605   }
27606
27607   jresult = (void *)result;
27608   return jresult;
27609 }
27610
27611
27612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
27613   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27614   Dali::Vector< int >::ItemType *arg2 = 0 ;
27615   Dali::Vector< int >::ItemType temp2 ;
27616
27617   arg1 = (Dali::Vector< int > *)jarg1;
27618   temp2 = (Dali::Vector< int >::ItemType)jarg2;
27619   arg2 = &temp2;
27620   {
27621     try {
27622       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
27623     } CALL_CATCH_EXCEPTION();
27624   }
27625
27626 }
27627
27628
27629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
27630   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27631   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
27632   Dali::Vector< int >::ItemType *arg3 = 0 ;
27633   Dali::Vector< int >::ItemType temp3 ;
27634
27635   arg1 = (Dali::Vector< int > *)jarg1;
27636   arg2 = (Dali::Vector< int >::Iterator)jarg2;
27637   temp3 = (Dali::Vector< int >::ItemType)jarg3;
27638   arg3 = &temp3;
27639   {
27640     try {
27641       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
27642     } CALL_CATCH_EXCEPTION();
27643   }
27644
27645 }
27646
27647
27648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27649   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27650   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
27651   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
27652   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
27653
27654   arg1 = (Dali::Vector< int > *)jarg1;
27655   arg2 = (Dali::Vector< int >::Iterator)jarg2;
27656   arg3 = (Dali::Vector< int >::Iterator)jarg3;
27657   arg4 = (Dali::Vector< int >::Iterator)jarg4;
27658   {
27659     try {
27660       (arg1)->Insert(arg2,arg3,arg4);
27661     } CALL_CATCH_EXCEPTION();
27662   }
27663
27664 }
27665
27666
27667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
27668   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27669   Dali::Vector< int >::SizeType arg2 ;
27670
27671   arg1 = (Dali::Vector< int > *)jarg1;
27672   arg2 = (Dali::Vector< int >::SizeType)jarg2;
27673   {
27674     try {
27675       (arg1)->Reserve(arg2);
27676     } CALL_CATCH_EXCEPTION();
27677   }
27678
27679 }
27680
27681
27682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
27683   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27684   Dali::Vector< int >::SizeType arg2 ;
27685
27686   arg1 = (Dali::Vector< int > *)jarg1;
27687   arg2 = (Dali::Vector< int >::SizeType)jarg2;
27688   {
27689     try {
27690       (arg1)->Resize(arg2);
27691     } CALL_CATCH_EXCEPTION();
27692   }
27693
27694 }
27695
27696
27697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
27698   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27699   Dali::Vector< int >::SizeType arg2 ;
27700   Dali::Vector< int >::ItemType *arg3 = 0 ;
27701   Dali::Vector< int >::ItemType temp3 ;
27702
27703   arg1 = (Dali::Vector< int > *)jarg1;
27704   arg2 = (Dali::Vector< int >::SizeType)jarg2;
27705   temp3 = (Dali::Vector< int >::ItemType)jarg3;
27706   arg3 = &temp3;
27707   {
27708     try {
27709       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
27710     } CALL_CATCH_EXCEPTION();
27711   }
27712
27713 }
27714
27715
27716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
27717   void * jresult ;
27718   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27719   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
27720   Dali::Vector< int >::Iterator result;
27721
27722   arg1 = (Dali::Vector< int > *)jarg1;
27723   arg2 = (Dali::Vector< int >::Iterator)jarg2;
27724   {
27725     try {
27726       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
27727     } CALL_CATCH_EXCEPTION(0);
27728   }
27729
27730   jresult = (void *)result;
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
27736   void * jresult ;
27737   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27738   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
27739   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
27740   Dali::Vector< int >::Iterator result;
27741
27742   arg1 = (Dali::Vector< int > *)jarg1;
27743   arg2 = (Dali::Vector< int >::Iterator)jarg2;
27744   arg3 = (Dali::Vector< int >::Iterator)jarg3;
27745   {
27746     try {
27747       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
27748     } CALL_CATCH_EXCEPTION(0);
27749   }
27750
27751   jresult = (void *)result;
27752   return jresult;
27753 }
27754
27755
27756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
27757   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27758   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
27759
27760   arg1 = (Dali::Vector< int > *)jarg1;
27761   arg2 = (Dali::Vector< int >::Iterator)jarg2;
27762   {
27763     try {
27764       (arg1)->Remove(arg2);
27765     } CALL_CATCH_EXCEPTION();
27766   }
27767
27768 }
27769
27770
27771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
27772   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27773   Dali::Vector< int > *arg2 = 0 ;
27774
27775   arg1 = (Dali::Vector< int > *)jarg1;
27776   arg2 = (Dali::Vector< int > *)jarg2;
27777   if (!arg2) {
27778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
27779     return ;
27780   }
27781   {
27782     try {
27783       (arg1)->Swap(*arg2);
27784     } CALL_CATCH_EXCEPTION();
27785   }
27786
27787 }
27788
27789
27790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
27791   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27792
27793   arg1 = (Dali::Vector< int > *)jarg1;
27794   {
27795     try {
27796       (arg1)->Clear();
27797     } CALL_CATCH_EXCEPTION();
27798   }
27799
27800 }
27801
27802
27803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
27804   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
27805
27806   arg1 = (Dali::Vector< int > *)jarg1;
27807   {
27808     try {
27809       (arg1)->Release();
27810     } CALL_CATCH_EXCEPTION();
27811   }
27812
27813 }
27814
27815
27816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
27817   int jresult ;
27818   int result;
27819
27820   result = (int)Dali::Vector< float >::BaseType;
27821   jresult = (int)result;
27822   return jresult;
27823 }
27824
27825
27826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
27827   void * jresult ;
27828   Dali::Vector< float > *result = 0 ;
27829
27830   {
27831     try {
27832       result = (Dali::Vector< float > *)new Dali::Vector< float >();
27833     } CALL_CATCH_EXCEPTION(0);
27834   }
27835
27836   jresult = (void *)result;
27837   return jresult;
27838 }
27839
27840
27841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
27842   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27843
27844   arg1 = (Dali::Vector< float > *)jarg1;
27845   {
27846     try {
27847       delete arg1;
27848     } CALL_CATCH_EXCEPTION();
27849   }
27850
27851 }
27852
27853
27854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
27855   void * jresult ;
27856   Dali::Vector< float > *arg1 = 0 ;
27857   Dali::Vector< float > *result = 0 ;
27858
27859   arg1 = (Dali::Vector< float > *)jarg1;
27860   if (!arg1) {
27861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
27862     return 0;
27863   }
27864   {
27865     try {
27866       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
27867     } CALL_CATCH_EXCEPTION(0);
27868   }
27869
27870   jresult = (void *)result;
27871   return jresult;
27872 }
27873
27874
27875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
27876   void * jresult ;
27877   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27878   Dali::Vector< float > *arg2 = 0 ;
27879   Dali::Vector< float > *result = 0 ;
27880
27881   arg1 = (Dali::Vector< float > *)jarg1;
27882   arg2 = (Dali::Vector< float > *)jarg2;
27883   if (!arg2) {
27884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
27885     return 0;
27886   }
27887   {
27888     try {
27889       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
27890     } CALL_CATCH_EXCEPTION(0);
27891   }
27892
27893   jresult = (void *)result;
27894   return jresult;
27895 }
27896
27897
27898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
27899   void * jresult ;
27900   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27901   Dali::Vector< float >::Iterator result;
27902
27903   arg1 = (Dali::Vector< float > *)jarg1;
27904   {
27905     try {
27906       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
27907     } CALL_CATCH_EXCEPTION(0);
27908   }
27909
27910   jresult = (void *)result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
27916   void * jresult ;
27917   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27918   Dali::Vector< float >::Iterator result;
27919
27920   arg1 = (Dali::Vector< float > *)jarg1;
27921   {
27922     try {
27923       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
27924     } CALL_CATCH_EXCEPTION(0);
27925   }
27926
27927   jresult = (void *)result;
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
27933   void * jresult ;
27934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27935   Dali::Vector< float >::SizeType arg2 ;
27936   Dali::Vector< float >::ItemType *result = 0 ;
27937
27938   arg1 = (Dali::Vector< float > *)jarg1;
27939   arg2 = (Dali::Vector< float >::SizeType)jarg2;
27940   {
27941     try {
27942       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
27943     } CALL_CATCH_EXCEPTION(0);
27944   }
27945
27946   jresult = (void *)result;
27947   return jresult;
27948 }
27949
27950
27951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
27952   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27953   Dali::Vector< float >::ItemType *arg2 = 0 ;
27954   Dali::Vector< float >::ItemType temp2 ;
27955
27956   arg1 = (Dali::Vector< float > *)jarg1;
27957   temp2 = (Dali::Vector< float >::ItemType)jarg2;
27958   arg2 = &temp2;
27959   {
27960     try {
27961       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
27962     } CALL_CATCH_EXCEPTION();
27963   }
27964
27965 }
27966
27967
27968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
27969   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27970   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
27971   Dali::Vector< float >::ItemType *arg3 = 0 ;
27972   Dali::Vector< float >::ItemType temp3 ;
27973
27974   arg1 = (Dali::Vector< float > *)jarg1;
27975   arg2 = (Dali::Vector< float >::Iterator)jarg2;
27976   temp3 = (Dali::Vector< float >::ItemType)jarg3;
27977   arg3 = &temp3;
27978   {
27979     try {
27980       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
27981     } CALL_CATCH_EXCEPTION();
27982   }
27983
27984 }
27985
27986
27987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27988   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
27989   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
27990   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
27991   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
27992
27993   arg1 = (Dali::Vector< float > *)jarg1;
27994   arg2 = (Dali::Vector< float >::Iterator)jarg2;
27995   arg3 = (Dali::Vector< float >::Iterator)jarg3;
27996   arg4 = (Dali::Vector< float >::Iterator)jarg4;
27997   {
27998     try {
27999       (arg1)->Insert(arg2,arg3,arg4);
28000     } CALL_CATCH_EXCEPTION();
28001   }
28002
28003 }
28004
28005
28006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
28007   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28008   Dali::Vector< float >::SizeType arg2 ;
28009
28010   arg1 = (Dali::Vector< float > *)jarg1;
28011   arg2 = (Dali::Vector< float >::SizeType)jarg2;
28012   {
28013     try {
28014       (arg1)->Reserve(arg2);
28015     } CALL_CATCH_EXCEPTION();
28016   }
28017
28018 }
28019
28020 //// ========================= end of part 2 =============================
28021
28022 //// ========================== start part 3 ===============================
28023
28024
28025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
28026   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28027   Dali::Vector< float >::SizeType arg2 ;
28028
28029   arg1 = (Dali::Vector< float > *)jarg1;
28030   arg2 = (Dali::Vector< float >::SizeType)jarg2;
28031   {
28032     try {
28033       (arg1)->Resize(arg2);
28034     } CALL_CATCH_EXCEPTION();
28035   }
28036
28037 }
28038
28039
28040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
28041   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28042   Dali::Vector< float >::SizeType arg2 ;
28043   Dali::Vector< float >::ItemType *arg3 = 0 ;
28044   Dali::Vector< float >::ItemType temp3 ;
28045
28046   arg1 = (Dali::Vector< float > *)jarg1;
28047   arg2 = (Dali::Vector< float >::SizeType)jarg2;
28048   temp3 = (Dali::Vector< float >::ItemType)jarg3;
28049   arg3 = &temp3;
28050   {
28051     try {
28052       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
28053     } CALL_CATCH_EXCEPTION();
28054   }
28055
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
28060   void * jresult ;
28061   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28062   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
28063   Dali::Vector< float >::Iterator result;
28064
28065   arg1 = (Dali::Vector< float > *)jarg1;
28066   arg2 = (Dali::Vector< float >::Iterator)jarg2;
28067   {
28068     try {
28069       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
28070     } CALL_CATCH_EXCEPTION(0);
28071   }
28072
28073   jresult = (void *)result;
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
28079   void * jresult ;
28080   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28081   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
28082   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
28083   Dali::Vector< float >::Iterator result;
28084
28085   arg1 = (Dali::Vector< float > *)jarg1;
28086   arg2 = (Dali::Vector< float >::Iterator)jarg2;
28087   arg3 = (Dali::Vector< float >::Iterator)jarg3;
28088   {
28089     try {
28090       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
28091     } CALL_CATCH_EXCEPTION(0);
28092   }
28093
28094   jresult = (void *)result;
28095   return jresult;
28096 }
28097
28098
28099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
28100   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28101   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
28102
28103   arg1 = (Dali::Vector< float > *)jarg1;
28104   arg2 = (Dali::Vector< float >::Iterator)jarg2;
28105   {
28106     try {
28107       (arg1)->Remove(arg2);
28108     } CALL_CATCH_EXCEPTION();
28109   }
28110
28111 }
28112
28113
28114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
28115   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28116   Dali::Vector< float > *arg2 = 0 ;
28117
28118   arg1 = (Dali::Vector< float > *)jarg1;
28119   arg2 = (Dali::Vector< float > *)jarg2;
28120   if (!arg2) {
28121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
28122     return ;
28123   }
28124   {
28125     try {
28126       (arg1)->Swap(*arg2);
28127     } CALL_CATCH_EXCEPTION();
28128   }
28129
28130 }
28131
28132
28133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
28134   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28135
28136   arg1 = (Dali::Vector< float > *)jarg1;
28137   {
28138     try {
28139       (arg1)->Clear();
28140     } CALL_CATCH_EXCEPTION();
28141   }
28142
28143 }
28144
28145
28146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
28147   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
28148
28149   arg1 = (Dali::Vector< float > *)jarg1;
28150   {
28151     try {
28152       (arg1)->Release();
28153     } CALL_CATCH_EXCEPTION();
28154   }
28155
28156 }
28157
28158
28159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
28160   int jresult ;
28161   int result;
28162
28163   result = (int)Dali::Vector< unsigned char >::BaseType;
28164   jresult = (int)result;
28165   return jresult;
28166 }
28167
28168
28169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
28170   void * jresult ;
28171   Dali::Vector< unsigned char > *result = 0 ;
28172
28173   {
28174     try {
28175       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
28176     } CALL_CATCH_EXCEPTION(0);
28177   }
28178
28179   jresult = (void *)result;
28180   return jresult;
28181 }
28182
28183
28184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
28185   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28186
28187   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28188   {
28189     try {
28190       delete arg1;
28191     } CALL_CATCH_EXCEPTION();
28192   }
28193
28194 }
28195
28196
28197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
28198   void * jresult ;
28199   Dali::Vector< unsigned char > *arg1 = 0 ;
28200   Dali::Vector< unsigned char > *result = 0 ;
28201
28202   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28203   if (!arg1) {
28204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
28205     return 0;
28206   }
28207   {
28208     try {
28209       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
28210     } CALL_CATCH_EXCEPTION(0);
28211   }
28212
28213   jresult = (void *)result;
28214   return jresult;
28215 }
28216
28217
28218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
28219   void * jresult ;
28220   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28221   Dali::Vector< unsigned char > *arg2 = 0 ;
28222   Dali::Vector< unsigned char > *result = 0 ;
28223
28224   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28225   arg2 = (Dali::Vector< unsigned char > *)jarg2;
28226   if (!arg2) {
28227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
28228     return 0;
28229   }
28230   {
28231     try {
28232       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
28233     } CALL_CATCH_EXCEPTION(0);
28234   }
28235
28236   jresult = (void *)result;
28237   return jresult;
28238 }
28239
28240
28241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
28242   void * jresult ;
28243   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28244   Dali::Vector< unsigned char >::Iterator result;
28245
28246   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28247   {
28248     try {
28249       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
28250     } CALL_CATCH_EXCEPTION(0);
28251   }
28252
28253   jresult = (void *)result;
28254   return jresult;
28255 }
28256
28257
28258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
28259   void * jresult ;
28260   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28261   Dali::Vector< unsigned char >::Iterator result;
28262
28263   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28264   {
28265     try {
28266       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
28267     } CALL_CATCH_EXCEPTION(0);
28268   }
28269
28270   jresult = (void *)result;
28271   return jresult;
28272 }
28273
28274
28275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
28276   void * jresult ;
28277   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28278   Dali::Vector< unsigned char >::SizeType arg2 ;
28279   Dali::Vector< unsigned char >::ItemType *result = 0 ;
28280
28281   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28282   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
28283   {
28284     try {
28285       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
28286     } CALL_CATCH_EXCEPTION(0);
28287   }
28288
28289   jresult = (void *)result;
28290   return jresult;
28291 }
28292
28293
28294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
28295   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28296   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
28297   Dali::Vector< unsigned char >::ItemType temp2 ;
28298
28299   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28300   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
28301   arg2 = &temp2;
28302   {
28303     try {
28304       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
28305     } CALL_CATCH_EXCEPTION();
28306   }
28307
28308 }
28309
28310
28311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
28312   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28313   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28314   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
28315   Dali::Vector< unsigned char >::ItemType temp3 ;
28316
28317   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28318   arg2 = jarg2;
28319   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
28320   arg3 = &temp3;
28321   {
28322     try {
28323       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
28324     } CALL_CATCH_EXCEPTION();
28325   }
28326
28327
28328
28329 }
28330
28331
28332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
28333   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28334   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28335   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28336   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28337
28338   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28339   arg2 = jarg2;
28340   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
28341   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
28342   {
28343     try {
28344       (arg1)->Insert(arg2,arg3,arg4);
28345     } CALL_CATCH_EXCEPTION();
28346   }
28347
28348
28349
28350 }
28351
28352
28353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
28354   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28355   Dali::Vector< unsigned char >::SizeType arg2 ;
28356
28357   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28358   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
28359   {
28360     try {
28361       (arg1)->Reserve(arg2);
28362     } CALL_CATCH_EXCEPTION();
28363   }
28364
28365 }
28366
28367
28368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
28369   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28370   Dali::Vector< unsigned char >::SizeType arg2 ;
28371
28372   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28373   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
28374   {
28375     try {
28376       (arg1)->Resize(arg2);
28377     } CALL_CATCH_EXCEPTION();
28378   }
28379
28380 }
28381
28382
28383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
28384   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28385   Dali::Vector< unsigned char >::SizeType arg2 ;
28386   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
28387   Dali::Vector< unsigned char >::ItemType temp3 ;
28388
28389   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28390   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
28391   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
28392   arg3 = &temp3;
28393   {
28394     try {
28395       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
28396     } CALL_CATCH_EXCEPTION();
28397   }
28398
28399 }
28400
28401
28402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
28403   void * jresult ;
28404   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28405   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28406   Dali::Vector< unsigned char >::Iterator result;
28407
28408   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28409   arg2 = jarg2;
28410   {
28411     try {
28412       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
28413     } CALL_CATCH_EXCEPTION(0);
28414   }
28415
28416   jresult = (void *)result;
28417
28418
28419   return jresult;
28420 }
28421
28422
28423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
28424   void * jresult ;
28425   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28426   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28427   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28428   Dali::Vector< unsigned char >::Iterator result;
28429
28430   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28431   arg2 = jarg2;
28432   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
28433   {
28434     try {
28435       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
28436     } CALL_CATCH_EXCEPTION(0);
28437   }
28438
28439   jresult = (void *)result;
28440
28441
28442   return jresult;
28443 }
28444
28445
28446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
28447   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28448   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
28449
28450   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28451   arg2 = jarg2;
28452   {
28453     try {
28454       (arg1)->Remove(arg2);
28455     } CALL_CATCH_EXCEPTION();
28456   }
28457
28458
28459
28460 }
28461
28462
28463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
28464   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28465   Dali::Vector< unsigned char > *arg2 = 0 ;
28466
28467   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28468   arg2 = (Dali::Vector< unsigned char > *)jarg2;
28469   if (!arg2) {
28470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
28471     return ;
28472   }
28473   {
28474     try {
28475       (arg1)->Swap(*arg2);
28476     } CALL_CATCH_EXCEPTION();
28477   }
28478
28479 }
28480
28481
28482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
28483   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28484
28485   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28486   {
28487     try {
28488       (arg1)->Clear();
28489     } CALL_CATCH_EXCEPTION();
28490   }
28491
28492 }
28493
28494
28495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
28496   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
28497
28498   arg1 = (Dali::Vector< unsigned char > *)jarg1;
28499   {
28500     try {
28501       (arg1)->Release();
28502     } CALL_CATCH_EXCEPTION();
28503   }
28504
28505 }
28506
28507
28508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
28509   int jresult ;
28510   int result;
28511
28512   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
28513   jresult = (int)result;
28514   return jresult;
28515 }
28516
28517
28518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
28519   void * jresult ;
28520   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
28521
28522   {
28523     try {
28524       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
28525     } CALL_CATCH_EXCEPTION(0);
28526   }
28527
28528   jresult = (void *)result;
28529   return jresult;
28530 }
28531
28532
28533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
28534   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28535
28536   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28537   {
28538     try {
28539       delete arg1;
28540     } CALL_CATCH_EXCEPTION();
28541   }
28542
28543 }
28544
28545
28546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
28547   void * jresult ;
28548   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
28549   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
28550
28551   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28552   if (!arg1) {
28553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
28554     return 0;
28555   }
28556   {
28557     try {
28558       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
28559     } CALL_CATCH_EXCEPTION(0);
28560   }
28561
28562   jresult = (void *)result;
28563   return jresult;
28564 }
28565
28566
28567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
28568   void * jresult ;
28569   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28570   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
28571   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
28572
28573   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28574   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
28575   if (!arg2) {
28576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
28577     return 0;
28578   }
28579   {
28580     try {
28581       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
28582     } CALL_CATCH_EXCEPTION(0);
28583   }
28584
28585   jresult = (void *)result;
28586   return jresult;
28587 }
28588
28589
28590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
28591   void * jresult ;
28592   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28593   Dali::Vector< Dali::Uint16Pair >::Iterator result;
28594
28595   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28596   {
28597     try {
28598       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
28599     } CALL_CATCH_EXCEPTION(0);
28600   }
28601
28602   jresult = (void *)result;
28603   return jresult;
28604 }
28605
28606
28607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
28608   void * jresult ;
28609   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28610   Dali::Vector< Dali::Uint16Pair >::Iterator result;
28611
28612   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28613   {
28614     try {
28615       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
28616     } CALL_CATCH_EXCEPTION(0);
28617   }
28618
28619   jresult = (void *)result;
28620   return jresult;
28621 }
28622
28623
28624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
28625   void * jresult ;
28626   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28627   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
28628   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
28629
28630   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28631   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
28632   {
28633     try {
28634       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
28635     } CALL_CATCH_EXCEPTION(0);
28636   }
28637
28638   jresult = (void *)result;
28639   return jresult;
28640 }
28641
28642
28643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
28644   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28645   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
28646
28647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28648   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
28649   if (!arg2) {
28650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
28651     return ;
28652   }
28653   {
28654     try {
28655       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
28656     } CALL_CATCH_EXCEPTION();
28657   }
28658
28659 }
28660
28661
28662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
28663   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28664   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28665   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
28666
28667   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28668   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
28669   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
28670   if (!arg3) {
28671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
28672     return ;
28673   }
28674   {
28675     try {
28676       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
28677     } CALL_CATCH_EXCEPTION();
28678   }
28679
28680 }
28681
28682
28683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
28684   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28685   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28686   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28687   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28688
28689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28690   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
28691   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
28692   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
28693   {
28694     try {
28695       (arg1)->Insert(arg2,arg3,arg4);
28696     } CALL_CATCH_EXCEPTION();
28697   }
28698
28699 }
28700
28701
28702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
28703   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28704   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
28705
28706   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28707   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
28708   {
28709     try {
28710       (arg1)->Reserve(arg2);
28711     } CALL_CATCH_EXCEPTION();
28712   }
28713
28714 }
28715
28716
28717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
28718   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28719   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
28720
28721   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28722   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
28723   {
28724     try {
28725       (arg1)->Resize(arg2);
28726     } CALL_CATCH_EXCEPTION();
28727   }
28728
28729 }
28730
28731
28732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
28733   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28734   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
28735   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
28736
28737   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28738   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
28739   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
28740   if (!arg3) {
28741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
28742     return ;
28743   }
28744   {
28745     try {
28746       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
28747     } CALL_CATCH_EXCEPTION();
28748   }
28749
28750 }
28751
28752
28753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
28754   void * jresult ;
28755   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28756   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28757   Dali::Vector< Dali::Uint16Pair >::Iterator result;
28758
28759   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28760   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
28761   {
28762     try {
28763       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
28764     } CALL_CATCH_EXCEPTION(0);
28765   }
28766
28767   jresult = (void *)result;
28768   return jresult;
28769 }
28770
28771
28772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
28773   void * jresult ;
28774   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28775   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28776   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28777   Dali::Vector< Dali::Uint16Pair >::Iterator result;
28778
28779   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28780   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
28781   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
28782   {
28783     try {
28784       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
28785     } CALL_CATCH_EXCEPTION(0);
28786   }
28787
28788   jresult = (void *)result;
28789   return jresult;
28790 }
28791
28792
28793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
28794   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28795   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
28796
28797   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28798   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
28799   {
28800     try {
28801       (arg1)->Remove(arg2);
28802     } CALL_CATCH_EXCEPTION();
28803   }
28804
28805 }
28806
28807
28808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
28809   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28810   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
28811
28812   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28813   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
28814   if (!arg2) {
28815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
28816     return ;
28817   }
28818   {
28819     try {
28820       (arg1)->Swap(*arg2);
28821     } CALL_CATCH_EXCEPTION();
28822   }
28823
28824 }
28825
28826
28827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
28828   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28829
28830   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28831   {
28832     try {
28833       (arg1)->Clear();
28834     } CALL_CATCH_EXCEPTION();
28835   }
28836
28837 }
28838
28839
28840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
28841   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
28842
28843   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
28844   {
28845     try {
28846       (arg1)->Release();
28847     } CALL_CATCH_EXCEPTION();
28848   }
28849
28850 }
28851
28852
28853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
28854   void * jresult ;
28855   Dali::Signal< void () > *result = 0 ;
28856
28857   {
28858     try {
28859       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
28860     } CALL_CATCH_EXCEPTION(0);
28861   }
28862
28863   jresult = (void *)result;
28864   return jresult;
28865 }
28866
28867
28868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
28869   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28870
28871   arg1 = (Dali::Signal< void () > *)jarg1;
28872   {
28873     try {
28874       delete arg1;
28875     } CALL_CATCH_EXCEPTION();
28876   }
28877
28878 }
28879
28880
28881 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
28882   bool jresult ;
28883   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28884   bool result;
28885
28886   arg1 = (Dali::Signal< void () > *)jarg1;
28887   {
28888     try {
28889       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
28890     } CALL_CATCH_EXCEPTION(0);
28891   }
28892
28893   jresult = result;
28894   return jresult;
28895 }
28896
28897
28898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
28899   unsigned long jresult ;
28900   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28901   std::size_t result;
28902
28903   arg1 = (Dali::Signal< void () > *)jarg1;
28904   {
28905     try {
28906       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
28907     } CALL_CATCH_EXCEPTION(0);
28908   }
28909
28910   jresult = (unsigned long)result;
28911   return jresult;
28912 }
28913
28914
28915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
28916   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28917   void (*arg2)() = (void (*)()) 0 ;
28918
28919   arg1 = (Dali::Signal< void () > *)jarg1;
28920   arg2 = (void (*)())jarg2;
28921   {
28922     try {
28923       (arg1)->Connect(arg2);
28924     } CALL_CATCH_EXCEPTION();
28925   }
28926
28927 }
28928
28929
28930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
28931   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28932   void (*arg2)() = (void (*)()) 0 ;
28933
28934   arg1 = (Dali::Signal< void () > *)jarg1;
28935   arg2 = (void (*)())jarg2;
28936   {
28937     try {
28938       (arg1)->Disconnect(arg2);
28939     } CALL_CATCH_EXCEPTION();
28940   }
28941
28942 }
28943
28944
28945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
28946   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28947   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
28948   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
28949
28950   arg1 = (Dali::Signal< void () > *)jarg1;
28951   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
28952   arg3 = (Dali::FunctorDelegate *)jarg3;
28953   {
28954     try {
28955       (arg1)->Connect(arg2,arg3);
28956     } CALL_CATCH_EXCEPTION();
28957   }
28958
28959 }
28960
28961
28962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
28963   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
28964
28965   arg1 = (Dali::Signal< void () > *)jarg1;
28966   {
28967     try {
28968       (arg1)->Emit();
28969     } CALL_CATCH_EXCEPTION();
28970   }
28971
28972 }
28973
28974
28975 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
28976   bool jresult ;
28977   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
28978   bool result;
28979
28980   arg1 = (Dali::Signal< void (float) > *)jarg1;
28981   {
28982     try {
28983       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
28984     } CALL_CATCH_EXCEPTION(0);
28985   }
28986
28987   jresult = result;
28988   return jresult;
28989 }
28990
28991
28992 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
28993   unsigned long jresult ;
28994   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
28995   std::size_t result;
28996
28997   arg1 = (Dali::Signal< void (float) > *)jarg1;
28998   {
28999     try {
29000       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
29001     } CALL_CATCH_EXCEPTION(0);
29002   }
29003
29004   jresult = (unsigned long)result;
29005   return jresult;
29006 }
29007
29008
29009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
29010   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
29011   void (*arg2)(float) = (void (*)(float)) 0 ;
29012
29013   arg1 = (Dali::Signal< void (float) > *)jarg1;
29014   arg2 = (void (*)(float))jarg2;
29015   {
29016     try {
29017       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
29018     } CALL_CATCH_EXCEPTION();
29019   }
29020
29021 }
29022
29023
29024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
29025   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
29026   void (*arg2)(float) = (void (*)(float)) 0 ;
29027
29028   arg1 = (Dali::Signal< void (float) > *)jarg1;
29029   arg2 = (void (*)(float))jarg2;
29030   {
29031     try {
29032       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
29033     } CALL_CATCH_EXCEPTION();
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
29040   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
29041   float arg2 ;
29042
29043   arg1 = (Dali::Signal< void (float) > *)jarg1;
29044   arg2 = (float)jarg2;
29045   {
29046     try {
29047       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
29048     } CALL_CATCH_EXCEPTION();
29049   }
29050
29051 }
29052
29053
29054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
29055   void * jresult ;
29056   Dali::Signal< void (float) > *result = 0 ;
29057
29058   {
29059     try {
29060       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
29061     } CALL_CATCH_EXCEPTION(0);
29062   }
29063
29064   jresult = (void *)result;
29065   return jresult;
29066 }
29067
29068
29069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
29070   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
29071
29072   arg1 = (Dali::Signal< void (float) > *)jarg1;
29073   {
29074     try {
29075       delete arg1;
29076     } CALL_CATCH_EXCEPTION();
29077   }
29078
29079 }
29080
29081
29082 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
29083   bool jresult ;
29084   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29085   bool result;
29086
29087   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29088   {
29089     try {
29090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
29091     } CALL_CATCH_EXCEPTION(0);
29092   }
29093
29094   jresult = result;
29095   return jresult;
29096 }
29097
29098
29099 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
29100   unsigned long jresult ;
29101   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29102   std::size_t result;
29103
29104   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29105   {
29106     try {
29107       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
29108     } CALL_CATCH_EXCEPTION(0);
29109   }
29110
29111   jresult = (unsigned long)result;
29112   return jresult;
29113 }
29114
29115
29116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
29117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29118   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
29119
29120   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29121   arg2 = (void (*)(Dali::BaseHandle))jarg2;
29122   {
29123     try {
29124       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
29125     } CALL_CATCH_EXCEPTION();
29126   }
29127
29128 }
29129
29130
29131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
29132   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29133   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
29134
29135   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29136   arg2 = (void (*)(Dali::BaseHandle))jarg2;
29137   {
29138     try {
29139       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
29140     } CALL_CATCH_EXCEPTION();
29141   }
29142
29143 }
29144
29145
29146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
29147   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29148   Dali::BaseHandle arg2 ;
29149   Dali::BaseHandle *argp2 ;
29150
29151   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29152   argp2 = (Dali::BaseHandle *)jarg2;
29153   if (!argp2) {
29154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29155     return ;
29156   }
29157   arg2 = *argp2;
29158   {
29159     try {
29160       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
29161     } CALL_CATCH_EXCEPTION();
29162   }
29163
29164 }
29165
29166
29167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
29168   void * jresult ;
29169   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
29170
29171   {
29172     try {
29173       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
29174     } CALL_CATCH_EXCEPTION(0);
29175   }
29176
29177   jresult = (void *)result;
29178   return jresult;
29179 }
29180
29181
29182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
29183   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
29184
29185   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
29186   {
29187     try {
29188       delete arg1;
29189     } CALL_CATCH_EXCEPTION();
29190   }
29191
29192 }
29193
29194
29195 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
29196   bool jresult ;
29197   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29198   bool result;
29199
29200   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29201   {
29202     try {
29203       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
29204     } CALL_CATCH_EXCEPTION(0);
29205   }
29206
29207   jresult = result;
29208   return jresult;
29209 }
29210
29211
29212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
29213   unsigned long jresult ;
29214   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29215   std::size_t result;
29216
29217   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29218   {
29219     try {
29220       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
29221     } CALL_CATCH_EXCEPTION(0);
29222   }
29223
29224   jresult = (unsigned long)result;
29225   return jresult;
29226 }
29227
29228
29229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
29230   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29231   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
29232
29233   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29234   arg2 = (void (*)(Dali::RefObject const *))jarg2;
29235   {
29236     try {
29237       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
29238     } CALL_CATCH_EXCEPTION();
29239   }
29240
29241 }
29242
29243
29244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
29245   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29246   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
29247
29248   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29249   arg2 = (void (*)(Dali::RefObject const *))jarg2;
29250   {
29251     try {
29252       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
29253     } CALL_CATCH_EXCEPTION();
29254   }
29255
29256 }
29257
29258
29259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
29260   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29261   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
29262
29263   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29264   arg2 = (Dali::RefObject *)jarg2;
29265   {
29266     try {
29267       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
29268     } CALL_CATCH_EXCEPTION();
29269   }
29270
29271 }
29272
29273
29274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
29275   void * jresult ;
29276   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
29277
29278   {
29279     try {
29280       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
29281     } CALL_CATCH_EXCEPTION(0);
29282   }
29283
29284   jresult = (void *)result;
29285   return jresult;
29286 }
29287
29288
29289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
29290   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
29291
29292   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
29293   {
29294     try {
29295       delete arg1;
29296     } CALL_CATCH_EXCEPTION();
29297   }
29298
29299 }
29300
29301
29302 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
29303   bool jresult ;
29304   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29305   bool result;
29306
29307   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29308   {
29309     try {
29310       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
29311     } CALL_CATCH_EXCEPTION(0);
29312   }
29313
29314   jresult = result;
29315   return jresult;
29316 }
29317
29318
29319 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
29320   unsigned long jresult ;
29321   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29322   std::size_t result;
29323
29324   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29325   {
29326     try {
29327       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
29328     } CALL_CATCH_EXCEPTION(0);
29329   }
29330
29331   jresult = (unsigned long)result;
29332   return jresult;
29333 }
29334
29335
29336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
29337   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29338   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
29339
29340   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29341   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
29342   {
29343     try {
29344       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
29345     } CALL_CATCH_EXCEPTION();
29346   }
29347
29348 }
29349
29350
29351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
29352   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29353   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
29354
29355   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29356   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
29357   {
29358     try {
29359       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
29360     } CALL_CATCH_EXCEPTION();
29361   }
29362
29363 }
29364
29365
29366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
29367   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29368   Dali::PropertyNotification *arg2 = 0 ;
29369
29370   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29371   arg2 = (Dali::PropertyNotification *)jarg2;
29372   if (!arg2) {
29373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
29374     return ;
29375   }
29376   {
29377     try {
29378       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
29379     } CALL_CATCH_EXCEPTION();
29380   }
29381
29382 }
29383
29384
29385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
29386   void * jresult ;
29387   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
29388
29389   {
29390     try {
29391       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
29392     } CALL_CATCH_EXCEPTION(0);
29393   }
29394
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
29401   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
29402
29403   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
29404   {
29405     try {
29406       delete arg1;
29407     } CALL_CATCH_EXCEPTION();
29408   }
29409
29410 }
29411
29412
29413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
29414   void * jresult ;
29415   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
29416
29417   {
29418     try {
29419       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
29420     } CALL_CATCH_EXCEPTION(0);
29421   }
29422
29423   jresult = (void *)result;
29424   return jresult;
29425 }
29426
29427
29428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
29429   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
29430
29431   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
29432   {
29433     try {
29434       delete arg1;
29435     } CALL_CATCH_EXCEPTION();
29436   }
29437
29438 }
29439
29440
29441 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
29442   bool jresult ;
29443   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29444   bool result;
29445
29446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29447   {
29448     try {
29449       result = (bool)Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
29450     } CALL_CATCH_EXCEPTION(0);
29451   }
29452
29453   jresult = result;
29454   return jresult;
29455 }
29456
29457
29458 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
29459   unsigned long jresult ;
29460   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29461   std::size_t result;
29462
29463   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29464   {
29465     try {
29466       result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
29467     } CALL_CATCH_EXCEPTION(0);
29468   }
29469
29470   jresult = (unsigned long)result;
29471   return jresult;
29472 }
29473
29474
29475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
29476   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29477   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
29478
29479   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29480   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
29481   {
29482     try {
29483       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
29484     } CALL_CATCH_EXCEPTION();
29485   }
29486
29487 }
29488
29489
29490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
29491   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29492   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
29493
29494   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29495   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
29496   {
29497     try {
29498       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
29499     } CALL_CATCH_EXCEPTION();
29500   }
29501
29502 }
29503
29504
29505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
29506   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29507   Dali::Actor arg2 ;
29508   Dali::LongPressGesture *arg3 = 0 ;
29509   Dali::Actor *argp2 ;
29510
29511   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29512   argp2 = (Dali::Actor *)jarg2;
29513   if (!argp2) {
29514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29515     return ;
29516   }
29517   arg2 = *argp2;
29518   arg3 = (Dali::LongPressGesture *)jarg3;
29519   if (!arg3) {
29520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
29521     return ;
29522   }
29523   {
29524     try {
29525       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
29526     } CALL_CATCH_EXCEPTION();
29527   }
29528
29529 }
29530
29531
29532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
29533   void * jresult ;
29534   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
29535
29536   {
29537     try {
29538       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
29539     } CALL_CATCH_EXCEPTION(0);
29540   }
29541
29542   jresult = (void *)result;
29543   return jresult;
29544 }
29545
29546
29547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
29548   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
29549
29550   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
29551   {
29552     try {
29553       delete arg1;
29554     } CALL_CATCH_EXCEPTION();
29555   }
29556
29557 }
29558
29559
29560 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
29561   bool jresult ;
29562   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29563   bool result;
29564
29565   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29566   {
29567     try {
29568       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
29569     } CALL_CATCH_EXCEPTION(0);
29570   }
29571
29572   jresult = result;
29573   return jresult;
29574 }
29575
29576
29577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
29578   unsigned long jresult ;
29579   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29580   std::size_t result;
29581
29582   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29583   {
29584     try {
29585       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
29586     } CALL_CATCH_EXCEPTION(0);
29587   }
29588
29589   jresult = (unsigned long)result;
29590   return jresult;
29591 }
29592
29593
29594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
29595   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29596   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
29597
29598   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29599   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
29600   {
29601     try {
29602       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
29603     } CALL_CATCH_EXCEPTION();
29604   }
29605
29606 }
29607
29608
29609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
29610   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29611   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
29612
29613   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29614   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
29615   {
29616     try {
29617       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
29618     } CALL_CATCH_EXCEPTION();
29619   }
29620
29621 }
29622
29623
29624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
29625   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29626   Dali::KeyEvent *arg2 = 0 ;
29627
29628   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29629   arg2 = (Dali::KeyEvent *)jarg2;
29630   if (!arg2) {
29631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
29632     return ;
29633   }
29634   {
29635     try {
29636       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
29637     } CALL_CATCH_EXCEPTION();
29638   }
29639
29640 }
29641
29642
29643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
29644   void * jresult ;
29645   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
29646
29647   {
29648     try {
29649       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
29650     } CALL_CATCH_EXCEPTION(0);
29651   }
29652
29653   jresult = (void *)result;
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
29659   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
29660
29661   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
29662   {
29663     try {
29664       delete arg1;
29665     } CALL_CATCH_EXCEPTION();
29666   }
29667
29668 }
29669
29670 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
29671   bool jresult ;
29672   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29673   bool result;
29674
29675   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29676   {
29677     try {
29678       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
29679     } CALL_CATCH_EXCEPTION(0);
29680   }
29681
29682   jresult = result;
29683   return jresult;
29684 }
29685
29686
29687 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
29688   unsigned long jresult ;
29689   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29690   std::size_t result;
29691
29692   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29693   {
29694     try {
29695       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
29696     } CALL_CATCH_EXCEPTION(0);
29697   }
29698
29699   jresult = (unsigned long)result;
29700   return jresult;
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
29705   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29706   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
29707
29708   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29709   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
29710   {
29711     try {
29712       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
29713     } CALL_CATCH_EXCEPTION();
29714   }
29715
29716 }
29717
29718
29719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
29720   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29721   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
29722
29723   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29724   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
29725   {
29726     try {
29727       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
29728     } CALL_CATCH_EXCEPTION();
29729   }
29730
29731 }
29732
29733
29734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
29735   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29736   Dali::WheelEvent *arg2 = 0 ;
29737
29738   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29739   arg2 = (Dali::WheelEvent *)jarg2;
29740   if (!arg2) {
29741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
29742     return ;
29743   }
29744   {
29745     try {
29746       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
29747     } CALL_CATCH_EXCEPTION();
29748   }
29749
29750 }
29751
29752
29753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
29754   void * jresult ;
29755   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
29756
29757   {
29758     try {
29759       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
29760     } CALL_CATCH_EXCEPTION(0);
29761   }
29762
29763   jresult = (void *)result;
29764   return jresult;
29765 }
29766
29767
29768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
29769   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
29770
29771   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
29772   {
29773     try {
29774       delete arg1;
29775     } CALL_CATCH_EXCEPTION();
29776   }
29777
29778 }
29779
29780
29781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
29782   void * jresult ;
29783   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
29784
29785   {
29786     try {
29787       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
29788     } CALL_CATCH_EXCEPTION(0);
29789   }
29790
29791   jresult = (void *)result;
29792   return jresult;
29793 }
29794
29795
29796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
29797   void * jresult ;
29798   Dali::Radian arg1 ;
29799   Dali::Radian arg2 ;
29800   Dali::Radian *argp1 ;
29801   Dali::Radian *argp2 ;
29802   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
29803
29804   argp1 = (Dali::Radian *)jarg1;
29805   if (!argp1) {
29806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
29807     return 0;
29808   }
29809   arg1 = *argp1;
29810   argp2 = (Dali::Radian *)jarg2;
29811   if (!argp2) {
29812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
29813     return 0;
29814   }
29815   arg2 = *argp2;
29816   {
29817     try {
29818       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
29819     } CALL_CATCH_EXCEPTION(0);
29820   }
29821
29822   jresult = (void *)result;
29823   return jresult;
29824 }
29825
29826
29827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
29828   void * jresult ;
29829   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
29830   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
29831
29832   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29833   if (!arg1) {
29834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
29835     return 0;
29836   }
29837   {
29838     try {
29839       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
29840     } CALL_CATCH_EXCEPTION(0);
29841   }
29842
29843   jresult = (void *)result;
29844   return jresult;
29845 }
29846
29847
29848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
29849   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
29850   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
29851
29852   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29853   arg2 = (Dali::Radian *)jarg2;
29854   if (arg1) (arg1)->first = *arg2;
29855 }
29856
29857
29858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
29859   void * jresult ;
29860   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
29861   Dali::Radian *result = 0 ;
29862
29863   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29864   result = (Dali::Radian *)& ((arg1)->first);
29865   jresult = (void *)result;
29866   return jresult;
29867 }
29868
29869
29870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
29871   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
29872   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
29873
29874   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29875   arg2 = (Dali::Radian *)jarg2;
29876   if (arg1) (arg1)->second = *arg2;
29877 }
29878
29879
29880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
29881   void * jresult ;
29882   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
29883   Dali::Radian *result = 0 ;
29884
29885   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29886   result = (Dali::Radian *)& ((arg1)->second);
29887   jresult = (void *)result;
29888   return jresult;
29889 }
29890
29891
29892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
29893   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
29894
29895   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
29896   {
29897     try {
29898       delete arg1;
29899     } CALL_CATCH_EXCEPTION();
29900   }
29901
29902 }
29903
29904
29905 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
29906   bool jresult ;
29907   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
29908   bool result;
29909
29910   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
29911   {
29912     try {
29913       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);
29914     } CALL_CATCH_EXCEPTION(0);
29915   }
29916
29917   jresult = result;
29918   return jresult;
29919 }
29920
29921
29922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
29923   unsigned long jresult ;
29924   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
29925   std::size_t result;
29926
29927   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
29928   {
29929     try {
29930       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);
29931     } CALL_CATCH_EXCEPTION(0);
29932   }
29933
29934   jresult = (unsigned long)result;
29935   return jresult;
29936 }
29937
29938
29939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
29940   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
29941   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
29942
29943   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
29944   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
29945   {
29946     try {
29947       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
29948     } CALL_CATCH_EXCEPTION();
29949   }
29950
29951 }
29952
29953
29954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
29955   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
29956   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
29957
29958   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
29959   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
29960   {
29961     try {
29962       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
29963     } CALL_CATCH_EXCEPTION();
29964   }
29965
29966 }
29967
29968
29969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
29970   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
29971   Dali::Actor arg2 ;
29972   Dali::PanGesture *arg3 = 0 ;
29973   Dali::Actor *argp2 ;
29974
29975   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
29976   argp2 = (Dali::Actor *)jarg2;
29977   if (!argp2) {
29978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29979     return ;
29980   }
29981   arg2 = *argp2;
29982   arg3 = (Dali::PanGesture *)jarg3;
29983   if (!arg3) {
29984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
29985     return ;
29986   }
29987   {
29988     try {
29989       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
29990     } CALL_CATCH_EXCEPTION();
29991   }
29992
29993 }
29994
29995
29996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
29997   void * jresult ;
29998   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
29999
30000   {
30001     try {
30002       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
30003     } CALL_CATCH_EXCEPTION(0);
30004   }
30005
30006   jresult = (void *)result;
30007   return jresult;
30008 }
30009
30010
30011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
30012   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
30013
30014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
30015   {
30016     try {
30017       delete arg1;
30018     } CALL_CATCH_EXCEPTION();
30019   }
30020
30021 }
30022
30023
30024 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
30025   bool jresult ;
30026   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30027   bool result;
30028
30029   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30030   {
30031     try {
30032       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);
30033     } CALL_CATCH_EXCEPTION(0);
30034   }
30035
30036   jresult = result;
30037   return jresult;
30038 }
30039
30040
30041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
30042   unsigned long jresult ;
30043   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30044   std::size_t result;
30045
30046   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30047   {
30048     try {
30049       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);
30050     } CALL_CATCH_EXCEPTION(0);
30051   }
30052
30053   jresult = (unsigned long)result;
30054   return jresult;
30055 }
30056
30057
30058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
30059   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30060   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
30061
30062   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30063   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
30064   {
30065     try {
30066       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
30067     } CALL_CATCH_EXCEPTION();
30068   }
30069
30070 }
30071
30072
30073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
30074   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30075   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
30076
30077   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30078   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
30079   {
30080     try {
30081       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
30082     } CALL_CATCH_EXCEPTION();
30083   }
30084
30085 }
30086
30087
30088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
30089   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30090   Dali::Actor arg2 ;
30091   Dali::PinchGesture *arg3 = 0 ;
30092   Dali::Actor *argp2 ;
30093
30094   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30095   argp2 = (Dali::Actor *)jarg2;
30096   if (!argp2) {
30097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30098     return ;
30099   }
30100   arg2 = *argp2;
30101   arg3 = (Dali::PinchGesture *)jarg3;
30102   if (!arg3) {
30103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
30104     return ;
30105   }
30106   {
30107     try {
30108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
30109     } CALL_CATCH_EXCEPTION();
30110   }
30111
30112 }
30113
30114
30115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
30116   void * jresult ;
30117   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
30118
30119   {
30120     try {
30121       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
30122     } CALL_CATCH_EXCEPTION(0);
30123   }
30124
30125   jresult = (void *)result;
30126   return jresult;
30127 }
30128
30129
30130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
30131   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
30132
30133   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
30134   {
30135     try {
30136       delete arg1;
30137     } CALL_CATCH_EXCEPTION();
30138   }
30139
30140 }
30141
30142
30143 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
30144   bool jresult ;
30145   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30146   bool result;
30147
30148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30149   {
30150     try {
30151       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);
30152     } CALL_CATCH_EXCEPTION(0);
30153   }
30154
30155   jresult = result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
30161   unsigned long jresult ;
30162   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30163   std::size_t result;
30164
30165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30166   {
30167     try {
30168       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);
30169     } CALL_CATCH_EXCEPTION(0);
30170   }
30171
30172   jresult = (unsigned long)result;
30173   return jresult;
30174 }
30175
30176
30177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
30178   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30179   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
30180
30181   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30182   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
30183   {
30184     try {
30185       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
30186     } CALL_CATCH_EXCEPTION();
30187   }
30188
30189 }
30190
30191
30192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
30193   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30194   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
30195
30196   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30197   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
30198   {
30199     try {
30200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
30201     } CALL_CATCH_EXCEPTION();
30202   }
30203
30204 }
30205
30206
30207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
30208   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30209   Dali::Actor arg2 ;
30210   Dali::TapGesture *arg3 = 0 ;
30211   Dali::Actor *argp2 ;
30212
30213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30214   argp2 = (Dali::Actor *)jarg2;
30215   if (!argp2) {
30216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30217     return ;
30218   }
30219   arg2 = *argp2;
30220   arg3 = (Dali::TapGesture *)jarg3;
30221   if (!arg3) {
30222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
30223     return ;
30224   }
30225   {
30226     try {
30227       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
30228     } CALL_CATCH_EXCEPTION();
30229   }
30230
30231 }
30232
30233
30234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
30235   void * jresult ;
30236   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
30237
30238   {
30239     try {
30240       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
30241     } CALL_CATCH_EXCEPTION(0);
30242   }
30243
30244   jresult = (void *)result;
30245   return jresult;
30246 }
30247
30248
30249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
30250   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
30251
30252   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
30253   {
30254     try {
30255       delete arg1;
30256     } CALL_CATCH_EXCEPTION();
30257   }
30258
30259 }
30260
30261 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
30262   unsigned long jresult ;
30263   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
30264   std::size_t result = 0;
30265
30266   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
30267   {
30268     try {
30269       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);
30270     }CALL_CATCH_EXCEPTION(0);
30271   }
30272   jresult = (unsigned long)result;
30273   return jresult;
30274 }
30275
30276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
30277   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
30278   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
30279
30280   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
30281   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
30282   {
30283     try {
30284       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
30285     } CALL_CATCH_EXCEPTION();
30286   }
30287 }
30288
30289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
30290   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
30291   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
30292
30293   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
30294   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
30295   {
30296     try {
30297       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
30298     } CALL_CATCH_EXCEPTION();
30299   }
30300 }
30301
30302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
30303   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
30304   Dali::Actor arg2 ;
30305   //bool arg3 ;
30306   Dali::LayoutDirection::Type arg4 ;
30307   Dali::Actor *argp2 ;
30308
30309   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
30310   argp2 = (Dali::Actor *)jarg2;
30311   if (!argp2) {
30312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30313     return ;
30314   }
30315   arg2 = *argp2;
30316   //arg3 = jarg3 ? true : false;
30317   arg4 = (Dali::LayoutDirection::Type)jarg4;
30318   {
30319     try {
30320       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
30321     } CALL_CATCH_EXCEPTION();
30322   }
30323 }
30324
30325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
30326   void * jresult ;
30327   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
30328
30329   {
30330     try {
30331       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
30332     } CALL_CATCH_EXCEPTION(0);
30333   }
30334   jresult = (void *)result;
30335   return jresult;
30336 }
30337
30338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
30339   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
30340
30341   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
30342   {
30343     try {
30344       delete arg1;
30345     } CALL_CATCH_EXCEPTION();
30346   }
30347 }
30348
30349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
30350   void * jresult ;
30351   Dali::Timer *result = 0 ;
30352
30353   {
30354     try {
30355       result = (Dali::Timer *)new Dali::Timer();
30356     } CALL_CATCH_EXCEPTION(0);
30357   }
30358
30359   jresult = (void *)result;
30360   return jresult;
30361 }
30362
30363
30364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
30365   void * jresult ;
30366   unsigned int arg1 ;
30367   Dali::Timer result;
30368
30369   arg1 = (unsigned int)jarg1;
30370   {
30371     try {
30372       result = Dali::Timer::New(arg1);
30373     } CALL_CATCH_EXCEPTION(0);
30374   }
30375
30376   jresult = new Dali::Timer((const Dali::Timer &)result);
30377   return jresult;
30378 }
30379
30380
30381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
30382   void * jresult ;
30383   Dali::Timer *arg1 = 0 ;
30384   Dali::Timer *result = 0 ;
30385
30386   arg1 = (Dali::Timer *)jarg1;
30387   if (!arg1) {
30388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
30389     return 0;
30390   }
30391   {
30392     try {
30393       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
30394     } CALL_CATCH_EXCEPTION(0);
30395   }
30396
30397   jresult = (void *)result;
30398   return jresult;
30399 }
30400
30401
30402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
30403   void * jresult ;
30404   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30405   Dali::Timer *arg2 = 0 ;
30406   Dali::Timer *result = 0 ;
30407
30408   arg1 = (Dali::Timer *)jarg1;
30409   arg2 = (Dali::Timer *)jarg2;
30410   if (!arg2) {
30411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
30412     return 0;
30413   }
30414   {
30415     try {
30416       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
30417     } CALL_CATCH_EXCEPTION(0);
30418   }
30419
30420   jresult = (void *)result;
30421   return jresult;
30422 }
30423
30424
30425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
30426   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30427
30428   arg1 = (Dali::Timer *)jarg1;
30429   {
30430     try {
30431       delete arg1;
30432     } CALL_CATCH_EXCEPTION();
30433   }
30434
30435 }
30436
30437
30438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
30439   void * jresult ;
30440   Dali::BaseHandle arg1 ;
30441   Dali::BaseHandle *argp1 ;
30442   Dali::Timer result;
30443
30444   argp1 = (Dali::BaseHandle *)jarg1;
30445   if (!argp1) {
30446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30447     return 0;
30448   }
30449   arg1 = *argp1;
30450   {
30451     try {
30452       result = Dali::Timer::DownCast(arg1);
30453     } CALL_CATCH_EXCEPTION(0);
30454   }
30455
30456   jresult = new Dali::Timer((const Dali::Timer &)result);
30457   return jresult;
30458 }
30459
30460
30461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
30462   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30463
30464   arg1 = (Dali::Timer *)jarg1;
30465   {
30466     try {
30467       (arg1)->Start();
30468     } CALL_CATCH_EXCEPTION();
30469   }
30470
30471 }
30472
30473
30474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
30475   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30476
30477   arg1 = (Dali::Timer *)jarg1;
30478   {
30479     try {
30480       (arg1)->Stop();
30481     } CALL_CATCH_EXCEPTION();
30482   }
30483
30484 }
30485
30486
30487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
30488   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30489   unsigned int arg2 ;
30490
30491   arg1 = (Dali::Timer *)jarg1;
30492   arg2 = (unsigned int)jarg2;
30493   {
30494     try {
30495       (arg1)->SetInterval(arg2);
30496     } CALL_CATCH_EXCEPTION();
30497   }
30498
30499 }
30500
30501
30502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
30503   unsigned int jresult ;
30504   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30505   unsigned int result;
30506
30507   arg1 = (Dali::Timer *)jarg1;
30508   {
30509     try {
30510       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
30511     } CALL_CATCH_EXCEPTION(0);
30512   }
30513
30514   jresult = result;
30515   return jresult;
30516 }
30517
30518
30519 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
30520   bool jresult ;
30521   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30522   bool result;
30523
30524   arg1 = (Dali::Timer *)jarg1;
30525   {
30526     try {
30527       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
30528     } CALL_CATCH_EXCEPTION(0);
30529   }
30530
30531   jresult = result;
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
30537   void * jresult ;
30538   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
30539   Dali::Timer::TimerSignalType *result = 0 ;
30540
30541   arg1 = (Dali::Timer *)jarg1;
30542   {
30543     try {
30544       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
30545     } CALL_CATCH_EXCEPTION(0);
30546   }
30547
30548   jresult = (void *)result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
30554   bool jresult ;
30555   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30556   bool result;
30557
30558   arg1 = (Dali::Signal< bool () > *)jarg1;
30559   {
30560     try {
30561       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
30562     } CALL_CATCH_EXCEPTION(0);
30563   }
30564
30565   jresult = result;
30566   return jresult;
30567 }
30568
30569
30570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
30571   unsigned long jresult ;
30572   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30573   std::size_t result;
30574
30575   arg1 = (Dali::Signal< bool () > *)jarg1;
30576   {
30577     try {
30578       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
30579     } CALL_CATCH_EXCEPTION(0);
30580   }
30581
30582   jresult = (unsigned long)result;
30583   return jresult;
30584 }
30585
30586
30587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
30588   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30589   bool (*arg2)() = (bool (*)()) 0 ;
30590
30591   arg1 = (Dali::Signal< bool () > *)jarg1;
30592   arg2 = (bool (*)())jarg2;
30593   {
30594     try {
30595       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
30596     } CALL_CATCH_EXCEPTION();
30597   }
30598
30599 }
30600
30601
30602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
30603   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30604   bool (*arg2)() = (bool (*)()) 0 ;
30605
30606   arg1 = (Dali::Signal< bool () > *)jarg1;
30607   arg2 = (bool (*)())jarg2;
30608   {
30609     try {
30610       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
30611     } CALL_CATCH_EXCEPTION();
30612   }
30613
30614 }
30615
30616
30617 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
30618   bool jresult ;
30619   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30620   bool result;
30621
30622   arg1 = (Dali::Signal< bool () > *)jarg1;
30623   {
30624     try {
30625       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
30626     } CALL_CATCH_EXCEPTION(0);
30627   }
30628
30629   jresult = result;
30630   return jresult;
30631 }
30632
30633
30634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
30635   void * jresult ;
30636   Dali::Signal< bool () > *result = 0 ;
30637
30638   {
30639     try {
30640       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
30641     } CALL_CATCH_EXCEPTION(0);
30642   }
30643
30644   jresult = (void *)result;
30645   return jresult;
30646 }
30647
30648
30649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
30650   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
30651
30652   arg1 = (Dali::Signal< bool () > *)jarg1;
30653   {
30654     try {
30655       delete arg1;
30656     } CALL_CATCH_EXCEPTION();
30657   }
30658
30659 }
30660
30661
30662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
30663   int jresult ;
30664   int result;
30665
30666   {
30667     try {
30668       result = (int)Dali::Toolkit::Visual::Property::TYPE;
30669     } CALL_CATCH_EXCEPTION(0);
30670   }
30671
30672   jresult = (int)result;
30673   return jresult;
30674 }
30675
30676
30677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
30678   int jresult ;
30679   int result;
30680
30681   {
30682     try {
30683       result = (int)Dali::Toolkit::Visual::Property::SHADER;
30684     } CALL_CATCH_EXCEPTION(0);
30685   }
30686
30687   jresult = (int)result;
30688   return jresult;
30689 }
30690
30691
30692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
30693   int jresult ;
30694   int result;
30695
30696   {
30697     try {
30698       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
30699     } CALL_CATCH_EXCEPTION(0);
30700   }
30701
30702   jresult = (int)result;
30703   return jresult;
30704 }
30705
30706
30707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
30708   int jresult ;
30709   int result;
30710
30711   {
30712     try {
30713       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
30714     } CALL_CATCH_EXCEPTION(0);
30715   }
30716
30717   jresult = (int)result;
30718   return jresult;
30719 }
30720
30721
30722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
30723   int jresult ;
30724   int result;
30725
30726   {
30727     try {
30728       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
30729     } CALL_CATCH_EXCEPTION(0);
30730   }
30731
30732   jresult = (int)result;
30733   return jresult;
30734 }
30735
30736
30737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
30738   int jresult ;
30739   int result;
30740
30741   {
30742     try {
30743       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
30744     } CALL_CATCH_EXCEPTION(0);
30745   }
30746
30747   jresult = (int)result;
30748   return jresult;
30749 }
30750
30751
30752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
30753   int jresult ;
30754   int result;
30755
30756   {
30757     try {
30758       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
30759     } CALL_CATCH_EXCEPTION(0);
30760   }
30761
30762   jresult = (int)result;
30763   return jresult;
30764 }
30765
30766
30767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
30768   int jresult ;
30769   int result;
30770
30771   {
30772     try {
30773       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
30774     } CALL_CATCH_EXCEPTION(0);
30775   }
30776
30777   jresult = (int)result;
30778   return jresult;
30779 }
30780
30781
30782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
30783   int jresult ;
30784   int result;
30785
30786   {
30787     try {
30788       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
30789     } CALL_CATCH_EXCEPTION(0);
30790   }
30791
30792   jresult = (int)result;
30793   return jresult;
30794 }
30795
30796
30797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
30798   int jresult ;
30799   int result;
30800
30801   {
30802     try {
30803       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
30804     } CALL_CATCH_EXCEPTION(0);
30805   }
30806
30807   jresult = (int)result;
30808   return jresult;
30809 }
30810
30811
30812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
30813   int jresult ;
30814   int result;
30815
30816   {
30817     try {
30818       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
30819     } CALL_CATCH_EXCEPTION(0);
30820   }
30821
30822   jresult = (int)result;
30823   return jresult;
30824 }
30825
30826
30827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
30828   int jresult ;
30829   int result;
30830
30831   {
30832     try {
30833       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
30834     } CALL_CATCH_EXCEPTION(0);
30835   }
30836
30837   jresult = (int)result;
30838   return jresult;
30839 }
30840
30841
30842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
30843   int jresult ;
30844   int result;
30845
30846   {
30847     try {
30848       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
30849     } CALL_CATCH_EXCEPTION(0);
30850   }
30851
30852   jresult = (int)result;
30853   return jresult;
30854 }
30855
30856
30857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
30858   int jresult ;
30859   int result;
30860
30861   {
30862     try {
30863       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
30864     } CALL_CATCH_EXCEPTION(0);
30865   }
30866
30867   jresult = (int)result;
30868   return jresult;
30869 }
30870
30871
30872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
30873   int jresult ;
30874   int result;
30875
30876   {
30877     try {
30878       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
30879     } CALL_CATCH_EXCEPTION(0);
30880   }
30881
30882   jresult = (int)result;
30883   return jresult;
30884 }
30885
30886
30887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
30888   int jresult ;
30889   int result;
30890
30891   {
30892     try {
30893       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
30894     } CALL_CATCH_EXCEPTION(0);
30895   }
30896
30897   jresult = (int)result;
30898   return jresult;
30899 }
30900
30901
30902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
30903   int jresult ;
30904   int result;
30905
30906   {
30907     try {
30908       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
30909     } CALL_CATCH_EXCEPTION(0);
30910   }
30911
30912   jresult = (int)result;
30913   return jresult;
30914 }
30915
30916
30917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
30918   int jresult ;
30919   int result;
30920
30921   {
30922     try {
30923       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
30924     } CALL_CATCH_EXCEPTION(0);
30925   }
30926
30927   jresult = (int)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
30933   int jresult ;
30934   int result;
30935
30936   {
30937     try {
30938       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
30939     } CALL_CATCH_EXCEPTION(0);
30940   }
30941
30942   jresult = (int)result;
30943   return jresult;
30944 }
30945
30946
30947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
30948   int jresult ;
30949   int result;
30950
30951   {
30952     try {
30953       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
30954     } CALL_CATCH_EXCEPTION(0);
30955   }
30956
30957   jresult = (int)result;
30958   return jresult;
30959 }
30960
30961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
30962   int jresult ;
30963   int result;
30964
30965   {
30966     try {
30967       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
30968     } CALL_CATCH_EXCEPTION(0);
30969   }
30970
30971   jresult = (int)result;
30972   return jresult;
30973 }
30974
30975
30976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
30977   int jresult ;
30978   int result;
30979   {
30980     try
30981     {
30982       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
30983     } CALL_CATCH_EXCEPTION(0);
30984   }
30985
30986   jresult = (int)result;
30987   return jresult;
30988 }
30989
30990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
30991   int jresult ;
30992   int result;
30993   {
30994     try
30995     {
30996       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
30997     } CALL_CATCH_EXCEPTION(0);
30998   }
30999
31000   jresult = (int)result;
31001   return jresult;
31002 }
31003
31004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
31005   int jresult ;
31006   int result;
31007   {
31008     try
31009     {
31010       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
31011     } CALL_CATCH_EXCEPTION(0);
31012   }
31013
31014   jresult = (int)result;
31015   return jresult;
31016 }
31017
31018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
31019   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
31020 }
31021
31022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
31023   int jresult ;
31024   int result;
31025   {
31026     try
31027     {
31028       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
31029     } CALL_CATCH_EXCEPTION(0);
31030   }
31031
31032   jresult = (int)result;
31033   return jresult;
31034 }
31035
31036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
31037   int jresult ;
31038   int result;
31039   {
31040     try
31041     {
31042       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
31043     } CALL_CATCH_EXCEPTION(0);
31044   }
31045
31046   jresult = (int)result;
31047   return jresult;
31048 }
31049
31050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
31051   int jresult ;
31052   int result;
31053
31054   {
31055     try {
31056       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
31057     } CALL_CATCH_EXCEPTION(0);
31058   }
31059
31060   jresult = (int)result;
31061   return jresult;
31062 }
31063
31064
31065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
31066   int jresult ;
31067   int result;
31068
31069   {
31070     try {
31071       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
31072     } CALL_CATCH_EXCEPTION(0);
31073   }
31074
31075   jresult = (int)result;
31076   return jresult;
31077 }
31078
31079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
31080   int jresult ;
31081   int result;
31082   {
31083     try
31084     {
31085       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
31086     } CALL_CATCH_EXCEPTION(0);
31087   }
31088
31089   jresult = (int)result;
31090   return jresult;
31091 }
31092
31093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
31094   int jresult ;
31095   int result;
31096   {
31097     try
31098     {
31099       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
31100     } CALL_CATCH_EXCEPTION(0);
31101   }
31102
31103   jresult = (int)result;
31104   return jresult;
31105 }
31106
31107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
31108   int jresult ;
31109   int result;
31110   {
31111     try
31112     {
31113       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
31114     } CALL_CATCH_EXCEPTION(0);
31115   }
31116
31117   jresult = (int)result;
31118   return jresult;
31119 }
31120
31121
31122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
31123   int jresult ;
31124   int result;
31125   {
31126     try
31127     {
31128       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
31129     } CALL_CATCH_EXCEPTION(0);
31130   }
31131
31132   jresult = (int)result;
31133   return jresult;
31134 }
31135
31136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
31137   int jresult ;
31138   int result;
31139   {
31140     try
31141     {
31142       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
31143     } CALL_CATCH_EXCEPTION(0);
31144   }
31145
31146   jresult = (int)result;
31147   return jresult;
31148 }
31149
31150
31151
31152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
31153   int jresult ;
31154   int result;
31155
31156   {
31157     try {
31158       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
31159     } CALL_CATCH_EXCEPTION(0);
31160   }
31161
31162   jresult = (int)result;
31163   return jresult;
31164 }
31165
31166
31167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
31168   int jresult ;
31169   int result;
31170
31171   {
31172     try {
31173       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
31174     } CALL_CATCH_EXCEPTION(0);
31175   }
31176
31177   jresult = (int)result;
31178   return jresult;
31179 }
31180
31181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PLACEHOLDER_IMAGE_get() {
31182   int jresult;
31183   int result;
31184   result = (int)Dali::Toolkit::ImageView::Property::PLACEHOLDER_IMAGE;
31185   jresult = (int)result;
31186   return jresult;
31187 }
31188
31189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_TRANSITION_EFFECT_get() {
31190   int jresult ;
31191   int result;
31192
31193   result = (int)Dali::Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT;
31194   jresult = (int)result;
31195   return jresult;
31196 }
31197
31198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
31199   int jresult ;
31200   int result;
31201
31202   {
31203     try {
31204       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
31205     } CALL_CATCH_EXCEPTION(0);
31206   }
31207
31208   jresult = (int)result;
31209   return jresult;
31210 }
31211
31212
31213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
31214   int jresult ;
31215   int result;
31216
31217   {
31218     try {
31219       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
31220     } CALL_CATCH_EXCEPTION(0);
31221   }
31222
31223   jresult = (int)result;
31224   return jresult;
31225 }
31226
31227
31228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
31229   int jresult ;
31230   int result;
31231
31232   {
31233     try {
31234       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
31235     } CALL_CATCH_EXCEPTION(0);
31236   }
31237
31238   jresult = (int)result;
31239   return jresult;
31240 }
31241
31242
31243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
31244   int jresult ;
31245   int result;
31246
31247   {
31248     try {
31249       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
31250     } CALL_CATCH_EXCEPTION(0);
31251   }
31252
31253   jresult = (int)result;
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
31259   int jresult ;
31260   int result;
31261
31262   {
31263     try {
31264       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
31265     } CALL_CATCH_EXCEPTION(0);
31266   }
31267
31268   jresult = (int)result;
31269   return jresult;
31270 }
31271
31272 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
31273   int jresult ;
31274   int result;
31275
31276   {
31277     try {
31278       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
31279     } CALL_CATCH_EXCEPTION(0);
31280   }
31281
31282   jresult = (int)result;
31283   return jresult;
31284 }
31285
31286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
31287   int jresult ;
31288   int result;
31289
31290   {
31291     try {
31292       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
31293     } CALL_CATCH_EXCEPTION(0);
31294   }
31295
31296   jresult = (int)result;
31297   return jresult;
31298 }
31299
31300
31301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
31302   int jresult ;
31303   int result;
31304
31305   {
31306     try {
31307       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
31308     } CALL_CATCH_EXCEPTION(0);
31309   }
31310
31311   jresult = (int)result;
31312   return jresult;
31313 }
31314
31315
31316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
31317   int jresult ;
31318   int result;
31319
31320   {
31321     try {
31322       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
31323     } CALL_CATCH_EXCEPTION(0);
31324   }
31325
31326   jresult = (int)result;
31327   return jresult;
31328 }
31329
31330
31331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
31332   int jresult ;
31333   int result;
31334
31335   {
31336     try {
31337       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
31338     } CALL_CATCH_EXCEPTION(0);
31339   }
31340
31341   jresult = (int)result;
31342   return jresult;
31343 }
31344
31345
31346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
31347   int jresult ;
31348   int result;
31349
31350   {
31351     try {
31352       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
31353     } CALL_CATCH_EXCEPTION(0);
31354   }
31355
31356   jresult = (int)result;
31357   return jresult;
31358 }
31359
31360
31361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
31362   int jresult ;
31363   int result;
31364
31365   {
31366     try {
31367       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
31368     } CALL_CATCH_EXCEPTION(0);
31369   }
31370
31371   jresult = (int)result;
31372   return jresult;
31373 }
31374
31375
31376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
31377   int jresult ;
31378   int result;
31379
31380   {
31381     try {
31382       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
31383     } CALL_CATCH_EXCEPTION(0);
31384   }
31385
31386   jresult = (int)result;
31387   return jresult;
31388 }
31389
31390
31391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
31392   int jresult ;
31393   int result;
31394
31395   {
31396     try {
31397       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
31398     } CALL_CATCH_EXCEPTION(0);
31399   }
31400
31401   jresult = (int)result;
31402   return jresult;
31403 }
31404
31405
31406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
31407   int jresult ;
31408   int result;
31409
31410   {
31411     try {
31412       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
31413     } CALL_CATCH_EXCEPTION(0);
31414   }
31415
31416   jresult = (int)result;
31417   return jresult;
31418 }
31419
31420
31421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
31422   int jresult ;
31423   int result;
31424
31425   {
31426     try {
31427       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
31428     } CALL_CATCH_EXCEPTION(0);
31429   }
31430
31431   jresult = (int)result;
31432   return jresult;
31433 }
31434
31435
31436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
31437   int jresult ;
31438   int result;
31439
31440   {
31441     try {
31442       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
31443     } CALL_CATCH_EXCEPTION(0);
31444   }
31445
31446   jresult = (int)result;
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
31452   int jresult ;
31453   int result;
31454
31455   {
31456     try {
31457       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
31458     } CALL_CATCH_EXCEPTION(0);
31459   }
31460
31461   jresult = (int)result;
31462   return jresult;
31463 }
31464
31465
31466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
31467   int jresult ;
31468   int result;
31469
31470   {
31471     try {
31472       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
31473     } CALL_CATCH_EXCEPTION(0);
31474   }
31475
31476   jresult = (int)result;
31477   return jresult;
31478 }
31479
31480
31481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
31482   int jresult ;
31483   int result;
31484
31485   {
31486     try {
31487       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
31488     } CALL_CATCH_EXCEPTION(0);
31489   }
31490
31491   jresult = (int)result;
31492   return jresult;
31493 }
31494
31495
31496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
31497   int jresult ;
31498   int result;
31499
31500   {
31501     try {
31502       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
31503     } CALL_CATCH_EXCEPTION(0);
31504   }
31505
31506   jresult = (int)result;
31507   return jresult;
31508 }
31509
31510
31511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
31512   int jresult ;
31513   int result;
31514
31515   {
31516     try {
31517       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
31518     } CALL_CATCH_EXCEPTION(0);
31519   }
31520
31521   jresult = (int)result;
31522   return jresult;
31523 }
31524
31525
31526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
31527   int jresult ;
31528   int result;
31529
31530   {
31531     try {
31532       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
31533     } CALL_CATCH_EXCEPTION(0);
31534   }
31535
31536   jresult = (int)result;
31537   return jresult;
31538 }
31539
31540
31541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
31542   int jresult ;
31543   int result;
31544
31545   {
31546     try {
31547       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
31548     } CALL_CATCH_EXCEPTION(0);
31549   }
31550
31551   jresult = (int)result;
31552   return jresult;
31553 }
31554
31555
31556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
31557   int jresult ;
31558   int result;
31559
31560   {
31561     try {
31562       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
31563     } CALL_CATCH_EXCEPTION(0);
31564   }
31565
31566   jresult = (int)result;
31567   return jresult;
31568 }
31569
31570
31571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
31572   int jresult ;
31573   int result;
31574
31575   {
31576     try {
31577       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
31578     } CALL_CATCH_EXCEPTION(0);
31579   }
31580
31581   jresult = (int)result;
31582   return jresult;
31583 }
31584
31585
31586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
31587   int jresult ;
31588   int result;
31589
31590   {
31591     try {
31592       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
31593     } CALL_CATCH_EXCEPTION(0);
31594   }
31595
31596   jresult = (int)result;
31597   return jresult;
31598 }
31599
31600
31601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
31602   int jresult ;
31603   int result;
31604
31605   {
31606     try {
31607       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
31608     } CALL_CATCH_EXCEPTION(0);
31609   }
31610
31611   jresult = (int)result;
31612   return jresult;
31613 }
31614
31615
31616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
31617   int jresult ;
31618   int result;
31619
31620   {
31621     try {
31622       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
31623     } CALL_CATCH_EXCEPTION(0);
31624   }
31625
31626   jresult = (int)result;
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
31632   int jresult ;
31633   int result;
31634
31635   {
31636     try {
31637       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
31638     } CALL_CATCH_EXCEPTION(0);
31639   }
31640
31641   jresult = (int)result;
31642   return jresult;
31643 }
31644
31645
31646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
31647   int jresult ;
31648   int result;
31649
31650   {
31651     try {
31652       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
31653     } CALL_CATCH_EXCEPTION(0);
31654   }
31655
31656   jresult = (int)result;
31657   return jresult;
31658 }
31659
31660
31661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
31662   int jresult ;
31663   int result;
31664
31665   {
31666     try {
31667       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
31668     } CALL_CATCH_EXCEPTION(0);
31669   }
31670
31671   jresult = (int)result;
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
31677   int jresult ;
31678   int result;
31679
31680   {
31681     try {
31682       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
31683     } CALL_CATCH_EXCEPTION(0);
31684   }
31685
31686   jresult = (int)result;
31687   return jresult;
31688 }
31689
31690
31691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
31692   int jresult ;
31693   int result;
31694
31695   {
31696     try {
31697       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
31698     } CALL_CATCH_EXCEPTION(0);
31699   }
31700
31701   jresult = (int)result;
31702   return jresult;
31703 }
31704
31705
31706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
31707   void * jresult ;
31708   Dali::Toolkit::Builder *result = 0 ;
31709
31710   {
31711     try {
31712       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
31713     } CALL_CATCH_EXCEPTION(0);
31714   }
31715
31716   jresult = (void *)result;
31717   return jresult;
31718 }
31719
31720
31721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
31722   void * jresult ;
31723   Dali::Toolkit::Builder result;
31724
31725   {
31726     try {
31727       result = Dali::Toolkit::Builder::New();
31728     } CALL_CATCH_EXCEPTION(0);
31729   }
31730
31731   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
31732   return jresult;
31733 }
31734
31735
31736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
31737   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31738
31739   arg1 = (Dali::Toolkit::Builder *)jarg1;
31740   {
31741     try {
31742       delete arg1;
31743     } CALL_CATCH_EXCEPTION();
31744   }
31745
31746 }
31747
31748
31749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
31750   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31751   std::string *arg2 = 0 ;
31752   Dali::Toolkit::Builder::UIFormat arg3 ;
31753
31754   arg1 = (Dali::Toolkit::Builder *)jarg1;
31755   if (!jarg2) {
31756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31757     return ;
31758   }
31759   std::string arg2_str(jarg2);
31760   arg2 = &arg2_str;
31761   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
31762   {
31763     try {
31764       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
31765     } CALL_CATCH_EXCEPTION();
31766   }
31767
31768
31769   //argout typemap for const std::string&
31770
31771 }
31772
31773
31774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
31775   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31776   std::string *arg2 = 0 ;
31777
31778   arg1 = (Dali::Toolkit::Builder *)jarg1;
31779   if (!jarg2) {
31780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31781     return ;
31782   }
31783   std::string arg2_str(jarg2);
31784   arg2 = &arg2_str;
31785   {
31786     try {
31787       (arg1)->LoadFromString((std::string const &)*arg2);
31788     } CALL_CATCH_EXCEPTION();
31789   }
31790
31791
31792   //argout typemap for const std::string&
31793
31794 }
31795
31796
31797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
31798   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31799   Dali::Property::Map *arg2 = 0 ;
31800
31801   arg1 = (Dali::Toolkit::Builder *)jarg1;
31802   arg2 = (Dali::Property::Map *)jarg2;
31803   if (!arg2) {
31804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
31805     return ;
31806   }
31807   {
31808     try {
31809       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
31810     } CALL_CATCH_EXCEPTION();
31811   }
31812
31813 }
31814
31815
31816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
31817   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31818   std::string *arg2 = 0 ;
31819   Dali::Property::Value *arg3 = 0 ;
31820
31821   arg1 = (Dali::Toolkit::Builder *)jarg1;
31822   if (!jarg2) {
31823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31824     return ;
31825   }
31826   std::string arg2_str(jarg2);
31827   arg2 = &arg2_str;
31828   arg3 = (Dali::Property::Value *)jarg3;
31829   if (!arg3) {
31830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
31831     return ;
31832   }
31833   {
31834     try {
31835       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
31836     } CALL_CATCH_EXCEPTION();
31837   }
31838
31839
31840   //argout typemap for const std::string&
31841
31842 }
31843
31844
31845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
31846   void * jresult ;
31847   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31848   Dali::Property::Map *result = 0 ;
31849
31850   arg1 = (Dali::Toolkit::Builder *)jarg1;
31851   {
31852     try {
31853       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
31854     } CALL_CATCH_EXCEPTION(0);
31855   }
31856
31857   jresult = (void *)result;
31858   return jresult;
31859 }
31860
31861
31862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
31863   void * jresult ;
31864   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31865   std::string *arg2 = 0 ;
31866   Dali::Property::Value *result = 0 ;
31867
31868   arg1 = (Dali::Toolkit::Builder *)jarg1;
31869   if (!jarg2) {
31870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31871     return 0;
31872   }
31873   std::string arg2_str(jarg2);
31874   arg2 = &arg2_str;
31875   {
31876     try {
31877       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
31878     } CALL_CATCH_EXCEPTION(0);
31879   }
31880
31881   jresult = (void *)result;
31882
31883   //argout typemap for const std::string&
31884
31885   return jresult;
31886 }
31887
31888
31889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
31890   void * jresult ;
31891   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31892   std::string *arg2 = 0 ;
31893   Dali::Animation result;
31894
31895   arg1 = (Dali::Toolkit::Builder *)jarg1;
31896   if (!jarg2) {
31897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31898     return 0;
31899   }
31900   std::string arg2_str(jarg2);
31901   arg2 = &arg2_str;
31902   {
31903     try {
31904       result = (arg1)->CreateAnimation((std::string const &)*arg2);
31905     } CALL_CATCH_EXCEPTION(0);
31906   }
31907
31908   jresult = new Dali::Animation((const Dali::Animation &)result);
31909
31910   //argout typemap for const std::string&
31911
31912   return jresult;
31913 }
31914
31915
31916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
31917   void * jresult ;
31918   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31919   std::string *arg2 = 0 ;
31920   Dali::Property::Map *arg3 = 0 ;
31921   Dali::Animation result;
31922
31923   arg1 = (Dali::Toolkit::Builder *)jarg1;
31924   if (!jarg2) {
31925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31926     return 0;
31927   }
31928   std::string arg2_str(jarg2);
31929   arg2 = &arg2_str;
31930   arg3 = (Dali::Property::Map *)jarg3;
31931   if (!arg3) {
31932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
31933     return 0;
31934   }
31935   {
31936     try {
31937       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
31938     } CALL_CATCH_EXCEPTION(0);
31939   }
31940
31941   jresult = new Dali::Animation((const Dali::Animation &)result);
31942
31943   //argout typemap for const std::string&
31944
31945   return jresult;
31946 }
31947
31948
31949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
31950   void * jresult ;
31951   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31952   std::string *arg2 = 0 ;
31953   Dali::Actor arg3 ;
31954   Dali::Actor *argp3 ;
31955   Dali::Animation result;
31956
31957   arg1 = (Dali::Toolkit::Builder *)jarg1;
31958   if (!jarg2) {
31959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31960     return 0;
31961   }
31962   std::string arg2_str(jarg2);
31963   arg2 = &arg2_str;
31964   argp3 = (Dali::Actor *)jarg3;
31965   if (!argp3) {
31966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31967     return 0;
31968   }
31969   arg3 = *argp3;
31970   {
31971     try {
31972       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
31973     } CALL_CATCH_EXCEPTION(0);
31974   }
31975
31976   jresult = new Dali::Animation((const Dali::Animation &)result);
31977
31978   //argout typemap for const std::string&
31979
31980   return jresult;
31981 }
31982
31983
31984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
31985   void * jresult ;
31986   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
31987   std::string *arg2 = 0 ;
31988   Dali::Property::Map *arg3 = 0 ;
31989   Dali::Actor arg4 ;
31990   Dali::Actor *argp4 ;
31991   Dali::Animation result;
31992
31993   arg1 = (Dali::Toolkit::Builder *)jarg1;
31994   if (!jarg2) {
31995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31996     return 0;
31997   }
31998   std::string arg2_str(jarg2);
31999   arg2 = &arg2_str;
32000   arg3 = (Dali::Property::Map *)jarg3;
32001   if (!arg3) {
32002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
32003     return 0;
32004   }
32005   argp4 = (Dali::Actor *)jarg4;
32006   if (!argp4) {
32007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32008     return 0;
32009   }
32010   arg4 = *argp4;
32011   {
32012     try {
32013       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
32014     } CALL_CATCH_EXCEPTION(0);
32015   }
32016
32017   jresult = new Dali::Animation((const Dali::Animation &)result);
32018
32019   //argout typemap for const std::string&
32020
32021   return jresult;
32022 }
32023
32024
32025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
32026   void * jresult ;
32027   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32028   std::string *arg2 = 0 ;
32029   Dali::BaseHandle result;
32030
32031   arg1 = (Dali::Toolkit::Builder *)jarg1;
32032   if (!jarg2) {
32033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32034     return 0;
32035   }
32036   std::string arg2_str(jarg2);
32037   arg2 = &arg2_str;
32038   {
32039     try {
32040       result = (arg1)->Create((std::string const &)*arg2);
32041     } CALL_CATCH_EXCEPTION(0);
32042   }
32043
32044   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
32045
32046   //argout typemap for const std::string&
32047
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
32053   void * jresult ;
32054   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32055   std::string *arg2 = 0 ;
32056   Dali::Property::Map *arg3 = 0 ;
32057   Dali::BaseHandle result;
32058
32059   arg1 = (Dali::Toolkit::Builder *)jarg1;
32060   if (!jarg2) {
32061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32062     return 0;
32063   }
32064   std::string arg2_str(jarg2);
32065   arg2 = &arg2_str;
32066   arg3 = (Dali::Property::Map *)jarg3;
32067   if (!arg3) {
32068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
32069     return 0;
32070   }
32071   {
32072     try {
32073       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
32074     } CALL_CATCH_EXCEPTION(0);
32075   }
32076
32077   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
32078
32079   //argout typemap for const std::string&
32080
32081   return jresult;
32082 }
32083
32084
32085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
32086   void * jresult ;
32087   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32088   std::string *arg2 = 0 ;
32089   Dali::BaseHandle result;
32090
32091   arg1 = (Dali::Toolkit::Builder *)jarg1;
32092   if (!jarg2) {
32093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32094     return 0;
32095   }
32096   std::string arg2_str(jarg2);
32097   arg2 = &arg2_str;
32098   {
32099     try {
32100       result = (arg1)->CreateFromJson((std::string const &)*arg2);
32101     } CALL_CATCH_EXCEPTION(0);
32102   }
32103
32104   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
32105
32106   //argout typemap for const std::string&
32107
32108   return jresult;
32109 }
32110
32111
32112 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
32113   bool jresult ;
32114   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32115   std::string *arg2 = 0 ;
32116   Dali::Handle *arg3 = 0 ;
32117   bool result;
32118
32119   arg1 = (Dali::Toolkit::Builder *)jarg1;
32120   if (!jarg2) {
32121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32122     return 0;
32123   }
32124   std::string arg2_str(jarg2);
32125   arg2 = &arg2_str;
32126   arg3 = (Dali::Handle *)jarg3;
32127   if (!arg3) {
32128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
32129     return 0;
32130   }
32131   {
32132     try {
32133       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
32134     } CALL_CATCH_EXCEPTION(0);
32135   }
32136
32137   jresult = result;
32138
32139   //argout typemap for const std::string&
32140
32141   return jresult;
32142 }
32143
32144
32145 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
32146   bool jresult ;
32147   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32148   Dali::Handle *arg2 = 0 ;
32149   std::string *arg3 = 0 ;
32150   bool result;
32151
32152   arg1 = (Dali::Toolkit::Builder *)jarg1;
32153   arg2 = (Dali::Handle *)jarg2;
32154   if (!arg2) {
32155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
32156     return 0;
32157   }
32158   if (!jarg3) {
32159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32160     return 0;
32161   }
32162   std::string arg3_str(jarg3);
32163   arg3 = &arg3_str;
32164   {
32165     try {
32166       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
32167     } CALL_CATCH_EXCEPTION(0);
32168   }
32169
32170   jresult = result;
32171
32172   //argout typemap for const std::string&
32173
32174   return jresult;
32175 }
32176
32177
32178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
32179   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32180   Dali::Actor arg2 ;
32181   Dali::Actor *argp2 ;
32182
32183   arg1 = (Dali::Toolkit::Builder *)jarg1;
32184   argp2 = (Dali::Actor *)jarg2;
32185   if (!argp2) {
32186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32187     return ;
32188   }
32189   arg2 = *argp2;
32190   {
32191     try {
32192       (arg1)->AddActors(arg2);
32193     } CALL_CATCH_EXCEPTION();
32194   }
32195
32196 }
32197
32198
32199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
32200   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32201   std::string *arg2 = 0 ;
32202   Dali::Actor arg3 ;
32203   Dali::Actor *argp3 ;
32204
32205   arg1 = (Dali::Toolkit::Builder *)jarg1;
32206   if (!jarg2) {
32207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32208     return ;
32209   }
32210   std::string arg2_str(jarg2);
32211   arg2 = &arg2_str;
32212   argp3 = (Dali::Actor *)jarg3;
32213   if (!argp3) {
32214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32215     return ;
32216   }
32217   arg3 = *argp3;
32218   {
32219     try {
32220       (arg1)->AddActors((std::string const &)*arg2,arg3);
32221     } CALL_CATCH_EXCEPTION();
32222   }
32223
32224
32225   //argout typemap for const std::string&
32226
32227 }
32228
32229
32230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
32231   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32232   std::string *arg2 = 0 ;
32233
32234   arg1 = (Dali::Toolkit::Builder *)jarg1;
32235   if (!jarg2) {
32236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32237     return ;
32238   }
32239   std::string arg2_str(jarg2);
32240   arg2 = &arg2_str;
32241   {
32242     try {
32243       (arg1)->CreateRenderTask((std::string const &)*arg2);
32244     } CALL_CATCH_EXCEPTION();
32245   }
32246
32247
32248   //argout typemap for const std::string&
32249
32250 }
32251
32252
32253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
32254   void * jresult ;
32255   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32256   std::string *arg2 = 0 ;
32257   Dali::Path result;
32258
32259   arg1 = (Dali::Toolkit::Builder *)jarg1;
32260   if (!jarg2) {
32261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32262     return 0;
32263   }
32264   std::string arg2_str(jarg2);
32265   arg2 = &arg2_str;
32266   {
32267     try {
32268       result = (arg1)->GetPath((std::string const &)*arg2);
32269     } CALL_CATCH_EXCEPTION(0);
32270   }
32271
32272   jresult = new Dali::Path((const Dali::Path &)result);
32273
32274   //argout typemap for const std::string&
32275
32276   return jresult;
32277 }
32278
32279
32280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
32281   void * jresult ;
32282   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32283   std::string *arg2 = 0 ;
32284   Dali::PathConstrainer result;
32285
32286   arg1 = (Dali::Toolkit::Builder *)jarg1;
32287   if (!jarg2) {
32288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32289     return 0;
32290   }
32291   std::string arg2_str(jarg2);
32292   arg2 = &arg2_str;
32293   {
32294     try {
32295       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
32296     } CALL_CATCH_EXCEPTION(0);
32297   }
32298
32299   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
32300
32301   //argout typemap for const std::string&
32302
32303   return jresult;
32304 }
32305
32306
32307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
32308   void * jresult ;
32309   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32310   std::string *arg2 = 0 ;
32311   Dali::LinearConstrainer result;
32312
32313   arg1 = (Dali::Toolkit::Builder *)jarg1;
32314   if (!jarg2) {
32315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32316     return 0;
32317   }
32318   std::string arg2_str(jarg2);
32319   arg2 = &arg2_str;
32320   {
32321     try {
32322       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
32323     } CALL_CATCH_EXCEPTION(0);
32324   }
32325
32326   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
32327
32328   //argout typemap for const std::string&
32329
32330   return jresult;
32331 }
32332
32333
32334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
32335   void * jresult ;
32336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
32337   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
32338
32339   arg1 = (Dali::Toolkit::Builder *)jarg1;
32340   {
32341     try {
32342       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
32343     } CALL_CATCH_EXCEPTION(0);
32344   }
32345
32346   jresult = (void *)result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
32352   void * jresult ;
32353   Dali::Toolkit::TransitionData *result = 0 ;
32354
32355   {
32356     try {
32357       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
32358     } CALL_CATCH_EXCEPTION(0);
32359   }
32360
32361   jresult = (void *)result;
32362   return jresult;
32363 }
32364
32365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
32366   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
32367
32368   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
32369   {
32370     try {
32371       delete arg1;
32372     } CALL_CATCH_EXCEPTION();
32373   }
32374
32375 }
32376
32377
32378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
32379   void * jresult ;
32380   Dali::Property::Map *arg1 = 0 ;
32381   Dali::Toolkit::TransitionData result;
32382
32383   arg1 = (Dali::Property::Map *)jarg1;
32384   if (!arg1) {
32385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
32386     return 0;
32387   }
32388   {
32389     try {
32390       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
32391     } CALL_CATCH_EXCEPTION(0);
32392   }
32393
32394   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
32395   return jresult;
32396 }
32397
32398
32399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
32400   void * jresult ;
32401   Dali::Property::Array *arg1 = 0 ;
32402   Dali::Toolkit::TransitionData result;
32403
32404   arg1 = (Dali::Property::Array *)jarg1;
32405   if (!arg1) {
32406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
32407     return 0;
32408   }
32409   {
32410     try {
32411       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
32412     } CALL_CATCH_EXCEPTION(0);
32413   }
32414
32415   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
32416   return jresult;
32417 }
32418
32419
32420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
32421   void * jresult ;
32422   Dali::BaseHandle arg1 ;
32423   Dali::BaseHandle *argp1 ;
32424   Dali::Toolkit::TransitionData result;
32425
32426   argp1 = (Dali::BaseHandle *)jarg1;
32427   if (!argp1) {
32428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32429     return 0;
32430   }
32431   arg1 = *argp1;
32432   {
32433     try {
32434       result = Dali::Toolkit::TransitionData::DownCast(arg1);
32435     } CALL_CATCH_EXCEPTION(0);
32436   }
32437
32438   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
32439   return jresult;
32440 }
32441
32442
32443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
32444   void * jresult ;
32445   Dali::Toolkit::TransitionData *arg1 = 0 ;
32446   Dali::Toolkit::TransitionData *result = 0 ;
32447
32448   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
32449   if (!arg1) {
32450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
32451     return 0;
32452   }
32453   {
32454     try {
32455       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
32456     } CALL_CATCH_EXCEPTION(0);
32457   }
32458
32459   jresult = (void *)result;
32460   return jresult;
32461 }
32462
32463
32464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
32465   void * jresult ;
32466   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
32467   Dali::Toolkit::TransitionData *arg2 = 0 ;
32468   Dali::Toolkit::TransitionData *result = 0 ;
32469
32470   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
32471   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
32472   if (!arg2) {
32473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
32474     return 0;
32475   }
32476   {
32477     try {
32478       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
32479     } CALL_CATCH_EXCEPTION(0);
32480   }
32481
32482   jresult = (void *)result;
32483   return jresult;
32484 }
32485
32486
32487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
32488   unsigned long jresult ;
32489   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
32490   size_t result;
32491
32492   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
32493   {
32494     try {
32495       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
32496     } CALL_CATCH_EXCEPTION(0);
32497   }
32498
32499   jresult = (unsigned long)result;
32500   return jresult;
32501 }
32502
32503
32504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
32505   void * jresult ;
32506   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
32507   size_t arg2 ;
32508   Dali::Property::Map result;
32509
32510   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
32511   arg2 = (size_t)jarg2;
32512   {
32513     try {
32514       result = (arg1)->GetAnimatorAt(arg2);
32515     } CALL_CATCH_EXCEPTION(0);
32516   }
32517
32518   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
32519   return jresult;
32520 }
32521
32522
32523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
32524   int jresult ;
32525   int result;
32526
32527   {
32528     try {
32529       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
32530     } CALL_CATCH_EXCEPTION(0);
32531   }
32532
32533   jresult = (int)result;
32534   return jresult;
32535 }
32536
32537
32538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
32539   int jresult ;
32540   int result;
32541
32542   {
32543     try {
32544       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
32545     } CALL_CATCH_EXCEPTION(0);
32546   }
32547
32548   jresult = (int)result;
32549   return jresult;
32550 }
32551
32552
32553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
32554   int jresult ;
32555   int result;
32556
32557   {
32558     try {
32559       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
32560     } CALL_CATCH_EXCEPTION(0);
32561   }
32562
32563   jresult = (int)result;
32564   return jresult;
32565 }
32566
32567
32568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
32569   int jresult ;
32570   int result;
32571
32572   {
32573     try {
32574       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
32575     } CALL_CATCH_EXCEPTION(0);
32576   }
32577
32578   jresult = (int)result;
32579   return jresult;
32580 }
32581
32582
32583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
32584   int jresult ;
32585   int result;
32586
32587   {
32588     try {
32589       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
32590     } CALL_CATCH_EXCEPTION(0);
32591   }
32592
32593   jresult = (int)result;
32594   return jresult;
32595 }
32596
32597
32598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
32599   int jresult ;
32600   int result;
32601
32602   {
32603     try {
32604       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
32605     } CALL_CATCH_EXCEPTION(0);
32606   }
32607
32608   jresult = (int)result;
32609   return jresult;
32610 }
32611
32612
32613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
32614   int jresult ;
32615   int result;
32616
32617   {
32618     try {
32619       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
32620     } CALL_CATCH_EXCEPTION(0);
32621   }
32622
32623   jresult = (int)result;
32624   return jresult;
32625 }
32626
32627
32628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
32629   int jresult ;
32630   int result;
32631
32632   {
32633     try {
32634       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
32635     } CALL_CATCH_EXCEPTION(0);
32636   }
32637
32638   jresult = (int)result;
32639   return jresult;
32640 }
32641
32642
32643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
32644   int jresult ;
32645   int result;
32646
32647   {
32648     try {
32649       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
32650     } CALL_CATCH_EXCEPTION(0);
32651   }
32652
32653   jresult = (int)result;
32654   return jresult;
32655 }
32656
32657
32658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
32659   int jresult ;
32660   int result;
32661
32662   {
32663     try {
32664       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
32665     } CALL_CATCH_EXCEPTION(0);
32666   }
32667
32668   jresult = (int)result;
32669   return jresult;
32670 }
32671
32672
32673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
32674   int jresult ;
32675   int result;
32676
32677   {
32678     try {
32679       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
32680     } CALL_CATCH_EXCEPTION(0);
32681   }
32682
32683   jresult = (int)result;
32684   return jresult;
32685 }
32686
32687
32688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
32689   int jresult ;
32690   int result;
32691
32692   {
32693     try {
32694       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
32695     } CALL_CATCH_EXCEPTION(0);
32696   }
32697
32698   jresult = (int)result;
32699   return jresult;
32700 }
32701
32702
32703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
32704   int jresult ;
32705   int result;
32706
32707   {
32708     try {
32709       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
32710     } CALL_CATCH_EXCEPTION(0);
32711   }
32712
32713   jresult = (int)result;
32714   return jresult;
32715 }
32716
32717
32718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
32719   int jresult ;
32720   int result;
32721
32722   {
32723     try {
32724       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
32725     } CALL_CATCH_EXCEPTION(0);
32726   }
32727
32728   jresult = (int)result;
32729   return jresult;
32730 }
32731
32732
32733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
32734   void * jresult ;
32735   Dali::Toolkit::Control result;
32736
32737   {
32738     try {
32739       result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
32740     } CALL_CATCH_EXCEPTION(0);
32741   }
32742
32743   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
32744   return jresult;
32745 }
32746
32747
32748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
32749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32750   std::string *arg2 = 0 ;
32751
32752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32753   if (!jarg2) {
32754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
32755     return ;
32756   }
32757   std::string arg2_str(jarg2);
32758   arg2 = &arg2_str;
32759   {
32760     try {
32761       (arg1)->SetStyleName((std::string const &)*arg2);
32762     } CALL_CATCH_EXCEPTION();
32763   }
32764
32765
32766   //argout typemap for const std::string&
32767
32768 }
32769
32770
32771 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
32772   char * jresult ;
32773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32774   std::string *result = 0 ;
32775
32776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32777   {
32778     try {
32779       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
32780     } CALL_CATCH_EXCEPTION(0);
32781   }
32782
32783   jresult = SWIG_csharp_string_callback(result->c_str());
32784   return jresult;
32785 }
32786
32787
32788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
32789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32790   Dali::Vector4 *arg2 = 0 ;
32791
32792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32793   arg2 = (Dali::Vector4 *)jarg2;
32794   if (!arg2) {
32795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
32796     return ;
32797   }
32798   {
32799     try {
32800       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
32801     } CALL_CATCH_EXCEPTION();
32802   }
32803
32804 }
32805
32806
32807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
32808   void * jresult ;
32809   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
32810   Dali::Vector4 result;
32811
32812   arg1 = (Dali::Handle *)jarg1;
32813   {
32814     try {
32815       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
32816       if (resultMap)
32817       {
32818         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
32819         if(type && type->Get<int>() == Visual::COLOR )
32820         {
32821           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
32822           if (value)
32823           {
32824             result = value->Get<Vector4>();
32825           }
32826         }
32827       }
32828     } CALL_CATCH_EXCEPTION(0);
32829   }
32830
32831   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
32832   return jresult;
32833 }
32834
32835
32836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
32837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32838   Dali::Property::Map *arg2 = 0 ;
32839
32840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32841   arg2 = (Dali::Property::Map *)jarg2;
32842   if (!arg2) {
32843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
32844     return ;
32845   }
32846   {
32847     try {
32848       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
32849     } CALL_CATCH_EXCEPTION();
32850   }
32851
32852 }
32853
32854
32855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
32856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32857
32858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32859   {
32860     try {
32861       (arg1)->ClearBackground();
32862     } CALL_CATCH_EXCEPTION();
32863   }
32864
32865 }
32866
32867
32868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
32869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32870   Dali::GestureType::Value arg2 ;
32871
32872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32873   arg2 = (Dali::GestureType::Value)jarg2;
32874   {
32875     try {
32876       (arg1)->EnableGestureDetection(arg2);
32877     } CALL_CATCH_EXCEPTION();
32878   }
32879
32880 }
32881
32882
32883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
32884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32885   Dali::GestureType::Value arg2 ;
32886
32887   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32888   arg2 = (Dali::GestureType::Value)jarg2;
32889   {
32890     try {
32891       (arg1)->DisableGestureDetection(arg2);
32892     } CALL_CATCH_EXCEPTION();
32893   }
32894
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
32899   void * jresult ;
32900   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32901   Dali::PinchGestureDetector result;
32902
32903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32904   {
32905     try {
32906       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
32907     } CALL_CATCH_EXCEPTION(0);
32908   }
32909
32910   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
32911   return jresult;
32912 }
32913
32914
32915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
32916   void * jresult ;
32917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32918   Dali::PanGestureDetector result;
32919
32920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32921   {
32922     try {
32923       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
32924     } CALL_CATCH_EXCEPTION(0);
32925   }
32926
32927   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
32928   return jresult;
32929 }
32930
32931
32932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
32933   void * jresult ;
32934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32935   Dali::TapGestureDetector result;
32936
32937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32938   {
32939     try {
32940       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
32941     } CALL_CATCH_EXCEPTION(0);
32942   }
32943
32944   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
32945   return jresult;
32946 }
32947
32948
32949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
32950   void * jresult ;
32951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32952   Dali::LongPressGestureDetector result;
32953
32954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32955   {
32956     try {
32957       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
32958     } CALL_CATCH_EXCEPTION(0);
32959   }
32960
32961   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
32962   return jresult;
32963 }
32964
32965
32966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
32967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32968   bool arg2 ;
32969
32970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32971   arg2 = jarg2 ? true : false;
32972   {
32973     try {
32974       (arg1)->SetKeyboardNavigationSupport(arg2);
32975     } CALL_CATCH_EXCEPTION();
32976   }
32977
32978 }
32979
32980
32981 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
32982   bool jresult ;
32983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
32984   bool result;
32985
32986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
32987   {
32988     try {
32989       result = (bool)(arg1)->IsKeyboardNavigationSupported();
32990     } CALL_CATCH_EXCEPTION(0);
32991   }
32992
32993   jresult = result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
32999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33000
33001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33002   {
33003     try {
33004       (arg1)->SetKeyInputFocus();
33005     } CALL_CATCH_EXCEPTION();
33006   }
33007
33008 }
33009
33010
33011 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
33012   bool jresult ;
33013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33014   bool result;
33015
33016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33017   {
33018     try {
33019       result = (bool)(arg1)->HasKeyInputFocus();
33020     } CALL_CATCH_EXCEPTION(0);
33021   }
33022
33023   jresult = result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
33029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33030
33031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33032   {
33033     try {
33034       (arg1)->ClearKeyInputFocus();
33035     } CALL_CATCH_EXCEPTION();
33036   }
33037
33038 }
33039
33040
33041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
33042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33043   bool arg2 ;
33044
33045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33046   arg2 = jarg2 ? true : false;
33047   {
33048     try {
33049       (arg1)->SetAsKeyboardFocusGroup(arg2);
33050     } CALL_CATCH_EXCEPTION();
33051   }
33052
33053 }
33054
33055
33056 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
33057   bool jresult ;
33058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33059   bool result;
33060
33061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33062   {
33063     try {
33064       result = (bool)(arg1)->IsKeyboardFocusGroup();
33065     } CALL_CATCH_EXCEPTION(0);
33066   }
33067
33068   jresult = result;
33069   return jresult;
33070 }
33071
33072
33073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
33074   void * jresult ;
33075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33076   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
33077
33078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33079   {
33080     try {
33081       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33082     } CALL_CATCH_EXCEPTION(0);
33083   }
33084
33085   jresult = (void *)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
33091   void * jresult ;
33092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33093   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
33094
33095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33096   {
33097     try {
33098       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
33099     } CALL_CATCH_EXCEPTION(0);
33100   }
33101
33102   jresult = (void *)result;
33103   return jresult;
33104 }
33105
33106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
33107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33108   int arg2 ;
33109   SwigDirector_ViewImpl *darg = 0;
33110
33111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33112   arg2 = (int)jarg2;
33113   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33114   if(!darg) {
33115     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33116     return;
33117   }
33118   {
33119     try {
33120       if(darg) {
33121         (darg)->OnSceneConnection(arg2);
33122       }
33123     } CALL_CATCH_EXCEPTION();
33124   }
33125
33126 }
33127
33128
33129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
33130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33131   int arg2 ;
33132   SwigDirector_ViewImpl *darg = 0;
33133
33134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33135   arg2 = (int)jarg2;
33136   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33137   if(!darg) {
33138     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33139     return;
33140   }
33141   {
33142     try {
33143       if(darg) {
33144         (darg)->OnSceneConnectionSwigPublic(arg2);
33145       }
33146     } CALL_CATCH_EXCEPTION();
33147   }
33148
33149 }
33150
33151
33152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
33153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33154   SwigDirector_ViewImpl *darg = 0;
33155
33156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33158   if(!darg) {
33159     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33160     return;
33161   }
33162   {
33163     try {
33164       if(darg) {
33165         (darg)->OnSceneDisconnection();
33166       }
33167     } CALL_CATCH_EXCEPTION();
33168   }
33169
33170 }
33171
33172
33173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
33174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33175   SwigDirector_ViewImpl *darg = 0;
33176
33177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33178   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33179   if(!darg) {
33180     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33181     return;
33182   }
33183   {
33184     try {
33185       if(darg) {
33186         (darg)->OnSceneDisconnectionSwigPublic();
33187       }
33188     } CALL_CATCH_EXCEPTION();
33189   }
33190
33191 }
33192
33193
33194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
33195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33196   Dali::Actor *arg2 = 0 ;
33197   SwigDirector_ViewImpl *darg = 0;
33198
33199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33200   arg2 = (Dali::Actor *)jarg2;
33201   if (!arg2) {
33202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33203     return ;
33204   }
33205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33206   if(!darg) {
33207     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33208     return;
33209   }
33210   {
33211     try {
33212       if(darg) {
33213         (darg)->OnChildAdd(*arg2);
33214       }
33215     } CALL_CATCH_EXCEPTION();
33216   }
33217
33218 }
33219
33220
33221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
33222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33223   Dali::Actor *arg2 = 0 ;
33224   SwigDirector_ViewImpl *darg = 0;
33225
33226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33227   arg2 = (Dali::Actor *)jarg2;
33228   if (!arg2) {
33229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33230     return ;
33231   }
33232   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33233   if(!darg) {
33234     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33235     return;
33236   }
33237   {
33238     try {
33239       if(darg) {
33240           (darg)->OnChildAddSwigPublic(*arg2);
33241       }
33242     } CALL_CATCH_EXCEPTION();
33243   }
33244
33245 }
33246
33247
33248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
33249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33250   Dali::Actor *arg2 = 0 ;
33251   SwigDirector_ViewImpl *darg = 0;
33252
33253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33254   arg2 = (Dali::Actor *)jarg2;
33255   if (!arg2) {
33256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33257     return ;
33258   }
33259   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33260   if(!darg) {
33261     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33262     return;
33263   }
33264   {
33265     try {
33266       if(darg) {
33267         (darg)->OnChildRemove(*arg2);
33268       }
33269     } CALL_CATCH_EXCEPTION();
33270   }
33271
33272 }
33273
33274
33275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
33276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33277   Dali::Actor *arg2 = 0 ;
33278   SwigDirector_ViewImpl *darg = 0;
33279
33280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33281   arg2 = (Dali::Actor *)jarg2;
33282   if (!arg2) {
33283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33284     return ;
33285   }
33286   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33287   if(!darg) {
33288     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33289     return;
33290   }
33291   {
33292     try {
33293       if(darg) {
33294         (darg)->OnChildRemoveSwigPublic(*arg2);
33295       }
33296     } CALL_CATCH_EXCEPTION();
33297   }
33298
33299 }
33300
33301
33302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
33303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33304   Dali::Property::Index arg2 ;
33305   Dali::Property::Value arg3 ;
33306   Dali::Property::Value *argp3 ;
33307   SwigDirector_ViewImpl *darg = 0;
33308
33309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33310   arg2 = (Dali::Property::Index)jarg2;
33311   argp3 = (Dali::Property::Value *)jarg3;
33312   if (!argp3) {
33313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
33314     return ;
33315   }
33316   arg3 = *argp3;
33317   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33318   if (!darg) {
33319     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33320     return;
33321   }
33322   {
33323     try {
33324       (darg)->OnPropertySet(arg2,arg3);
33325     } CALL_CATCH_EXCEPTION();
33326   }
33327
33328 }
33329
33330
33331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
33332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33333   Dali::Vector3 *arg2 = 0 ;
33334   SwigDirector_ViewImpl *darg = 0;
33335
33336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33337   arg2 = (Dali::Vector3 *)jarg2;
33338   if (!arg2) {
33339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33340     return ;
33341   }
33342   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33343   if (!darg) {
33344     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33345     return;
33346   }
33347   {
33348     try {
33349       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
33350     } CALL_CATCH_EXCEPTION();
33351   }
33352
33353 }
33354
33355
33356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
33357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33358   Dali::Vector3 *arg2 = 0 ;
33359   SwigDirector_ViewImpl *darg = 0;
33360
33361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33362   arg2 = (Dali::Vector3 *)jarg2;
33363   if (!arg2) {
33364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33365     return ;
33366   }
33367   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33368   if (!darg) {
33369     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33370     return;
33371   }
33372   {
33373     try {
33374       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
33375     } CALL_CATCH_EXCEPTION();
33376   }
33377
33378 }
33379
33380
33381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
33382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33383   Dali::Animation *arg2 = 0 ;
33384   Dali::Vector3 *arg3 = 0 ;
33385   SwigDirector_ViewImpl *darg = 0;
33386
33387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33388   arg2 = (Dali::Animation *)jarg2;
33389   if (!arg2) {
33390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
33391     return ;
33392   }
33393   arg3 = (Dali::Vector3 *)jarg3;
33394   if (!arg3) {
33395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33396     return ;
33397   }
33398   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33399   if (!darg) {
33400     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33401     return;
33402   }
33403   {
33404     try {
33405       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
33406     } CALL_CATCH_EXCEPTION();
33407   }
33408
33409 }
33410
33411
33412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
33413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33414   Dali::Animation *arg2 = 0 ;
33415   Dali::Vector3 *arg3 = 0 ;
33416   SwigDirector_ViewImpl *darg = 0;
33417
33418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33419   arg2 = (Dali::Animation *)jarg2;
33420   if (!arg2) {
33421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
33422     return ;
33423   }
33424   arg3 = (Dali::Vector3 *)jarg3;
33425   if (!arg3) {
33426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33427     return ;
33428   }
33429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33430   if (!darg) {
33431     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33432     return;
33433   }
33434   {
33435     try {
33436       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
33437     } CALL_CATCH_EXCEPTION();
33438   }
33439 }
33440
33441 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
33442   bool jresult ;
33443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33444   Dali::KeyEvent *arg2 = 0 ;
33445   SwigDirector_ViewImpl *darg = 0;
33446   bool result;
33447
33448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33449   arg2 = (Dali::KeyEvent *)jarg2;
33450   if (!arg2) {
33451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
33452     return 0;
33453   }
33454   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33455   if (!darg) {
33456     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33457     return 0;
33458   }
33459   {
33460     try {
33461       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
33462     } CALL_CATCH_EXCEPTION(0);
33463   }
33464
33465   jresult = result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
33471   bool jresult ;
33472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33473   Dali::KeyEvent *arg2 = 0 ;
33474   SwigDirector_ViewImpl *darg = 0;
33475   bool result;
33476
33477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33478   arg2 = (Dali::KeyEvent *)jarg2;
33479   if (!arg2) {
33480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
33481     return 0;
33482   }
33483   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33484   if (!darg) {
33485     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33486     return 0;
33487   }
33488   {
33489     try {
33490       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
33491     } CALL_CATCH_EXCEPTION(0);
33492   }
33493
33494   jresult = result;
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
33500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33501   Dali::Vector2 *arg2 = 0 ;
33502   Dali::RelayoutContainer *arg3 = 0 ;
33503   SwigDirector_ViewImpl *darg = 0;
33504
33505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33506   arg2 = (Dali::Vector2 *)jarg2;
33507   if (!arg2) {
33508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33509     return ;
33510   }
33511   arg3 = (Dali::RelayoutContainer *)jarg3;
33512   if (!arg3) {
33513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
33514     return ;
33515   }
33516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33517   if (!darg) {
33518     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33519     return;
33520   }
33521   {
33522     try {
33523       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
33524     } CALL_CATCH_EXCEPTION();
33525   }
33526
33527 }
33528
33529
33530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
33531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33532   Dali::Vector2 *arg2 = 0 ;
33533   Dali::RelayoutContainer *arg3 = 0 ;
33534   SwigDirector_ViewImpl *darg = 0;
33535
33536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33537   arg2 = (Dali::Vector2 *)jarg2;
33538   if (!arg2) {
33539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33540     return ;
33541   }
33542   arg3 = (Dali::RelayoutContainer *)jarg3;
33543   if (!arg3) {
33544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
33545     return ;
33546   }
33547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33548   if (!darg) {
33549     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33550     return;
33551   }
33552   {
33553     try {
33554       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
33555     } CALL_CATCH_EXCEPTION();
33556   }
33557
33558 }
33559
33560
33561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
33562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33563   Dali::ResizePolicy::Type arg2 ;
33564   Dali::Dimension::Type arg3 ;
33565   SwigDirector_ViewImpl *darg = 0;
33566
33567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33568   arg2 = (Dali::ResizePolicy::Type)jarg2;
33569   arg3 = (Dali::Dimension::Type)jarg3;
33570   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33571   if (!darg) {
33572     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33573     return;
33574   }
33575   {
33576     try {
33577       (darg)->OnSetResizePolicy(arg2,arg3);
33578     } CALL_CATCH_EXCEPTION();
33579   }
33580
33581 }
33582
33583
33584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
33585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33586   Dali::ResizePolicy::Type arg2 ;
33587   Dali::Dimension::Type arg3 ;
33588   SwigDirector_ViewImpl *darg = 0;
33589
33590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33591   arg2 = (Dali::ResizePolicy::Type)jarg2;
33592   arg3 = (Dali::Dimension::Type)jarg3;
33593   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33594   if (!darg) {
33595     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33596     return;
33597   }
33598   {
33599     try {
33600       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
33601     } CALL_CATCH_EXCEPTION();
33602   }
33603
33604 }
33605
33606
33607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
33608   void * jresult ;
33609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33610   SwigDirector_ViewImpl *darg = 0;
33611   Dali::Vector3 result;
33612
33613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33615   if (!darg) {
33616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33617     return 0;
33618   }
33619   {
33620     try {
33621       result = (darg)->GetNaturalSize();
33622     } CALL_CATCH_EXCEPTION(0);
33623   }
33624
33625   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
33626   return jresult;
33627 }
33628
33629
33630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
33631   void * jresult ;
33632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33633   SwigDirector_ViewImpl *darg = 0;
33634   Dali::Vector3 result;
33635
33636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33637   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33638   if (!darg) {
33639     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33640     return 0;
33641   }
33642   {
33643     try {
33644       result = (darg)->GetNaturalSizeSwigPublic();
33645     } CALL_CATCH_EXCEPTION(0);
33646   }
33647
33648   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
33649   return jresult;
33650 }
33651
33652
33653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
33654   float jresult ;
33655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33656   Dali::Actor *arg2 = 0 ;
33657   Dali::Dimension::Type arg3 ;
33658   SwigDirector_ViewImpl *darg = 0;
33659   float result;
33660
33661   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33662   arg2 = (Dali::Actor *)jarg2;
33663   if (!arg2) {
33664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33665     return 0;
33666   }
33667   arg3 = (Dali::Dimension::Type)jarg3;
33668   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33669   if (!darg) {
33670     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33671     return 0;
33672   }
33673   {
33674     try {
33675       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
33676     } CALL_CATCH_EXCEPTION(0);
33677   }
33678
33679   jresult = result;
33680   return jresult;
33681 }
33682
33683
33684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
33685   float jresult ;
33686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33687   Dali::Actor *arg2 = 0 ;
33688   Dali::Dimension::Type arg3 ;
33689   SwigDirector_ViewImpl *darg = 0;
33690   float result;
33691
33692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33693   arg2 = (Dali::Actor *)jarg2;
33694   if (!arg2) {
33695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33696     return 0;
33697   }
33698   arg3 = (Dali::Dimension::Type)jarg3;
33699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33700   if (!darg) {
33701     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33702     return 0;
33703   }
33704   {
33705     try {
33706       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
33707     } CALL_CATCH_EXCEPTION(0);
33708   }
33709
33710   jresult = result;
33711   return jresult;
33712 }
33713
33714
33715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
33716   float jresult ;
33717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33718   float arg2 ;
33719   SwigDirector_ViewImpl *darg = 0;
33720   float result;
33721
33722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33723   arg2 = (float)jarg2;
33724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33725   if (!darg) {
33726     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33727     return 0;
33728   }
33729   {
33730     try {
33731       result = (float)(darg)->GetHeightForWidth(arg2);
33732     } CALL_CATCH_EXCEPTION(0);
33733   }
33734
33735   jresult = result;
33736   return jresult;
33737 }
33738
33739
33740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
33741   float jresult ;
33742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33743   float arg2 ;
33744   SwigDirector_ViewImpl *darg = 0;
33745   float result;
33746
33747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33748   arg2 = (float)jarg2;
33749   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33750   if (!darg) {
33751     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33752     return 0;
33753   }
33754   {
33755     try {
33756       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
33757     } CALL_CATCH_EXCEPTION(0);
33758   }
33759
33760   jresult = result;
33761   return jresult;
33762 }
33763
33764
33765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
33766   float jresult ;
33767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33768   float arg2 ;
33769   SwigDirector_ViewImpl *darg = 0;
33770   float result;
33771
33772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33773   arg2 = (float)jarg2;
33774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33775   if (!darg) {
33776     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33777     return 0;
33778   }
33779   {
33780     try {
33781       result = (float)(darg)->GetWidthForHeight(arg2);
33782     } CALL_CATCH_EXCEPTION(0);
33783   }
33784
33785   jresult = result;
33786   return jresult;
33787 }
33788
33789
33790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
33791   float jresult ;
33792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33793   float arg2 ;
33794   SwigDirector_ViewImpl *darg = 0;
33795   float result;
33796
33797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33798   arg2 = (float)jarg2;
33799   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33800   if (!darg) {
33801     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33802     return 0;
33803   }
33804   {
33805     try {
33806       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
33807     } CALL_CATCH_EXCEPTION(0);
33808   }
33809
33810   jresult = result;
33811   return jresult;
33812 }
33813
33814
33815 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
33816   bool jresult ;
33817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33818   Dali::Dimension::Type arg2 ;
33819   SwigDirector_ViewImpl *darg = 0;
33820   bool result;
33821
33822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33823   arg2 = (Dali::Dimension::Type)jarg2;
33824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33825   if (!darg) {
33826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33827     return 0;
33828   }
33829   {
33830     try {
33831       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
33832     } CALL_CATCH_EXCEPTION(0);
33833   }
33834
33835   jresult = result;
33836   return jresult;
33837 }
33838
33839
33840 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
33841   bool jresult ;
33842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33843   Dali::Dimension::Type arg2 ;
33844   SwigDirector_ViewImpl *darg = 0;
33845   bool result;
33846
33847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33848   arg2 = (Dali::Dimension::Type)jarg2;
33849   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33850   if (!darg) {
33851     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33852     return 0;
33853   }
33854   {
33855     try {
33856       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
33857     } CALL_CATCH_EXCEPTION(0);
33858   }
33859
33860   jresult = result;
33861   return jresult;
33862 }
33863
33864
33865 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
33866   bool jresult ;
33867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33868   SwigDirector_ViewImpl *darg = 0;
33869   bool result;
33870
33871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33872   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33873   if (!darg) {
33874     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33875     return 0;
33876   }
33877   {
33878     try {
33879       result = (bool)(darg)->RelayoutDependentOnChildren();
33880     } CALL_CATCH_EXCEPTION(0);
33881   }
33882
33883   jresult = result;
33884   return jresult;
33885 }
33886
33887
33888 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
33889   bool jresult ;
33890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33891   SwigDirector_ViewImpl *darg = 0;
33892   bool result;
33893
33894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33896   if (!darg) {
33897     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33898     return 0;
33899   }
33900   {
33901     try {
33902       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
33903     } CALL_CATCH_EXCEPTION(0);
33904   }
33905
33906   jresult = result;
33907   return jresult;
33908 }
33909
33910
33911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
33912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33913   Dali::Dimension::Type arg2 ;
33914   SwigDirector_ViewImpl *darg = 0;
33915
33916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33917   arg2 = (Dali::Dimension::Type)jarg2;
33918   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33919   if (!darg) {
33920     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33921     return;
33922   }
33923   {
33924     try {
33925       (darg)->OnCalculateRelayoutSize(arg2);
33926     } CALL_CATCH_EXCEPTION();
33927   }
33928
33929 }
33930
33931
33932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
33933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33934   Dali::Dimension::Type arg2 ;
33935   SwigDirector_ViewImpl *darg = 0;
33936
33937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33938   arg2 = (Dali::Dimension::Type)jarg2;
33939   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33940   if (!darg) {
33941     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33942     return;
33943   }
33944   {
33945     try {
33946       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
33947     } CALL_CATCH_EXCEPTION();
33948   }
33949
33950 }
33951
33952
33953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
33954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33955   float arg2 ;
33956   Dali::Dimension::Type arg3 ;
33957   SwigDirector_ViewImpl *darg = 0;
33958
33959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33960   arg2 = (float)jarg2;
33961   arg3 = (Dali::Dimension::Type)jarg3;
33962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33963   if (!darg) {
33964     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33965     return;
33966   }
33967   {
33968     try {
33969       (darg)->OnLayoutNegotiated(arg2,arg3);
33970     } CALL_CATCH_EXCEPTION();
33971   }
33972
33973 }
33974
33975
33976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
33977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
33978   float arg2 ;
33979   Dali::Dimension::Type arg3 ;
33980   SwigDirector_ViewImpl *darg = 0;
33981
33982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
33983   arg2 = (float)jarg2;
33984   arg3 = (Dali::Dimension::Type)jarg3;
33985   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
33986   if (!darg) {
33987     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
33988     return;
33989   }
33990   {
33991     try {
33992       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
33993     } CALL_CATCH_EXCEPTION();
33994   }
33995
33996 }
33997
33998
33999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
34000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34001
34002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34003   {
34004     try {
34005       (arg1)->OnInitialize();
34006     } CALL_CATCH_EXCEPTION();
34007   }
34008
34009 }
34010
34011
34012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
34013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34014
34015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34016   {
34017     try {
34018       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
34019     } CALL_CATCH_EXCEPTION();
34020   }
34021
34022 }
34023
34024
34025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
34026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34027   Dali::Toolkit::StyleManager arg2 ;
34028   Dali::StyleChange::Type arg3 ;
34029   Dali::Toolkit::StyleManager *argp2 ;
34030
34031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34032   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
34033   if (!argp2) {
34034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
34035     return ;
34036   }
34037   arg2 = *argp2;
34038   arg3 = (Dali::StyleChange::Type)jarg3;
34039   {
34040     try {
34041       (arg1)->OnStyleChange(arg2,arg3);
34042     } CALL_CATCH_EXCEPTION();
34043   }
34044
34045 }
34046
34047
34048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
34049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34050   Dali::Toolkit::StyleManager arg2 ;
34051   Dali::StyleChange::Type arg3 ;
34052   Dali::Toolkit::StyleManager *argp2 ;
34053
34054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34055   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
34056   if (!argp2) {
34057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
34058     return ;
34059   }
34060   arg2 = *argp2;
34061   arg3 = (Dali::StyleChange::Type)jarg3;
34062   {
34063     try {
34064       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
34065     } CALL_CATCH_EXCEPTION();
34066   }
34067
34068 }
34069
34070
34071 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
34072   bool jresult ;
34073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34074   bool result;
34075
34076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34077   {
34078     try {
34079       result = (bool)(arg1)->OnAccessibilityActivated();
34080     } CALL_CATCH_EXCEPTION(0);
34081   }
34082
34083   jresult = result;
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
34089   bool jresult ;
34090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34091   bool result;
34092
34093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34094   {
34095     try {
34096       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
34097     } CALL_CATCH_EXCEPTION(0);
34098   }
34099
34100   jresult = result;
34101   return jresult;
34102 }
34103
34104
34105 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
34106   bool jresult ;
34107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34108   Dali::PanGesture arg2 ;
34109   Dali::PanGesture *argp2 ;
34110   bool result;
34111
34112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34113   argp2 = (Dali::PanGesture *)jarg2;
34114   if (!argp2) {
34115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
34116     return 0;
34117   }
34118   arg2 = *argp2;
34119   {
34120     try {
34121       result = (bool)(arg1)->OnAccessibilityPan(arg2);
34122     } CALL_CATCH_EXCEPTION(0);
34123   }
34124
34125   jresult = result;
34126   return jresult;
34127 }
34128
34129
34130 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34131   bool jresult ;
34132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34133   Dali::PanGesture arg2 ;
34134   Dali::PanGesture *argp2 ;
34135   bool result;
34136
34137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34138   argp2 = (Dali::PanGesture *)jarg2;
34139   if (!argp2) {
34140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
34141     return 0;
34142   }
34143   arg2 = *argp2;
34144   {
34145     try {
34146       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
34147     } CALL_CATCH_EXCEPTION(0);
34148   }
34149
34150   jresult = result;
34151   return jresult;
34152 }
34153
34154 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
34155   bool jresult ;
34156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34157   bool arg2 ;
34158   bool result;
34159
34160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34161   arg2 = jarg2 ? true : false;
34162   {
34163     try {
34164       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
34165     } CALL_CATCH_EXCEPTION(0);
34166   }
34167
34168   jresult = result;
34169   return jresult;
34170 }
34171
34172
34173 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
34174   bool jresult ;
34175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34176   bool arg2 ;
34177   bool result;
34178
34179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34180   arg2 = jarg2 ? true : false;
34181   {
34182     try {
34183       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
34184     } CALL_CATCH_EXCEPTION(0);
34185   }
34186
34187   jresult = result;
34188   return jresult;
34189 }
34190
34191
34192 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
34193   bool jresult ;
34194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34195   bool result;
34196
34197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34198   {
34199     try {
34200       result = (bool)(arg1)->OnAccessibilityZoom();
34201     } CALL_CATCH_EXCEPTION(0);
34202   }
34203
34204   jresult = result;
34205   return jresult;
34206 }
34207
34208
34209 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
34210   bool jresult ;
34211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34212   bool result;
34213
34214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34215   {
34216     try {
34217       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
34218     } CALL_CATCH_EXCEPTION(0);
34219   }
34220
34221   jresult = result;
34222   return jresult;
34223 }
34224
34225
34226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
34227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34228
34229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34230   {
34231     try {
34232       (arg1)->OnKeyInputFocusGained();
34233     } CALL_CATCH_EXCEPTION();
34234   }
34235
34236 }
34237
34238
34239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
34240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34241
34242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34243   {
34244     try {
34245       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
34246     } CALL_CATCH_EXCEPTION();
34247   }
34248
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
34253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34254
34255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34256   {
34257     try {
34258       (arg1)->OnKeyInputFocusLost();
34259     } CALL_CATCH_EXCEPTION();
34260   }
34261
34262 }
34263
34264
34265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
34266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34267
34268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34269   {
34270     try {
34271       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
34272     } CALL_CATCH_EXCEPTION();
34273   }
34274
34275 }
34276
34277
34278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
34279   void * jresult ;
34280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34281   Dali::Actor arg2 ;
34282   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
34283   bool arg4 ;
34284   Dali::Actor *argp2 ;
34285   Dali::Actor result;
34286
34287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34288   argp2 = (Dali::Actor *)jarg2;
34289   if (!argp2) {
34290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34291     return 0;
34292   }
34293   arg2 = *argp2;
34294   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
34295   arg4 = jarg4 ? true : false;
34296   {
34297     try {
34298       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
34299     } CALL_CATCH_EXCEPTION(0);
34300   }
34301
34302   jresult = new Dali::Actor((const Dali::Actor &)result);
34303   return jresult;
34304 }
34305
34306
34307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
34308   void * jresult ;
34309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34310   Dali::Actor arg2 ;
34311   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
34312   bool arg4 ;
34313   Dali::Actor *argp2 ;
34314   Dali::Actor result;
34315
34316   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34317   argp2 = (Dali::Actor *)jarg2;
34318   if (!argp2) {
34319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34320     return 0;
34321   }
34322   arg2 = *argp2;
34323   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
34324   arg4 = jarg4 ? true : false;
34325   {
34326     try {
34327       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
34328     } CALL_CATCH_EXCEPTION(0);
34329   }
34330
34331   jresult = new Dali::Actor((const Dali::Actor &)result);
34332   return jresult;
34333 }
34334
34335
34336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
34337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34338   Dali::Actor arg2 ;
34339   Dali::Actor *argp2 ;
34340
34341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34342   argp2 = (Dali::Actor *)jarg2;
34343   if (!argp2) {
34344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34345     return ;
34346   }
34347   arg2 = *argp2;
34348   {
34349     try {
34350       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
34351     } CALL_CATCH_EXCEPTION();
34352   }
34353
34354 }
34355
34356
34357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34359   Dali::Actor arg2 ;
34360   Dali::Actor *argp2 ;
34361
34362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34363   argp2 = (Dali::Actor *)jarg2;
34364   if (!argp2) {
34365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34366     return ;
34367   }
34368   arg2 = *argp2;
34369   {
34370     try {
34371       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
34372     } CALL_CATCH_EXCEPTION();
34373   }
34374
34375 }
34376
34377
34378 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
34379   bool jresult ;
34380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34381   bool result;
34382
34383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34384   {
34385     try {
34386       result = (bool)(arg1)->OnKeyboardEnter();
34387     } CALL_CATCH_EXCEPTION(0);
34388   }
34389
34390   jresult = result;
34391   return jresult;
34392 }
34393
34394
34395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
34396   bool jresult ;
34397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34398   bool result;
34399
34400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34401   {
34402     try {
34403       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
34404     } CALL_CATCH_EXCEPTION(0);
34405   }
34406
34407   jresult = result;
34408   return jresult;
34409 }
34410
34411
34412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
34413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34414   Dali::PinchGesture *arg2 = 0 ;
34415
34416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34417   arg2 = (Dali::PinchGesture *)jarg2;
34418   if (!arg2) {
34419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34420     return ;
34421   }
34422   {
34423     try {
34424       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
34425     } CALL_CATCH_EXCEPTION();
34426   }
34427
34428 }
34429
34430
34431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34432   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34433   Dali::PinchGesture *arg2 = 0 ;
34434
34435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34436   arg2 = (Dali::PinchGesture *)jarg2;
34437   if (!arg2) {
34438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34439     return ;
34440   }
34441   {
34442     try {
34443       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
34444     } CALL_CATCH_EXCEPTION();
34445   }
34446
34447 }
34448
34449
34450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
34451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34452   Dali::PanGesture *arg2 = 0 ;
34453
34454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34455   arg2 = (Dali::PanGesture *)jarg2;
34456   if (!arg2) {
34457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
34458     return ;
34459   }
34460   {
34461     try {
34462       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
34463     } CALL_CATCH_EXCEPTION();
34464   }
34465
34466 }
34467
34468
34469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34471   Dali::PanGesture *arg2 = 0 ;
34472
34473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34474   arg2 = (Dali::PanGesture *)jarg2;
34475   if (!arg2) {
34476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
34477     return ;
34478   }
34479   {
34480     try {
34481       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
34482     } CALL_CATCH_EXCEPTION();
34483   }
34484
34485 }
34486
34487
34488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
34489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34490   Dali::TapGesture *arg2 = 0 ;
34491
34492   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34493   arg2 = (Dali::TapGesture *)jarg2;
34494   if (!arg2) {
34495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
34496     return ;
34497   }
34498   {
34499     try {
34500       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
34501     } CALL_CATCH_EXCEPTION();
34502   }
34503
34504 }
34505
34506
34507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34509   Dali::TapGesture *arg2 = 0 ;
34510
34511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34512   arg2 = (Dali::TapGesture *)jarg2;
34513   if (!arg2) {
34514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
34515     return ;
34516   }
34517   {
34518     try {
34519       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
34520     } CALL_CATCH_EXCEPTION();
34521   }
34522
34523 }
34524
34525
34526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
34527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34528   Dali::LongPressGesture *arg2 = 0 ;
34529
34530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34531   arg2 = (Dali::LongPressGesture *)jarg2;
34532   if (!arg2) {
34533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
34534     return ;
34535   }
34536   {
34537     try {
34538       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
34539     } CALL_CATCH_EXCEPTION();
34540   }
34541
34542 }
34543
34544
34545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
34546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34547   Dali::LongPressGesture *arg2 = 0 ;
34548
34549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34550   arg2 = (Dali::LongPressGesture *)jarg2;
34551   if (!arg2) {
34552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
34553     return ;
34554   }
34555   {
34556     try {
34557       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
34558     } CALL_CATCH_EXCEPTION();
34559   }
34560
34561 }
34562
34563
34564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
34565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34566   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
34567   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
34568
34569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34570   arg2 = (Dali::SlotObserver *)jarg2;
34571   arg3 = (Dali::CallbackBase *)jarg3;
34572   {
34573     try {
34574       (arg1)->SignalConnected(arg2,arg3);
34575     } CALL_CATCH_EXCEPTION();
34576   }
34577
34578 }
34579
34580
34581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
34582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34583   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
34584   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
34585
34586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34587   arg2 = (Dali::SlotObserver *)jarg2;
34588   arg3 = (Dali::CallbackBase *)jarg3;
34589   {
34590     try {
34591       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
34592     } CALL_CATCH_EXCEPTION();
34593   }
34594
34595 }
34596
34597
34598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
34599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34600   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
34601   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
34602
34603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34604   arg2 = (Dali::SlotObserver *)jarg2;
34605   arg3 = (Dali::CallbackBase *)jarg3;
34606   {
34607     try {
34608       (arg1)->SignalDisconnected(arg2,arg3);
34609     } CALL_CATCH_EXCEPTION();
34610   }
34611
34612 }
34613
34614
34615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
34616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
34617   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
34618   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
34619
34620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
34621   arg2 = (Dali::SlotObserver *)jarg2;
34622   arg3 = (Dali::CallbackBase *)jarg3;
34623   {
34624     try {
34625       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
34626     } CALL_CATCH_EXCEPTION();
34627   }
34628
34629 }
34630
34631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
34632   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
34633   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
34634   if (director) {
34635     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
34636   }
34637 }
34638
34639
34640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
34641   void * jresult ;
34642   Dali::Toolkit::Control *arg1 = 0 ;
34643   Dali::Toolkit::Internal::Control *result = 0 ;
34644
34645   arg1 = (Dali::Toolkit::Control *)jarg1;
34646   if (!arg1) {
34647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
34648     return 0;
34649   }
34650   {
34651     try {
34652       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
34653     } CALL_CATCH_EXCEPTION(0);
34654   }
34655
34656   jresult = (void *)result;
34657   return jresult;
34658 }
34659
34660
34661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
34662   int jresult ;
34663   int result;
34664
34665   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
34666   jresult = (int)result;
34667   return jresult;
34668 }
34669
34670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
34671   int jresult ;
34672   int result;
34673
34674   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
34675   jresult = (int)result;
34676   return jresult;
34677 }
34678
34679
34680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
34681   int jresult ;
34682   int result;
34683
34684   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
34685   jresult = (int)result;
34686   return jresult;
34687 }
34688
34689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
34690   int jresult ;
34691   int result;
34692
34693   result = (int)Dali::Toolkit::Control::Property::MARGIN;
34694   jresult = (int)result;
34695   return jresult;
34696 }
34697
34698
34699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
34700   int jresult ;
34701   int result;
34702
34703   result = (int)Dali::Toolkit::Control::Property::PADDING;
34704   jresult = (int)result;
34705   return jresult;
34706 }
34707
34708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
34709   int jresult ;
34710   int result;
34711
34712   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
34713   jresult = (int)result;
34714   return jresult;
34715 }
34716
34717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
34718   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
34719 }
34720
34721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
34722   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
34723 }
34724
34725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
34726   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
34727 }
34728
34729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
34730   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
34731 }
34732
34733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
34734   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
34735 }
34736
34737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
34738   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
34739 }
34740
34741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
34742   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
34743 }
34744
34745 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
34746   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
34747 }
34748
34749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
34750   void * jresult ;
34751   Dali::Toolkit::Control::Property *result = 0 ;
34752
34753   {
34754     try {
34755       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
34756     } CALL_CATCH_EXCEPTION(0);
34757   }
34758
34759   jresult = (void *)result;
34760   return jresult;
34761 }
34762
34763
34764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
34765   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
34766
34767   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
34768   {
34769     try {
34770       delete arg1;
34771     } CALL_CATCH_EXCEPTION();
34772   }
34773
34774 }
34775
34776
34777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
34778   void * jresult ;
34779   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
34780
34781   {
34782     try {
34783       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
34784     } CALL_CATCH_EXCEPTION(0);
34785   }
34786
34787   jresult = (void *)result;
34788   return jresult;
34789 }
34790
34791
34792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
34793   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
34794
34795   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
34796   {
34797     try {
34798       delete arg1;
34799     } CALL_CATCH_EXCEPTION();
34800   }
34801
34802 }
34803
34804
34805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
34806   void * jresult ;
34807   Dali::Toolkit::Control result;
34808
34809   {
34810     try {
34811       result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
34812     } CALL_CATCH_EXCEPTION(0);
34813   }
34814
34815   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
34816   return jresult;
34817 }
34818
34819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() {
34820   void * jresult;
34821   Dali::Toolkit::Control result;
34822
34823   {
34824     try {
34825       result = SlimCustomViewImpl::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
34826     } CALL_CATCH_EXCEPTION(0);
34827   }
34828
34829   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
34830   return jresult;
34831 }
34832
34833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
34834   void * jresult ;
34835   Dali::Toolkit::Control *result = 0 ;
34836
34837   {
34838     try {
34839       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
34840     } CALL_CATCH_EXCEPTION(0);
34841   }
34842
34843   jresult = (void *)result;
34844   return jresult;
34845 }
34846
34847
34848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
34849   void * jresult ;
34850   Dali::Toolkit::Control *arg1 = 0 ;
34851   Dali::Toolkit::Control *result = 0 ;
34852
34853   arg1 = (Dali::Toolkit::Control *)jarg1;
34854   if (!arg1) {
34855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
34856     return 0;
34857   }
34858   {
34859     try {
34860       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
34861     } CALL_CATCH_EXCEPTION(0);
34862   }
34863
34864   jresult = (void *)result;
34865   return jresult;
34866 }
34867
34868
34869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
34870   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34871
34872   arg1 = (Dali::Toolkit::Control *)jarg1;
34873   {
34874     try {
34875       delete arg1;
34876     } CALL_CATCH_EXCEPTION();
34877   }
34878
34879 }
34880
34881
34882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
34883   void * jresult ;
34884   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34885   Dali::Toolkit::Control *arg2 = 0 ;
34886   Dali::Toolkit::Control *result = 0 ;
34887
34888   arg1 = (Dali::Toolkit::Control *)jarg1;
34889   arg2 = (Dali::Toolkit::Control *)jarg2;
34890   if (!arg2) {
34891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
34892     return 0;
34893   }
34894   {
34895     try {
34896       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
34897     } CALL_CATCH_EXCEPTION(0);
34898   }
34899
34900   jresult = (void *)result;
34901   return jresult;
34902 }
34903
34904
34905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
34906   void * jresult ;
34907   Dali::BaseHandle arg1 ;
34908   Dali::BaseHandle *argp1 ;
34909   Dali::Toolkit::Control result;
34910
34911   argp1 = (Dali::BaseHandle *)jarg1;
34912   if (!argp1) {
34913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34914     return 0;
34915   }
34916   arg1 = *argp1;
34917   {
34918     try {
34919       result = Dali::Toolkit::Control::DownCast(arg1);
34920     } CALL_CATCH_EXCEPTION(0);
34921   }
34922
34923   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
34924   return jresult;
34925 }
34926
34927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
34928   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
34929   try {
34930     delete arg1;
34931   } CALL_CATCH_EXCEPTION();
34932 }
34933
34934
34935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
34936   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34937
34938   arg1 = (Dali::Toolkit::Control *)jarg1;
34939   {
34940     try {
34941       (arg1)->SetKeyInputFocus();
34942     } CALL_CATCH_EXCEPTION();
34943   }
34944
34945 }
34946
34947
34948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
34949   bool jresult ;
34950   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34951   bool result;
34952
34953   arg1 = (Dali::Toolkit::Control *)jarg1;
34954   {
34955     try {
34956       result = (bool)(arg1)->HasKeyInputFocus();
34957     } CALL_CATCH_EXCEPTION(0);
34958   }
34959
34960   jresult = result;
34961   return jresult;
34962 }
34963
34964
34965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
34966   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34967
34968   arg1 = (Dali::Toolkit::Control *)jarg1;
34969   {
34970     try {
34971       (arg1)->ClearKeyInputFocus();
34972     } CALL_CATCH_EXCEPTION();
34973   }
34974
34975 }
34976
34977
34978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
34979   void * jresult ;
34980   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34981   Dali::PinchGestureDetector result;
34982
34983   arg1 = (Dali::Toolkit::Control *)jarg1;
34984   {
34985     try {
34986       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
34987     } CALL_CATCH_EXCEPTION(0);
34988   }
34989
34990   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
34991   return jresult;
34992 }
34993
34994
34995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
34996   void * jresult ;
34997   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
34998   Dali::PanGestureDetector result;
34999
35000   arg1 = (Dali::Toolkit::Control *)jarg1;
35001   {
35002     try {
35003       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
35004     } CALL_CATCH_EXCEPTION(0);
35005   }
35006
35007   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35008   return jresult;
35009 }
35010
35011
35012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
35013   void * jresult ;
35014   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35015   Dali::TapGestureDetector result;
35016
35017   arg1 = (Dali::Toolkit::Control *)jarg1;
35018   {
35019     try {
35020       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
35021     } CALL_CATCH_EXCEPTION(0);
35022   }
35023
35024   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35025   return jresult;
35026 }
35027
35028
35029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
35030   void * jresult ;
35031   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35032   Dali::LongPressGestureDetector result;
35033
35034   arg1 = (Dali::Toolkit::Control *)jarg1;
35035   {
35036     try {
35037       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
35038     } CALL_CATCH_EXCEPTION(0);
35039   }
35040
35041   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
35047   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35048   std::string *arg2 = 0 ;
35049
35050   arg1 = (Dali::Toolkit::Control *)jarg1;
35051   if (!jarg2) {
35052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35053     return ;
35054   }
35055   std::string arg2_str(jarg2);
35056   arg2 = &arg2_str;
35057   {
35058     try {
35059       (arg1)->SetStyleName((std::string const &)*arg2);
35060     } CALL_CATCH_EXCEPTION();
35061   }
35062
35063
35064   //argout typemap for const std::string&
35065
35066 }
35067
35068
35069 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
35070   char * jresult ;
35071   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35072   std::string *result = 0 ;
35073
35074   arg1 = (Dali::Toolkit::Control *)jarg1;
35075   {
35076     try {
35077       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
35078     } CALL_CATCH_EXCEPTION(0);
35079   }
35080
35081   jresult = SWIG_csharp_string_callback(result->c_str());
35082   return jresult;
35083 }
35084
35085
35086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
35087   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35088   Dali::Vector4 *arg2 = 0 ;
35089
35090   arg1 = (Dali::Toolkit::Control *)jarg1;
35091   arg2 = (Dali::Vector4 *)jarg2;
35092   if (!arg2) {
35093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35094     return ;
35095   }
35096   {
35097     try {
35098       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35099     } CALL_CATCH_EXCEPTION();
35100   }
35101
35102 }
35103
35104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
35105   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35106
35107   arg1 = (Dali::Toolkit::Control *)jarg1;
35108   {
35109     try {
35110       (arg1)->ClearBackground();
35111     } CALL_CATCH_EXCEPTION();
35112   }
35113
35114 }
35115
35116 #ifndef GENERATE_CONTROL_SIGNAL
35117 #define GENERATE_CONTROL_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Toolkit::Control*, HType, Dali_View, SignalName)
35118 #endif
35119
35120 GENERATE_CONTROL_SIGNAL(bool(*)(Dali::Toolkit::Control, Dali::KeyEvent const&), KeyEventSignal)
35121 // CSharp_Dali_View_KeyEventSignal_Connect
35122 // CSharp_Dali_View_KeyEventSignal_Disconnect
35123
35124 GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusGainedSignal)
35125 // CSharp_Dali_View_KeyInputFocusGainedSignal_Connect
35126 // CSharp_Dali_View_KeyInputFocusGainedSignal_Disconnect
35127
35128 GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusLostSignal)
35129 // CSharp_Dali_View_KeyInputFocusLostSignal_Connect
35130 // CSharp_Dali_View_KeyInputFocusLostSignal_Disconnect
35131
35132 GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), ResourceReadySignal)
35133 // CSharp_Dali_View_ResourceReadySignal_Connect
35134 // CSharp_Dali_View_ResourceReadySignal_Disconnect
35135
35136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
35137   void * jresult ;
35138   Dali::Toolkit::Internal::Control *arg1 = 0 ;
35139   Dali::Toolkit::Control *result = 0 ;
35140
35141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35142   if (!arg1) {
35143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
35144     return 0;
35145   }
35146   {
35147     try {
35148       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
35149     } CALL_CATCH_EXCEPTION(0);
35150   }
35151
35152   jresult = (void *)result;
35153   return jresult;
35154 }
35155
35156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
35157 {
35158   int jresult;
35159   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35160   arg1 = (Dali::Toolkit::Control *)jarg1;
35161
35162   if (!arg1) {
35163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
35164     return 0;
35165   }
35166
35167   Dali::Property::Index arg2 = 0 ;
35168   arg2 = (Dali::Property::Index)jarg2;
35169
35170   Toolkit::Visual::ResourceStatus result;
35171   {
35172     try {
35173       result = arg1->GetVisualResourceStatus(arg2);
35174     } CALL_CATCH_EXCEPTION(0);
35175   }
35176
35177   jresult = (int)result;
35178   return jresult;
35179 }
35180
35181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
35182 {
35183   void * jresult;
35184   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
35185   arg1 = (Dali::Toolkit::Control *)jarg1;
35186
35187   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
35188
35189   Dali::Toolkit::TransitionData *arg2 = 0 ;
35190   Dali::Animation result;
35191
35192   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35193   if (!arg2) {
35194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35195     return 0;
35196   }
35197   {
35198     try {
35199       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
35200     } CALL_CATCH_EXCEPTION(0);
35201   }
35202
35203   jresult = new Dali::Animation((const Dali::Animation &)result);
35204   return jresult;
35205 }
35206
35207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
35208 {
35209   Dali::Toolkit::Control arg1;
35210   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
35211
35212   if (!argp1) {
35213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
35214   }
35215   arg1 = *argp1;
35216
35217   Dali::Property::Index arg2 = 0 ;
35218   arg2 = (Dali::Property::Index)jarg2;
35219
35220   Dali::Property::Index arg3 = 0 ;
35221   arg3 = (Dali::Property::Index)jarg3;
35222
35223   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
35224
35225   {
35226     try {
35227       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
35228     } CALL_CATCH_EXCEPTION();
35229   }
35230 }
35231
35232 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
35233 {
35234   if (!control)
35235   {
35236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
35237     return 0;
35238   }
35239
35240   void* result = 0;
35241   try
35242   {
35243     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
35244     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
35245   }
35246   CALL_CATCH_EXCEPTION(0);
35247
35248   return result;
35249 }
35250
35251 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
35252   bool jresult ;
35253   Dali::Toolkit::Control *arg1 = 0 ;
35254   bool result;
35255
35256   arg1 = (Dali::Toolkit::Control *)jarg1;
35257   if (!arg1) {
35258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
35259     return 0;
35260   }
35261   {
35262     try {
35263       result = (bool)arg1->IsResourceReady();
35264     } CALL_CATCH_EXCEPTION(0);
35265   }
35266
35267   jresult = result;
35268   return jresult;
35269 }
35270
35271
35272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
35273   void * jresult ;
35274   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
35275
35276   {
35277     try {
35278       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
35279     } CALL_CATCH_EXCEPTION(0);
35280   }
35281
35282   jresult = (void *)result;
35283   return jresult;
35284 }
35285
35286
35287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
35288   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
35289
35290   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
35291   {
35292     try {
35293       delete arg1;
35294     } CALL_CATCH_EXCEPTION();
35295   }
35296
35297 }
35298
35299
35300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
35301   void * jresult ;
35302   Dali::Toolkit::KeyInputFocusManager result;
35303
35304   {
35305     try {
35306       result = Dali::Toolkit::KeyInputFocusManager::Get();
35307     } CALL_CATCH_EXCEPTION(0);
35308   }
35309
35310   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
35311   return jresult;
35312 }
35313
35314
35315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
35316   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
35317   Dali::Toolkit::Control arg2 ;
35318   Dali::Toolkit::Control *argp2 ;
35319
35320   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
35321   argp2 = (Dali::Toolkit::Control *)jarg2;
35322   if (!argp2) {
35323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
35324     return ;
35325   }
35326   arg2 = *argp2;
35327   {
35328     try {
35329       (arg1)->SetFocus(arg2);
35330     } CALL_CATCH_EXCEPTION();
35331   }
35332
35333 }
35334
35335
35336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
35337   void * jresult ;
35338   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
35339   Dali::Toolkit::Control result;
35340
35341   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
35342   {
35343     try {
35344       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
35345     } CALL_CATCH_EXCEPTION(0);
35346   }
35347
35348   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35349   return jresult;
35350 }
35351
35352
35353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
35354   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
35355   Dali::Toolkit::Control arg2 ;
35356   Dali::Toolkit::Control *argp2 ;
35357
35358   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
35359   argp2 = (Dali::Toolkit::Control *)jarg2;
35360   if (!argp2) {
35361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
35362     return ;
35363   }
35364   arg2 = *argp2;
35365   {
35366     try {
35367       (arg1)->RemoveFocus(arg2);
35368     } CALL_CATCH_EXCEPTION();
35369   }
35370
35371 }
35372
35373
35374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
35375   void * jresult ;
35376   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
35377   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
35378
35379   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
35380   {
35381     try {
35382       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
35383     } CALL_CATCH_EXCEPTION(0);
35384   }
35385
35386   jresult = (void *)result;
35387   return jresult;
35388 }
35389
35390
35391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
35392   void * jresult ;
35393   Dali::Toolkit::Alignment::Padding *result = 0 ;
35394
35395   {
35396     try {
35397       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
35398     } CALL_CATCH_EXCEPTION(0);
35399   }
35400
35401   jresult = (void *)result;
35402   return jresult;
35403 }
35404
35405
35406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
35407   void * jresult ;
35408   float arg1 ;
35409   float arg2 ;
35410   float arg3 ;
35411   float arg4 ;
35412   Dali::Toolkit::Alignment::Padding *result = 0 ;
35413
35414   arg1 = (float)jarg1;
35415   arg2 = (float)jarg2;
35416   arg3 = (float)jarg3;
35417   arg4 = (float)jarg4;
35418   {
35419     try {
35420       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
35421     } CALL_CATCH_EXCEPTION(0);
35422   }
35423
35424   jresult = (void *)result;
35425   return jresult;
35426 }
35427
35428
35429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
35430   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35431   float arg2 ;
35432
35433   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35434   arg2 = (float)jarg2;
35435   if (arg1) (arg1)->left = arg2;
35436 }
35437
35438
35439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
35440   float jresult ;
35441   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35442   float result;
35443
35444   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35445   result = (float) ((arg1)->left);
35446   jresult = result;
35447   return jresult;
35448 }
35449
35450
35451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
35452   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35453   float arg2 ;
35454
35455   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35456   arg2 = (float)jarg2;
35457   if (arg1) (arg1)->right = arg2;
35458 }
35459
35460
35461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
35462   float jresult ;
35463   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35464   float result;
35465
35466   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35467   result = (float) ((arg1)->right);
35468   jresult = result;
35469   return jresult;
35470 }
35471
35472
35473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
35474   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35475   float arg2 ;
35476
35477   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35478   arg2 = (float)jarg2;
35479   if (arg1) (arg1)->top = arg2;
35480 }
35481
35482
35483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
35484   float jresult ;
35485   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35486   float result;
35487
35488   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35489   result = (float) ((arg1)->top);
35490   jresult = result;
35491   return jresult;
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
35496   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35497   float arg2 ;
35498
35499   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35500   arg2 = (float)jarg2;
35501   if (arg1) (arg1)->bottom = arg2;
35502 }
35503
35504
35505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
35506   float jresult ;
35507   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35508   float result;
35509
35510   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35511   result = (float) ((arg1)->bottom);
35512   jresult = result;
35513   return jresult;
35514 }
35515
35516
35517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
35518   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
35519
35520   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
35521   {
35522     try {
35523       delete arg1;
35524     } CALL_CATCH_EXCEPTION();
35525   }
35526
35527 }
35528
35529
35530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
35531   void * jresult ;
35532   Dali::Toolkit::Alignment *result = 0 ;
35533
35534   {
35535     try {
35536       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
35537     } CALL_CATCH_EXCEPTION(0);
35538   }
35539
35540   jresult = (void *)result;
35541   return jresult;
35542 }
35543
35544
35545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
35546   void * jresult ;
35547   Dali::Toolkit::Alignment::Type arg1 ;
35548   Dali::Toolkit::Alignment::Type arg2 ;
35549   Dali::Toolkit::Alignment result;
35550
35551   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
35552   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
35553   {
35554     try {
35555       result = Dali::Toolkit::Alignment::New(arg1,arg2);
35556     } CALL_CATCH_EXCEPTION(0);
35557   }
35558
35559   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
35560   return jresult;
35561 }
35562
35563
35564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
35565   void * jresult ;
35566   Dali::Toolkit::Alignment::Type arg1 ;
35567   Dali::Toolkit::Alignment result;
35568
35569   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
35570   {
35571     try {
35572       result = Dali::Toolkit::Alignment::New(arg1);
35573     } CALL_CATCH_EXCEPTION(0);
35574   }
35575
35576   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
35577   return jresult;
35578 }
35579
35580
35581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
35582   void * jresult ;
35583   Dali::Toolkit::Alignment result;
35584
35585   {
35586     try {
35587       result = Dali::Toolkit::Alignment::New();
35588     } CALL_CATCH_EXCEPTION(0);
35589   }
35590
35591   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
35597   void * jresult ;
35598   Dali::Toolkit::Alignment *arg1 = 0 ;
35599   Dali::Toolkit::Alignment *result = 0 ;
35600
35601   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35602   if (!arg1) {
35603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
35604     return 0;
35605   }
35606   {
35607     try {
35608       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
35609     } CALL_CATCH_EXCEPTION(0);
35610   }
35611
35612   jresult = (void *)result;
35613   return jresult;
35614 }
35615
35616
35617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
35618   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35619
35620   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35621   {
35622     try {
35623       delete arg1;
35624     } CALL_CATCH_EXCEPTION();
35625   }
35626
35627 }
35628
35629
35630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
35631   void * jresult ;
35632   Dali::BaseHandle arg1 ;
35633   Dali::BaseHandle *argp1 ;
35634   Dali::Toolkit::Alignment result;
35635
35636   argp1 = (Dali::BaseHandle *)jarg1;
35637   if (!argp1) {
35638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35639     return 0;
35640   }
35641   arg1 = *argp1;
35642   {
35643     try {
35644       result = Dali::Toolkit::Alignment::DownCast(arg1);
35645     } CALL_CATCH_EXCEPTION(0);
35646   }
35647
35648   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
35649   return jresult;
35650 }
35651
35652
35653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
35654   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35655   Dali::Toolkit::Alignment::Type arg2 ;
35656
35657   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35658   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
35659   {
35660     try {
35661       (arg1)->SetAlignmentType(arg2);
35662     } CALL_CATCH_EXCEPTION();
35663   }
35664
35665 }
35666
35667
35668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
35669   int jresult ;
35670   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35671   Dali::Toolkit::Alignment::Type result;
35672
35673   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35674   {
35675     try {
35676       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
35677     } CALL_CATCH_EXCEPTION(0);
35678   }
35679
35680   jresult = (int)result;
35681   return jresult;
35682 }
35683
35684
35685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
35686   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35687   Dali::Toolkit::Alignment::Scaling arg2 ;
35688
35689   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35690   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
35691   {
35692     try {
35693       (arg1)->SetScaling(arg2);
35694     } CALL_CATCH_EXCEPTION();
35695   }
35696
35697 }
35698
35699
35700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
35701   int jresult ;
35702   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35703   Dali::Toolkit::Alignment::Scaling result;
35704
35705   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35706   {
35707     try {
35708       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
35709     } CALL_CATCH_EXCEPTION(0);
35710   }
35711
35712   jresult = (int)result;
35713   return jresult;
35714 }
35715
35716
35717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
35718   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35719   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
35720
35721   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35722   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
35723   if (!arg2) {
35724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
35725     return ;
35726   }
35727   {
35728     try {
35729       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
35730     } CALL_CATCH_EXCEPTION();
35731   }
35732
35733 }
35734
35735
35736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
35737   void * jresult ;
35738   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35739   Dali::Toolkit::Alignment::Padding *result = 0 ;
35740
35741   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35742   {
35743     try {
35744       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
35745     } CALL_CATCH_EXCEPTION(0);
35746   }
35747
35748   jresult = (void *)result;
35749   return jresult;
35750 }
35751
35752
35753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
35754   void * jresult ;
35755   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
35756   Dali::Toolkit::Alignment *arg2 = 0 ;
35757   Dali::Toolkit::Alignment *result = 0 ;
35758
35759   arg1 = (Dali::Toolkit::Alignment *)jarg1;
35760   arg2 = (Dali::Toolkit::Alignment *)jarg2;
35761   if (!arg2) {
35762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
35763     return 0;
35764   }
35765   {
35766     try {
35767       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
35768     } CALL_CATCH_EXCEPTION(0);
35769   }
35770
35771   jresult = (void *)result;
35772   return jresult;
35773 }
35774
35775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
35776   int jresult ;
35777   int result;
35778
35779   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
35780   jresult = (int)result;
35781   return jresult;
35782 }
35783
35784
35785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
35786   int jresult ;
35787   int result;
35788
35789   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
35790   jresult = (int)result;
35791   return jresult;
35792 }
35793
35794
35795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
35796   int jresult ;
35797   int result;
35798
35799   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
35800   jresult = (int)result;
35801   return jresult;
35802 }
35803
35804
35805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
35806   int jresult ;
35807   int result;
35808
35809   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
35810   jresult = (int)result;
35811   return jresult;
35812 }
35813
35814
35815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
35816   int jresult ;
35817   int result;
35818
35819   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
35820   jresult = (int)result;
35821   return jresult;
35822 }
35823
35824
35825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
35826   int jresult ;
35827   int result;
35828
35829   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
35830   jresult = (int)result;
35831   return jresult;
35832 }
35833
35834
35835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
35836   void * jresult ;
35837   Dali::Toolkit::FlexContainer::Property *result = 0 ;
35838
35839   {
35840     try {
35841       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
35842     } CALL_CATCH_EXCEPTION(0);
35843   }
35844
35845   jresult = (void *)result;
35846   return jresult;
35847 }
35848
35849
35850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
35851   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
35852
35853   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
35854   {
35855     try {
35856       delete arg1;
35857     } CALL_CATCH_EXCEPTION();
35858   }
35859
35860 }
35861
35862
35863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
35864   int jresult ;
35865   int result;
35866
35867   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
35868   jresult = (int)result;
35869   return jresult;
35870 }
35871
35872
35873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
35874   int jresult ;
35875   int result;
35876
35877   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
35878   jresult = (int)result;
35879   return jresult;
35880 }
35881
35882
35883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
35884   int jresult ;
35885   int result;
35886
35887   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
35888   jresult = (int)result;
35889   return jresult;
35890 }
35891
35892
35893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
35894   void * jresult ;
35895   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
35896
35897   {
35898     try {
35899       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
35900     } CALL_CATCH_EXCEPTION(0);
35901   }
35902
35903   jresult = (void *)result;
35904   return jresult;
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
35909   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
35910
35911   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
35912   {
35913     try {
35914       delete arg1;
35915     } CALL_CATCH_EXCEPTION();
35916   }
35917
35918 }
35919
35920
35921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
35922   void * jresult ;
35923   Dali::Toolkit::FlexContainer *result = 0 ;
35924
35925   {
35926     try {
35927       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
35928     } CALL_CATCH_EXCEPTION(0);
35929   }
35930
35931   jresult = (void *)result;
35932   return jresult;
35933 }
35934
35935
35936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
35937   void * jresult ;
35938   Dali::Toolkit::FlexContainer *arg1 = 0 ;
35939   Dali::Toolkit::FlexContainer *result = 0 ;
35940
35941   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
35942   if (!arg1) {
35943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
35944     return 0;
35945   }
35946   {
35947     try {
35948       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
35949     } CALL_CATCH_EXCEPTION(0);
35950   }
35951
35952   jresult = (void *)result;
35953   return jresult;
35954 }
35955
35956
35957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
35958   void * jresult ;
35959   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
35960   Dali::Toolkit::FlexContainer *arg2 = 0 ;
35961   Dali::Toolkit::FlexContainer *result = 0 ;
35962
35963   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
35964   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
35965   if (!arg2) {
35966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
35967     return 0;
35968   }
35969   {
35970     try {
35971       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
35972     } CALL_CATCH_EXCEPTION(0);
35973   }
35974
35975   jresult = (void *)result;
35976   return jresult;
35977 }
35978
35979
35980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
35981   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
35982
35983   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
35984   {
35985     try {
35986       delete arg1;
35987     } CALL_CATCH_EXCEPTION();
35988   }
35989
35990 }
35991
35992
35993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
35994   void * jresult ;
35995   Dali::Toolkit::FlexContainer result;
35996
35997   {
35998     try {
35999       result = Dali::Toolkit::FlexContainer::New();
36000     } CALL_CATCH_EXCEPTION(0);
36001   }
36002
36003   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
36004   return jresult;
36005 }
36006
36007
36008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
36009   void * jresult ;
36010   Dali::BaseHandle arg1 ;
36011   Dali::BaseHandle *argp1 ;
36012   Dali::Toolkit::FlexContainer result;
36013
36014   argp1 = (Dali::BaseHandle *)jarg1;
36015   if (!argp1) {
36016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36017     return 0;
36018   }
36019   arg1 = *argp1;
36020   {
36021     try {
36022       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
36023     } CALL_CATCH_EXCEPTION(0);
36024   }
36025
36026   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
36027   return jresult;
36028 }
36029
36030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
36031   int jresult ;
36032   int result;
36033
36034   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
36035   jresult = (int)result;
36036   return jresult;
36037 }
36038
36039
36040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
36041   int jresult ;
36042   int result;
36043
36044   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
36045   jresult = (int)result;
36046   return jresult;
36047 }
36048
36049
36050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
36051   int jresult ;
36052   int result;
36053
36054   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
36055   jresult = (int)result;
36056   return jresult;
36057 }
36058
36059
36060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
36061   void * jresult ;
36062   Dali::Toolkit::ImageView::Property *result = 0 ;
36063
36064   {
36065     try {
36066       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
36067     } CALL_CATCH_EXCEPTION(0);
36068   }
36069
36070   jresult = (void *)result;
36071   return jresult;
36072 }
36073
36074
36075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
36076   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
36077
36078   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
36079   {
36080     try {
36081       delete arg1;
36082     } CALL_CATCH_EXCEPTION();
36083   }
36084
36085 }
36086
36087
36088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
36089   void * jresult ;
36090   Dali::Toolkit::ImageView *result = 0 ;
36091
36092   {
36093     try {
36094       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
36095     } CALL_CATCH_EXCEPTION(0);
36096   }
36097
36098   jresult = (void *)result;
36099   return jresult;
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
36104   void * jresult ;
36105   Dali::Toolkit::ImageView result;
36106
36107   {
36108     try {
36109       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
36110     } CALL_CATCH_EXCEPTION(0);
36111   }
36112
36113   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
36114   return jresult;
36115 }
36116
36117
36118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
36119   void * jresult ;
36120   std::string *arg1 = 0 ;
36121   Dali::Toolkit::ImageView result;
36122
36123   if (!jarg1) {
36124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36125     return 0;
36126   }
36127   std::string arg1_str(jarg1);
36128   arg1 = &arg1_str;
36129   {
36130     try {
36131       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
36132     } CALL_CATCH_EXCEPTION(0);
36133   }
36134
36135   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
36136
36137   //argout typemap for const std::string&
36138
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
36144   void * jresult ;
36145   std::string *arg1 = 0 ;
36146   Dali::ImageDimensions arg2 ;
36147   Dali::ImageDimensions *argp2 ;
36148   Dali::Toolkit::ImageView result;
36149
36150   if (!jarg1) {
36151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36152     return 0;
36153   }
36154   std::string arg1_str(jarg1);
36155   arg1 = &arg1_str;
36156   argp2 = (Dali::ImageDimensions *)jarg2;
36157   if (!argp2) {
36158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
36159     return 0;
36160   }
36161   arg2 = *argp2;
36162   {
36163     try {
36164       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2);
36165     } CALL_CATCH_EXCEPTION(0);
36166   }
36167
36168   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
36169
36170   //argout typemap for const std::string&
36171
36172   return jresult;
36173 }
36174
36175
36176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
36177   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
36178
36179   arg1 = (Dali::Toolkit::ImageView *)jarg1;
36180   {
36181     try {
36182       delete arg1;
36183     } CALL_CATCH_EXCEPTION();
36184   }
36185
36186 }
36187
36188
36189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
36190   void * jresult ;
36191   Dali::Toolkit::ImageView *arg1 = 0 ;
36192   Dali::Toolkit::ImageView *result = 0 ;
36193
36194   arg1 = (Dali::Toolkit::ImageView *)jarg1;
36195   if (!arg1) {
36196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
36197     return 0;
36198   }
36199   {
36200     try {
36201       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
36202     } CALL_CATCH_EXCEPTION(0);
36203   }
36204
36205   jresult = (void *)result;
36206   return jresult;
36207 }
36208
36209
36210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
36211   void * jresult ;
36212   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
36213   Dali::Toolkit::ImageView *arg2 = 0 ;
36214   Dali::Toolkit::ImageView *result = 0 ;
36215
36216   arg1 = (Dali::Toolkit::ImageView *)jarg1;
36217   arg2 = (Dali::Toolkit::ImageView *)jarg2;
36218   if (!arg2) {
36219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
36220     return 0;
36221   }
36222   {
36223     try {
36224       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
36225     } CALL_CATCH_EXCEPTION(0);
36226   }
36227
36228   jresult = (void *)result;
36229   return jresult;
36230 }
36231
36232
36233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
36234   void * jresult ;
36235   Dali::BaseHandle arg1 ;
36236   Dali::BaseHandle *argp1 ;
36237   Dali::Toolkit::ImageView result;
36238
36239   argp1 = (Dali::BaseHandle *)jarg1;
36240   if (!argp1) {
36241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36242     return 0;
36243   }
36244   arg1 = *argp1;
36245   {
36246     try {
36247       result = Dali::Toolkit::ImageView::DownCast(arg1);
36248     } CALL_CATCH_EXCEPTION(0);
36249   }
36250
36251   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
36252   return jresult;
36253 }
36254
36255
36256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
36257   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
36258   std::string *arg2 = 0 ;
36259
36260   arg1 = (Dali::Toolkit::ImageView *)jarg1;
36261   if (!jarg2) {
36262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36263     return ;
36264   }
36265   std::string arg2_str(jarg2);
36266   arg2 = &arg2_str;
36267   {
36268     try {
36269       (arg1)->SetImage((std::string const &)*arg2);
36270     } CALL_CATCH_EXCEPTION();
36271   }
36272
36273
36274   //argout typemap for const std::string&
36275
36276 }
36277
36278
36279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
36280   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
36281   std::string *arg2 = 0 ;
36282   Dali::ImageDimensions arg3 ;
36283   Dali::ImageDimensions *argp3 ;
36284
36285   arg1 = (Dali::Toolkit::ImageView *)jarg1;
36286   if (!jarg2) {
36287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36288     return ;
36289   }
36290   std::string arg2_str(jarg2);
36291   arg2 = &arg2_str;
36292   argp3 = (Dali::ImageDimensions *)jarg3;
36293   if (!argp3) {
36294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
36295     return ;
36296   }
36297   arg3 = *argp3;
36298   {
36299     try {
36300       (arg1)->SetImage((std::string const &)*arg2,arg3);
36301     } CALL_CATCH_EXCEPTION();
36302   }
36303
36304
36305   //argout typemap for const std::string&
36306
36307 }
36308
36309
36310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
36311   int jresult ;
36312   int result;
36313
36314   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
36315   jresult = (int)result;
36316   return jresult;
36317 }
36318
36319
36320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
36321   int jresult ;
36322   int result;
36323
36324   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
36325   jresult = (int)result;
36326   return jresult;
36327 }
36328
36329
36330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
36331   int jresult ;
36332   int result;
36333
36334   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
36335   jresult = (int)result;
36336   return jresult;
36337 }
36338
36339
36340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
36341   int jresult ;
36342   int result;
36343
36344   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
36345   jresult = (int)result;
36346   return jresult;
36347 }
36348
36349
36350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
36351   int jresult ;
36352   int result;
36353
36354   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
36355   jresult = (int)result;
36356   return jresult;
36357 }
36358
36359
36360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
36361   int jresult ;
36362   int result;
36363
36364   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
36365   jresult = (int)result;
36366   return jresult;
36367 }
36368
36369
36370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
36371   int jresult ;
36372   int result;
36373
36374   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
36375   jresult = (int)result;
36376   return jresult;
36377 }
36378
36379
36380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
36381   int jresult ;
36382   int result;
36383
36384   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
36385   jresult = (int)result;
36386   return jresult;
36387 }
36388
36389
36390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
36391   int jresult ;
36392   int result;
36393
36394   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
36395   jresult = (int)result;
36396   return jresult;
36397 }
36398
36399
36400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
36401   void * jresult ;
36402   Dali::Toolkit::ScrollBar::Property *result = 0 ;
36403
36404   {
36405     try {
36406       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
36407     } CALL_CATCH_EXCEPTION(0);
36408   }
36409
36410   jresult = (void *)result;
36411   return jresult;
36412 }
36413
36414
36415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
36416   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
36417
36418   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
36419   {
36420     try {
36421       delete arg1;
36422     } CALL_CATCH_EXCEPTION();
36423   }
36424
36425 }
36426
36427
36428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
36429   void * jresult ;
36430   Dali::Toolkit::ScrollBar *result = 0 ;
36431
36432   {
36433     try {
36434       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
36435     } CALL_CATCH_EXCEPTION(0);
36436   }
36437
36438   jresult = (void *)result;
36439   return jresult;
36440 }
36441
36442
36443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
36444   void * jresult ;
36445   Dali::Toolkit::ScrollBar *arg1 = 0 ;
36446   Dali::Toolkit::ScrollBar *result = 0 ;
36447
36448   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36449   if (!arg1) {
36450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
36451     return 0;
36452   }
36453   {
36454     try {
36455       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
36456     } CALL_CATCH_EXCEPTION(0);
36457   }
36458
36459   jresult = (void *)result;
36460   return jresult;
36461 }
36462
36463
36464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
36465   void * jresult ;
36466   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36467   Dali::Toolkit::ScrollBar *arg2 = 0 ;
36468   Dali::Toolkit::ScrollBar *result = 0 ;
36469
36470   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36471   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
36472   if (!arg2) {
36473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
36474     return 0;
36475   }
36476   {
36477     try {
36478       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
36479     } CALL_CATCH_EXCEPTION(0);
36480   }
36481
36482   jresult = (void *)result;
36483   return jresult;
36484 }
36485
36486
36487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
36488   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36489
36490   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36491   {
36492     try {
36493       delete arg1;
36494     } CALL_CATCH_EXCEPTION();
36495   }
36496
36497 }
36498
36499
36500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
36501   void * jresult ;
36502   Dali::Toolkit::ScrollBar::Direction arg1 ;
36503   Dali::Toolkit::ScrollBar result;
36504
36505   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
36506   {
36507     try {
36508       result = Dali::Toolkit::ScrollBar::New(arg1);
36509     } CALL_CATCH_EXCEPTION(0);
36510   }
36511
36512   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
36513   return jresult;
36514 }
36515
36516
36517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
36518   void * jresult ;
36519   Dali::Toolkit::ScrollBar result;
36520
36521   {
36522     try {
36523       result = Dali::Toolkit::ScrollBar::New();
36524     } CALL_CATCH_EXCEPTION(0);
36525   }
36526
36527   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
36528   return jresult;
36529 }
36530
36531
36532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
36533   void * jresult ;
36534   Dali::BaseHandle arg1 ;
36535   Dali::BaseHandle *argp1 ;
36536   Dali::Toolkit::ScrollBar result;
36537
36538   argp1 = (Dali::BaseHandle *)jarg1;
36539   if (!argp1) {
36540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36541     return 0;
36542   }
36543   arg1 = *argp1;
36544   {
36545     try {
36546       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
36547     } CALL_CATCH_EXCEPTION(0);
36548   }
36549
36550   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
36551   return jresult;
36552 }
36553
36554
36555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
36556   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36557   Dali::Handle arg2 ;
36558   Dali::Property::Index arg3 ;
36559   Dali::Property::Index arg4 ;
36560   Dali::Property::Index arg5 ;
36561   Dali::Property::Index arg6 ;
36562   Dali::Handle *argp2 ;
36563
36564   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36565   argp2 = (Dali::Handle *)jarg2;
36566   if (!argp2) {
36567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
36568     return ;
36569   }
36570   arg2 = *argp2;
36571   arg3 = (Dali::Property::Index)jarg3;
36572   arg4 = (Dali::Property::Index)jarg4;
36573   arg5 = (Dali::Property::Index)jarg5;
36574   arg6 = (Dali::Property::Index)jarg6;
36575   {
36576     try {
36577       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
36578     } CALL_CATCH_EXCEPTION();
36579   }
36580
36581 }
36582
36583
36584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
36585   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36586   Dali::Actor arg2 ;
36587   Dali::Actor *argp2 ;
36588
36589   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36590   argp2 = (Dali::Actor *)jarg2;
36591   if (!argp2) {
36592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36593     return ;
36594   }
36595   arg2 = *argp2;
36596   {
36597     try {
36598       (arg1)->SetScrollIndicator(arg2);
36599     } CALL_CATCH_EXCEPTION();
36600   }
36601
36602 }
36603
36604
36605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
36606   void * jresult ;
36607   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36608   Dali::Actor result;
36609
36610   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36611   {
36612     try {
36613       result = (arg1)->GetScrollIndicator();
36614     } CALL_CATCH_EXCEPTION(0);
36615   }
36616
36617   jresult = new Dali::Actor((const Dali::Actor &)result);
36618   return jresult;
36619 }
36620
36621
36622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
36623   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36624   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
36625
36626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36627   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
36628   if (!arg2) {
36629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
36630     return ;
36631   }
36632   {
36633     try {
36634       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
36635     } CALL_CATCH_EXCEPTION();
36636   }
36637
36638 }
36639
36640
36641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
36642   void * jresult ;
36643   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36644
36645   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36646   {
36647     try {
36648       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()));
36649     } CALL_CATCH_EXCEPTION(0);
36650   }
36651   return jresult;
36652 }
36653
36654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
36655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36656   Dali::Toolkit::ScrollBar::Direction arg2 ;
36657
36658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36659   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
36660   {
36661     try {
36662       (arg1)->SetScrollDirection(arg2);
36663     } CALL_CATCH_EXCEPTION();
36664   }
36665
36666 }
36667
36668
36669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
36670   int jresult ;
36671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36672   Dali::Toolkit::ScrollBar::Direction result;
36673
36674   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36675   {
36676     try {
36677       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
36678     } CALL_CATCH_EXCEPTION(0);
36679   }
36680
36681   jresult = (int)result;
36682   return jresult;
36683 }
36684
36685
36686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
36687   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36688   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
36689
36690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36691   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
36692   {
36693     try {
36694       (arg1)->SetIndicatorHeightPolicy(arg2);
36695     } CALL_CATCH_EXCEPTION();
36696   }
36697
36698 }
36699
36700
36701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
36702   int jresult ;
36703   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36704   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
36705
36706   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36707   {
36708     try {
36709       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
36710     } CALL_CATCH_EXCEPTION(0);
36711   }
36712
36713   jresult = (int)result;
36714   return jresult;
36715 }
36716
36717
36718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
36719   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36720   float arg2 ;
36721
36722   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36723   arg2 = (float)jarg2;
36724   {
36725     try {
36726       (arg1)->SetIndicatorFixedHeight(arg2);
36727     } CALL_CATCH_EXCEPTION();
36728   }
36729
36730 }
36731
36732
36733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
36734   float jresult ;
36735   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36736   float result;
36737
36738   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36739   {
36740     try {
36741       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
36742     } CALL_CATCH_EXCEPTION(0);
36743   }
36744
36745   jresult = result;
36746   return jresult;
36747 }
36748
36749
36750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
36751   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36752   float arg2 ;
36753
36754   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36755   arg2 = (float)jarg2;
36756   {
36757     try {
36758       (arg1)->SetIndicatorShowDuration(arg2);
36759     } CALL_CATCH_EXCEPTION();
36760   }
36761
36762 }
36763
36764
36765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
36766   float jresult ;
36767   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36768   float result;
36769
36770   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36771   {
36772     try {
36773       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
36774     } CALL_CATCH_EXCEPTION(0);
36775   }
36776
36777   jresult = result;
36778   return jresult;
36779 }
36780
36781
36782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
36783   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36784   float arg2 ;
36785
36786   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36787   arg2 = (float)jarg2;
36788   {
36789     try {
36790       (arg1)->SetIndicatorHideDuration(arg2);
36791     } CALL_CATCH_EXCEPTION();
36792   }
36793
36794 }
36795
36796
36797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
36798   float jresult ;
36799   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36800   float result;
36801
36802   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36803   {
36804     try {
36805       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
36806     } CALL_CATCH_EXCEPTION(0);
36807   }
36808
36809   jresult = result;
36810   return jresult;
36811 }
36812
36813
36814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
36815   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36816
36817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36818   {
36819     try {
36820       (arg1)->ShowIndicator();
36821     } CALL_CATCH_EXCEPTION();
36822   }
36823
36824 }
36825
36826
36827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
36828   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36829
36830   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36831   {
36832     try {
36833       (arg1)->HideIndicator();
36834     } CALL_CATCH_EXCEPTION();
36835   }
36836
36837 }
36838
36839
36840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
36841   void * jresult ;
36842   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36843   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
36844
36845   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36846   {
36847     try {
36848       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
36849     } CALL_CATCH_EXCEPTION(0);
36850   }
36851
36852   jresult = (void *)result;
36853   return jresult;
36854 }
36855
36856
36857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
36858   void * jresult ;
36859   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
36860   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
36861
36862   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
36863   {
36864     try {
36865       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
36866     } CALL_CATCH_EXCEPTION(0);
36867   }
36868
36869   jresult = (void *)result;
36870   return jresult;
36871 }
36872
36873
36874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
36875   int jresult ;
36876   int result;
36877
36878   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
36879   jresult = (int)result;
36880   return jresult;
36881 }
36882
36883
36884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
36885   int jresult ;
36886   int result;
36887
36888   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
36889   jresult = (int)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
36895   int jresult ;
36896   int result;
36897
36898   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
36899   jresult = (int)result;
36900   return jresult;
36901 }
36902
36903
36904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
36905   int jresult ;
36906   int result;
36907
36908   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
36909   jresult = (int)result;
36910   return jresult;
36911 }
36912
36913
36914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
36915   int jresult ;
36916   int result;
36917
36918   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
36919   jresult = (int)result;
36920   return jresult;
36921 }
36922
36923
36924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
36925   int jresult ;
36926   int result;
36927
36928   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
36929   jresult = (int)result;
36930   return jresult;
36931 }
36932
36933
36934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
36935   int jresult ;
36936   int result;
36937
36938   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
36939   jresult = (int)result;
36940   return jresult;
36941 }
36942
36943
36944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
36945   int jresult ;
36946   int result;
36947
36948   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
36949   jresult = (int)result;
36950   return jresult;
36951 }
36952
36953
36954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
36955   int jresult ;
36956   int result;
36957
36958   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
36959   jresult = (int)result;
36960   return jresult;
36961 }
36962
36963
36964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
36965   int jresult ;
36966   int result;
36967
36968   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
36969   jresult = (int)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
36975   int jresult ;
36976   int result;
36977
36978   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
36979   jresult = (int)result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
36985   int jresult ;
36986   int result;
36987
36988   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
36989   jresult = (int)result;
36990   return jresult;
36991 }
36992
36993
36994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
36995   int jresult ;
36996   int result;
36997
36998   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
36999   jresult = (int)result;
37000   return jresult;
37001 }
37002
37003
37004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
37005   int jresult ;
37006   int result;
37007
37008   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
37009   jresult = (int)result;
37010   return jresult;
37011 }
37012
37013
37014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
37015   void * jresult ;
37016   Dali::Toolkit::Scrollable::Property *result = 0 ;
37017
37018   {
37019     try {
37020       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
37021     } CALL_CATCH_EXCEPTION(0);
37022   }
37023
37024   jresult = (void *)result;
37025   return jresult;
37026 }
37027
37028
37029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
37030   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
37031
37032   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
37033   {
37034     try {
37035       delete arg1;
37036     } CALL_CATCH_EXCEPTION();
37037   }
37038
37039 }
37040
37041
37042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
37043   void * jresult ;
37044   Dali::Toolkit::Scrollable *result = 0 ;
37045
37046   {
37047     try {
37048       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
37049     } CALL_CATCH_EXCEPTION(0);
37050   }
37051
37052   jresult = (void *)result;
37053   return jresult;
37054 }
37055
37056
37057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
37058   void * jresult ;
37059   Dali::Toolkit::Scrollable *arg1 = 0 ;
37060   Dali::Toolkit::Scrollable *result = 0 ;
37061
37062   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37063   if (!arg1) {
37064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
37065     return 0;
37066   }
37067   {
37068     try {
37069       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
37070     } CALL_CATCH_EXCEPTION(0);
37071   }
37072
37073   jresult = (void *)result;
37074   return jresult;
37075 }
37076
37077
37078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
37079   void * jresult ;
37080   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37081   Dali::Toolkit::Scrollable *arg2 = 0 ;
37082   Dali::Toolkit::Scrollable *result = 0 ;
37083
37084   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37085   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
37086   if (!arg2) {
37087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
37088     return 0;
37089   }
37090   {
37091     try {
37092       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
37093     } CALL_CATCH_EXCEPTION(0);
37094   }
37095
37096   jresult = (void *)result;
37097   return jresult;
37098 }
37099
37100
37101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
37102   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37103
37104   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37105   {
37106     try {
37107       delete arg1;
37108     } CALL_CATCH_EXCEPTION();
37109   }
37110
37111 }
37112
37113
37114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
37115   void * jresult ;
37116   Dali::BaseHandle arg1 ;
37117   Dali::BaseHandle *argp1 ;
37118   Dali::Toolkit::Scrollable result;
37119
37120   argp1 = (Dali::BaseHandle *)jarg1;
37121   if (!argp1) {
37122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37123     return 0;
37124   }
37125   arg1 = *argp1;
37126   {
37127     try {
37128       result = Dali::Toolkit::Scrollable::DownCast(arg1);
37129     } CALL_CATCH_EXCEPTION(0);
37130   }
37131
37132   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
37133   return jresult;
37134 }
37135
37136
37137 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
37138   bool jresult ;
37139   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37140   bool result;
37141
37142   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37143   {
37144     try {
37145       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
37146     } CALL_CATCH_EXCEPTION(0);
37147   }
37148
37149   jresult = result;
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
37155   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37156   bool arg2 ;
37157
37158   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37159   arg2 = jarg2 ? true : false;
37160   {
37161     try {
37162       (arg1)->SetOvershootEnabled(arg2);
37163     } CALL_CATCH_EXCEPTION();
37164   }
37165
37166 }
37167
37168
37169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
37170   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37171   Dali::Vector4 *arg2 = 0 ;
37172
37173   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37174   arg2 = (Dali::Vector4 *)jarg2;
37175   if (!arg2) {
37176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
37177     return ;
37178   }
37179   {
37180     try {
37181       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
37182     } CALL_CATCH_EXCEPTION();
37183   }
37184
37185 }
37186
37187
37188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
37189   void * jresult ;
37190   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37191   Dali::Vector4 result;
37192
37193   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37194   {
37195     try {
37196       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
37197     } CALL_CATCH_EXCEPTION(0);
37198   }
37199
37200   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37201   return jresult;
37202 }
37203
37204
37205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
37206   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37207   float arg2 ;
37208
37209   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37210   arg2 = (float)jarg2;
37211   {
37212     try {
37213       (arg1)->SetOvershootAnimationSpeed(arg2);
37214     } CALL_CATCH_EXCEPTION();
37215   }
37216
37217 }
37218
37219
37220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
37221   float jresult ;
37222   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37223   float result;
37224
37225   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37226   {
37227     try {
37228       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
37229     } CALL_CATCH_EXCEPTION(0);
37230   }
37231
37232   jresult = result;
37233   return jresult;
37234 }
37235
37236
37237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
37238   void * jresult ;
37239   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37240   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
37241
37242   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37243   {
37244     try {
37245       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
37246     } CALL_CATCH_EXCEPTION(0);
37247   }
37248
37249   jresult = (void *)result;
37250   return jresult;
37251 }
37252
37253
37254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
37255   void * jresult ;
37256   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37257   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
37258
37259   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37260   {
37261     try {
37262       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
37263     } CALL_CATCH_EXCEPTION(0);
37264   }
37265
37266   jresult = (void *)result;
37267   return jresult;
37268 }
37269
37270
37271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
37272   void * jresult ;
37273   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
37274   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
37275
37276   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
37277   {
37278     try {
37279       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
37280     } CALL_CATCH_EXCEPTION(0);
37281   }
37282
37283   jresult = (void *)result;
37284   return jresult;
37285 }
37286
37287
37288 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
37289   bool jresult ;
37290   Dali::Toolkit::ControlOrientation::Type arg1 ;
37291   bool result;
37292
37293   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
37294   {
37295     try {
37296       result = (bool)Dali::Toolkit::IsVertical(arg1);
37297     } CALL_CATCH_EXCEPTION(0);
37298   }
37299
37300   jresult = result;
37301   return jresult;
37302 }
37303
37304
37305 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
37306   bool jresult ;
37307   Dali::Toolkit::ControlOrientation::Type arg1 ;
37308   bool result;
37309
37310   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
37311   {
37312     try {
37313       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
37314     } CALL_CATCH_EXCEPTION(0);
37315   }
37316
37317   jresult = result;
37318   return jresult;
37319 }
37320
37321
37322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
37323   void * jresult ;
37324   unsigned int arg1 ;
37325   unsigned int arg2 ;
37326   Dali::Toolkit::ItemRange *result = 0 ;
37327
37328   arg1 = (unsigned int)jarg1;
37329   arg2 = (unsigned int)jarg2;
37330   {
37331     try {
37332       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
37333     } CALL_CATCH_EXCEPTION(0);
37334   }
37335
37336   jresult = (void *)result;
37337   return jresult;
37338 }
37339
37340
37341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
37342   void * jresult ;
37343   Dali::Toolkit::ItemRange *arg1 = 0 ;
37344   Dali::Toolkit::ItemRange *result = 0 ;
37345
37346   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37347   if (!arg1) {
37348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
37349     return 0;
37350   }
37351   {
37352     try {
37353       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
37354     } CALL_CATCH_EXCEPTION(0);
37355   }
37356
37357   jresult = (void *)result;
37358   return jresult;
37359 }
37360
37361
37362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
37363   void * jresult ;
37364   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37365   Dali::Toolkit::ItemRange *arg2 = 0 ;
37366   Dali::Toolkit::ItemRange *result = 0 ;
37367
37368   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37369   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
37370   if (!arg2) {
37371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
37372     return 0;
37373   }
37374   {
37375     try {
37376       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
37377     } CALL_CATCH_EXCEPTION(0);
37378   }
37379
37380   jresult = (void *)result;
37381   return jresult;
37382 }
37383
37384
37385 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
37386   bool jresult ;
37387   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37388   unsigned int arg2 ;
37389   bool result;
37390
37391   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37392   arg2 = (unsigned int)jarg2;
37393   {
37394     try {
37395       result = (bool)(arg1)->Within(arg2);
37396     } CALL_CATCH_EXCEPTION(0);
37397   }
37398
37399   jresult = result;
37400   return jresult;
37401 }
37402
37403
37404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
37405   void * jresult ;
37406   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37407   Dali::Toolkit::ItemRange *arg2 = 0 ;
37408   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
37409
37410   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37411   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
37412   if (!arg2) {
37413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
37414     return 0;
37415   }
37416   {
37417     try {
37418       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
37419     } CALL_CATCH_EXCEPTION(0);
37420   }
37421
37422   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
37423   return jresult;
37424 }
37425
37426
37427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
37428   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37429   unsigned int arg2 ;
37430
37431   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37432   arg2 = (unsigned int)jarg2;
37433   if (arg1) (arg1)->begin = arg2;
37434 }
37435
37436
37437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
37438   unsigned int jresult ;
37439   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37440   unsigned int result;
37441
37442   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37443   result = (unsigned int) ((arg1)->begin);
37444   jresult = result;
37445   return jresult;
37446 }
37447
37448
37449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
37450   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37451   unsigned int arg2 ;
37452
37453   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37454   arg2 = (unsigned int)jarg2;
37455   if (arg1) (arg1)->end = arg2;
37456 }
37457
37458
37459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
37460   unsigned int jresult ;
37461   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37462   unsigned int result;
37463
37464   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37465   result = (unsigned int) ((arg1)->end);
37466   jresult = result;
37467   return jresult;
37468 }
37469
37470
37471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
37472   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
37473
37474   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
37475   {
37476     try {
37477       delete arg1;
37478     } CALL_CATCH_EXCEPTION();
37479   }
37480
37481 }
37482
37483
37484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
37485   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37486
37487   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37488   {
37489     try {
37490       delete arg1;
37491     } CALL_CATCH_EXCEPTION();
37492   }
37493
37494 }
37495
37496
37497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
37498   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37499   Dali::Toolkit::ControlOrientation::Type arg2 ;
37500
37501   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37502   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
37503   {
37504     try {
37505       (arg1)->SetOrientation(arg2);
37506     } CALL_CATCH_EXCEPTION();
37507   }
37508
37509 }
37510
37511
37512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
37513   int jresult ;
37514   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37515   Dali::Toolkit::ControlOrientation::Type result;
37516
37517   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37518   {
37519     try {
37520       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
37521     } CALL_CATCH_EXCEPTION(0);
37522   }
37523
37524   jresult = (int)result;
37525   return jresult;
37526 }
37527
37528
37529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
37530   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37531   Dali::Property::Map *arg2 = 0 ;
37532
37533   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37534   arg2 = (Dali::Property::Map *)jarg2;
37535   if (!arg2) {
37536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
37537     return ;
37538   }
37539   {
37540     try {
37541       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
37542     } CALL_CATCH_EXCEPTION();
37543   }
37544
37545 }
37546
37547
37548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
37549   void * jresult ;
37550   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37551   Dali::Property::Map result;
37552
37553   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37554   {
37555     try {
37556       result = (arg1)->GetLayoutProperties();
37557     } CALL_CATCH_EXCEPTION(0);
37558   }
37559
37560   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
37561   return jresult;
37562 }
37563
37564
37565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
37566   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37567   unsigned int arg2 ;
37568   Dali::Vector3 *arg3 = 0 ;
37569   Dali::Vector3 *arg4 = 0 ;
37570
37571   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37572   arg2 = (unsigned int)jarg2;
37573   arg3 = (Dali::Vector3 *)jarg3;
37574   if (!arg3) {
37575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37576     return ;
37577   }
37578   arg4 = (Dali::Vector3 *)jarg4;
37579   if (!arg4) {
37580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37581     return ;
37582   }
37583   {
37584     try {
37585       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
37586     } CALL_CATCH_EXCEPTION();
37587   }
37588
37589 }
37590
37591
37592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
37593   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37594   Dali::Vector3 *arg2 = 0 ;
37595
37596   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37597   arg2 = (Dali::Vector3 *)jarg2;
37598   if (!arg2) {
37599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37600     return ;
37601   }
37602   {
37603     try {
37604       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
37605     } CALL_CATCH_EXCEPTION();
37606   }
37607
37608 }
37609
37610
37611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
37612   float jresult ;
37613   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37614   unsigned int arg2 ;
37615   Dali::Vector3 arg3 ;
37616   Dali::Vector3 *argp3 ;
37617   float result;
37618
37619   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37620   arg2 = (unsigned int)jarg2;
37621   argp3 = (Dali::Vector3 *)jarg3;
37622   if (!argp3) {
37623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
37624     return 0;
37625   }
37626   arg3 = *argp3;
37627   {
37628     try {
37629       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
37630     } CALL_CATCH_EXCEPTION(0);
37631   }
37632
37633   jresult = result;
37634   return jresult;
37635 }
37636
37637
37638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
37639   float jresult ;
37640   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37641   float arg2 ;
37642   float result;
37643
37644   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37645   arg2 = (float)jarg2;
37646   {
37647     try {
37648       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
37649     } CALL_CATCH_EXCEPTION(0);
37650   }
37651
37652   jresult = result;
37653   return jresult;
37654 }
37655
37656
37657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
37658   float jresult ;
37659   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37660   unsigned int arg2 ;
37661   float result;
37662
37663   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37664   arg2 = (unsigned int)jarg2;
37665   {
37666     try {
37667       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
37668     } CALL_CATCH_EXCEPTION(0);
37669   }
37670
37671   jresult = result;
37672   return jresult;
37673 }
37674
37675
37676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
37677   void * jresult ;
37678   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37679   float arg2 ;
37680   Dali::Vector3 arg3 ;
37681   Dali::Vector3 *argp3 ;
37682   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
37683
37684   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37685   arg2 = (float)jarg2;
37686   argp3 = (Dali::Vector3 *)jarg3;
37687   if (!argp3) {
37688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
37689     return 0;
37690   }
37691   arg3 = *argp3;
37692   {
37693     try {
37694       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
37695     } CALL_CATCH_EXCEPTION(0);
37696   }
37697
37698   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
37699   return jresult;
37700 }
37701
37702
37703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
37704   float jresult ;
37705   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37706   int arg2 ;
37707   float arg3 ;
37708   Dali::Vector3 *arg4 = 0 ;
37709   float result;
37710
37711   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37712   arg2 = (int)jarg2;
37713   arg3 = (float)jarg3;
37714   arg4 = (Dali::Vector3 *)jarg4;
37715   if (!arg4) {
37716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37717     return 0;
37718   }
37719   {
37720     try {
37721       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
37722     } CALL_CATCH_EXCEPTION(0);
37723   }
37724
37725   jresult = result;
37726   return jresult;
37727 }
37728
37729
37730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
37731   unsigned int jresult ;
37732   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37733   Dali::Vector3 arg2 ;
37734   Dali::Vector3 *argp2 ;
37735   unsigned int result;
37736
37737   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37738   argp2 = (Dali::Vector3 *)jarg2;
37739   if (!argp2) {
37740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
37741     return 0;
37742   }
37743   arg2 = *argp2;
37744   {
37745     try {
37746       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
37747     } CALL_CATCH_EXCEPTION(0);
37748   }
37749
37750   jresult = result;
37751   return jresult;
37752 }
37753
37754
37755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
37756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37757   unsigned int arg2 ;
37758   Dali::Vector3 *arg3 = 0 ;
37759   Dali::Vector3 *arg4 = 0 ;
37760
37761   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37762   arg2 = (unsigned int)jarg2;
37763   arg3 = (Dali::Vector3 *)jarg3;
37764   if (!arg3) {
37765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37766     return ;
37767   }
37768   arg4 = (Dali::Vector3 *)jarg4;
37769   if (!arg4) {
37770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37771     return ;
37772   }
37773   {
37774     try {
37775       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
37776     } CALL_CATCH_EXCEPTION();
37777   }
37778
37779 }
37780
37781
37782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
37783   void * jresult ;
37784   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37785   Dali::Degree result;
37786
37787   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37788   {
37789     try {
37790       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
37791     } CALL_CATCH_EXCEPTION(0);
37792   }
37793
37794   jresult = new Dali::Degree((const Dali::Degree &)result);
37795   return jresult;
37796 }
37797
37798
37799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
37800   float jresult ;
37801   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37802   float result;
37803
37804   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37805   {
37806     try {
37807       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
37808     } CALL_CATCH_EXCEPTION(0);
37809   }
37810
37811   jresult = result;
37812   return jresult;
37813 }
37814
37815
37816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
37817   float jresult ;
37818   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37819   float result;
37820
37821   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37822   {
37823     try {
37824       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
37825     } CALL_CATCH_EXCEPTION(0);
37826   }
37827
37828   jresult = result;
37829   return jresult;
37830 }
37831
37832
37833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
37834   float jresult ;
37835   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37836   float result;
37837
37838   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37839   {
37840     try {
37841       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
37842     } CALL_CATCH_EXCEPTION(0);
37843   }
37844
37845   jresult = result;
37846   return jresult;
37847 }
37848
37849
37850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
37851   int jresult ;
37852   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37853   int arg2 ;
37854   int arg3 ;
37855   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
37856   bool arg5 ;
37857   int result;
37858
37859   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37860   arg2 = (int)jarg2;
37861   arg3 = (int)jarg3;
37862   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
37863   arg5 = jarg5 ? true : false;
37864   {
37865     try {
37866       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
37867     } CALL_CATCH_EXCEPTION(0);
37868   }
37869
37870   jresult = result;
37871   return jresult;
37872 }
37873
37874
37875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
37876   float jresult ;
37877   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37878   float result;
37879
37880   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37881   {
37882     try {
37883       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
37884     } CALL_CATCH_EXCEPTION(0);
37885   }
37886
37887   jresult = result;
37888   return jresult;
37889 }
37890
37891
37892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
37893   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37894   Dali::Actor *arg2 = 0 ;
37895   int arg3 ;
37896   Dali::Vector3 *arg4 = 0 ;
37897   Dali::Actor *arg5 = 0 ;
37898
37899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37900   arg2 = (Dali::Actor *)jarg2;
37901   if (!arg2) {
37902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37903     return ;
37904   }
37905   arg3 = (int)jarg3;
37906   arg4 = (Dali::Vector3 *)jarg4;
37907   if (!arg4) {
37908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37909     return ;
37910   }
37911   arg5 = (Dali::Actor *)jarg5;
37912   if (!arg5) {
37913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
37914     return ;
37915   }
37916   {
37917     try {
37918       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
37919     } CALL_CATCH_EXCEPTION();
37920   }
37921
37922 }
37923
37924
37925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
37926   void * jresult ;
37927   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
37928   int arg2 ;
37929   float arg3 ;
37930   Dali::Vector3 *arg4 = 0 ;
37931   Dali::Vector3 result;
37932
37933   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
37934   arg2 = (int)jarg2;
37935   arg3 = (float)jarg3;
37936   arg4 = (Dali::Vector3 *)jarg4;
37937   if (!arg4) {
37938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37939     return 0;
37940   }
37941   {
37942     try {
37943       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
37944     } CALL_CATCH_EXCEPTION(0);
37945   }
37946
37947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
37948   return jresult;
37949 }
37950
37951
37952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
37953   void * jresult ;
37954   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
37955   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
37956
37957   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
37958   {
37959     try {
37960       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
37961     } CALL_CATCH_EXCEPTION(0);
37962   }
37963
37964   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
37965   return jresult;
37966 }
37967
37968
37969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
37970   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
37971
37972   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
37973   {
37974     try {
37975       delete arg1;
37976     } CALL_CATCH_EXCEPTION();
37977   }
37978
37979 }
37980
37981
37982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
37983   unsigned int jresult ;
37984   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
37985   unsigned int result;
37986
37987   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
37988   {
37989     try {
37990       result = (unsigned int)(arg1)->GetNumberOfItems();
37991     } CALL_CATCH_EXCEPTION(0);
37992   }
37993
37994   jresult = result;
37995   return jresult;
37996 }
37997
37998
37999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
38000   void * jresult ;
38001   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
38002   unsigned int arg2 ;
38003   Dali::Actor result;
38004
38005   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
38006   arg2 = (unsigned int)jarg2;
38007   {
38008     try {
38009       result = (arg1)->NewItem(arg2);
38010     } CALL_CATCH_EXCEPTION(0);
38011   }
38012
38013   jresult = new Dali::Actor((const Dali::Actor &)result);
38014   return jresult;
38015 }
38016
38017
38018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
38019   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
38020   unsigned int arg2 ;
38021   Dali::Actor arg3 ;
38022   Dali::Actor *argp3 ;
38023
38024   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
38025   arg2 = (unsigned int)jarg2;
38026   argp3 = (Dali::Actor *)jarg3;
38027   if (!argp3) {
38028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38029     return ;
38030   }
38031   arg3 = *argp3;
38032   {
38033     try {
38034       (arg1)->ItemReleased(arg2,arg3);
38035     } CALL_CATCH_EXCEPTION();
38036   }
38037
38038 }
38039
38040
38041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
38042   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
38043   unsigned int arg2 ;
38044   Dali::Actor arg3 ;
38045   Dali::Actor *argp3 ;
38046
38047   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
38048   arg2 = (unsigned int)jarg2;
38049   argp3 = (Dali::Actor *)jarg3;
38050   if (!argp3) {
38051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38052     return ;
38053   }
38054   arg3 = *argp3;
38055   {
38056     try {
38057       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
38058     } CALL_CATCH_EXCEPTION();
38059   }
38060
38061 }
38062
38063
38064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
38065   void * jresult ;
38066   Dali::Toolkit::ItemFactory *result = 0 ;
38067
38068   {
38069     try {
38070       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
38071     } CALL_CATCH_EXCEPTION(0);
38072   }
38073
38074   jresult = (void *)result;
38075   return jresult;
38076 }
38077
38078
38079 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) {
38080   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
38081   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
38082   if (director) {
38083     director->swig_connect_director(callback0, callback1, callback2);
38084   }
38085 }
38086
38087
38088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
38089   int jresult ;
38090   int result;
38091
38092   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
38093   jresult = (int)result;
38094   return jresult;
38095 }
38096
38097
38098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
38099   int jresult ;
38100   int result;
38101
38102   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
38103   jresult = (int)result;
38104   return jresult;
38105 }
38106
38107
38108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
38109   int jresult ;
38110   int result;
38111
38112   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
38113   jresult = (int)result;
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
38119   int jresult ;
38120   int result;
38121
38122   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
38123   jresult = (int)result;
38124   return jresult;
38125 }
38126
38127
38128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
38129   int jresult ;
38130   int result;
38131
38132   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
38133   jresult = (int)result;
38134   return jresult;
38135 }
38136
38137
38138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
38139   int jresult ;
38140   int result;
38141
38142   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
38143   jresult = (int)result;
38144   return jresult;
38145 }
38146
38147
38148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
38149   int jresult ;
38150   int result;
38151
38152   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
38153   jresult = (int)result;
38154   return jresult;
38155 }
38156
38157
38158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
38159   int jresult ;
38160   int result;
38161
38162   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
38163   jresult = (int)result;
38164   return jresult;
38165 }
38166
38167
38168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
38169   int jresult ;
38170   int result;
38171
38172   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
38173   jresult = (int)result;
38174   return jresult;
38175 }
38176
38177
38178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
38179   int jresult ;
38180   int result;
38181
38182   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
38183   jresult = (int)result;
38184   return jresult;
38185 }
38186
38187
38188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
38189   int jresult ;
38190   int result;
38191
38192   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
38193   jresult = (int)result;
38194   return jresult;
38195 }
38196
38197
38198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
38199   void * jresult ;
38200   Dali::Toolkit::ItemView::Property *result = 0 ;
38201
38202   {
38203     try {
38204       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
38205     } CALL_CATCH_EXCEPTION(0);
38206   }
38207
38208   jresult = (void *)result;
38209   return jresult;
38210 }
38211
38212
38213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
38214   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
38215
38216   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
38217   {
38218     try {
38219       delete arg1;
38220     } CALL_CATCH_EXCEPTION();
38221   }
38222
38223 }
38224
38225
38226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
38227   void * jresult ;
38228   Dali::Toolkit::ItemView *result = 0 ;
38229
38230   {
38231     try {
38232       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
38233     } CALL_CATCH_EXCEPTION(0);
38234   }
38235
38236   jresult = (void *)result;
38237   return jresult;
38238 }
38239
38240
38241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
38242   void * jresult ;
38243   Dali::Toolkit::ItemView *arg1 = 0 ;
38244   Dali::Toolkit::ItemView *result = 0 ;
38245
38246   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38247   if (!arg1) {
38248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
38249     return 0;
38250   }
38251   {
38252     try {
38253       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
38254     } CALL_CATCH_EXCEPTION(0);
38255   }
38256
38257   jresult = (void *)result;
38258   return jresult;
38259 }
38260
38261
38262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
38263   void * jresult ;
38264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38265   Dali::Toolkit::ItemView *arg2 = 0 ;
38266   Dali::Toolkit::ItemView *result = 0 ;
38267
38268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38269   arg2 = (Dali::Toolkit::ItemView *)jarg2;
38270   if (!arg2) {
38271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
38272     return 0;
38273   }
38274   {
38275     try {
38276       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
38277     } CALL_CATCH_EXCEPTION(0);
38278   }
38279
38280   jresult = (void *)result;
38281   return jresult;
38282 }
38283
38284
38285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
38286   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38287
38288   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38289   {
38290     try {
38291       delete arg1;
38292     } CALL_CATCH_EXCEPTION();
38293   }
38294
38295 }
38296
38297
38298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
38299   void * jresult ;
38300   Dali::Toolkit::ItemFactory *arg1 = 0 ;
38301   Dali::Toolkit::ItemView result;
38302
38303   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
38304   if (!arg1) {
38305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
38306     return 0;
38307   }
38308   {
38309     try {
38310       result = Dali::Toolkit::ItemView::New(*arg1);
38311     } CALL_CATCH_EXCEPTION(0);
38312   }
38313
38314   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
38315   return jresult;
38316 }
38317
38318
38319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
38320   void * jresult ;
38321   Dali::BaseHandle arg1 ;
38322   Dali::BaseHandle *argp1 ;
38323   Dali::Toolkit::ItemView result;
38324
38325   argp1 = (Dali::BaseHandle *)jarg1;
38326   if (!argp1) {
38327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38328     return 0;
38329   }
38330   arg1 = *argp1;
38331   {
38332     try {
38333       result = Dali::Toolkit::ItemView::DownCast(arg1);
38334     } CALL_CATCH_EXCEPTION(0);
38335   }
38336
38337   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
38338   return jresult;
38339 }
38340
38341
38342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
38343   unsigned int jresult ;
38344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38345   unsigned int result;
38346
38347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38348   {
38349     try {
38350       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
38351     } CALL_CATCH_EXCEPTION(0);
38352   }
38353
38354   jresult = result;
38355   return jresult;
38356 }
38357
38358
38359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
38360   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38361   Dali::Toolkit::ItemLayout *arg2 = 0 ;
38362
38363   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38364   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
38365   if (!arg2) {
38366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
38367     return ;
38368   }
38369   {
38370     try {
38371       (arg1)->AddLayout(*arg2);
38372     } CALL_CATCH_EXCEPTION();
38373   }
38374
38375 }
38376
38377
38378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
38379   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38380   unsigned int arg2 ;
38381
38382   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38383   arg2 = (unsigned int)jarg2;
38384   {
38385     try {
38386       (arg1)->RemoveLayout(arg2);
38387     } CALL_CATCH_EXCEPTION();
38388   }
38389
38390 }
38391
38392
38393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
38394   void * jresult ;
38395   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38396   unsigned int arg2 ;
38397   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
38398
38399   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38400   arg2 = (unsigned int)jarg2;
38401   {
38402     try {
38403       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
38404     } CALL_CATCH_EXCEPTION(0);
38405   }
38406
38407   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
38408   return jresult;
38409 }
38410
38411
38412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
38413   void * jresult ;
38414   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38415   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
38416
38417   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38418   {
38419     try {
38420       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
38421     } CALL_CATCH_EXCEPTION(0);
38422   }
38423
38424   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
38425   return jresult;
38426 }
38427
38428
38429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
38430   float jresult ;
38431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38432   Dali::Toolkit::ItemId arg2 ;
38433   float result;
38434
38435   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38436   arg2 = (Dali::Toolkit::ItemId)jarg2;
38437   {
38438     try {
38439       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
38440     } CALL_CATCH_EXCEPTION(0);
38441   }
38442
38443   jresult = result;
38444   return jresult;
38445 }
38446
38447
38448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
38449   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38450   unsigned int arg2 ;
38451   Dali::Vector3 arg3 ;
38452   float arg4 ;
38453   Dali::Vector3 *argp3 ;
38454
38455   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38456   arg2 = (unsigned int)jarg2;
38457   argp3 = (Dali::Vector3 *)jarg3;
38458   if (!argp3) {
38459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
38460     return ;
38461   }
38462   arg3 = *argp3;
38463   arg4 = (float)jarg4;
38464   {
38465     try {
38466       (arg1)->ActivateLayout(arg2,arg3,arg4);
38467     } CALL_CATCH_EXCEPTION();
38468   }
38469
38470 }
38471
38472
38473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
38474   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38475
38476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38477   {
38478     try {
38479       (arg1)->DeactivateCurrentLayout();
38480     } CALL_CATCH_EXCEPTION();
38481   }
38482
38483 }
38484
38485
38486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
38487   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38488   float arg2 ;
38489
38490   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38491   arg2 = (float)jarg2;
38492   {
38493     try {
38494       (arg1)->SetMinimumSwipeSpeed(arg2);
38495     } CALL_CATCH_EXCEPTION();
38496   }
38497
38498 }
38499
38500
38501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
38502   float jresult ;
38503   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38504   float result;
38505
38506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38507   {
38508     try {
38509       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
38510     } CALL_CATCH_EXCEPTION(0);
38511   }
38512
38513   jresult = result;
38514   return jresult;
38515 }
38516
38517
38518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
38519   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38520   float arg2 ;
38521
38522   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38523   arg2 = (float)jarg2;
38524   {
38525     try {
38526       (arg1)->SetMinimumSwipeDistance(arg2);
38527     } CALL_CATCH_EXCEPTION();
38528   }
38529
38530 }
38531
38532
38533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
38534   float jresult ;
38535   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38536   float result;
38537
38538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38539   {
38540     try {
38541       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
38542     } CALL_CATCH_EXCEPTION(0);
38543   }
38544
38545   jresult = result;
38546   return jresult;
38547 }
38548
38549
38550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
38551   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38552   float arg2 ;
38553
38554   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38555   arg2 = (float)jarg2;
38556   {
38557     try {
38558       (arg1)->SetWheelScrollDistanceStep(arg2);
38559     } CALL_CATCH_EXCEPTION();
38560   }
38561
38562 }
38563
38564
38565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
38566   float jresult ;
38567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38568   float result;
38569
38570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38571   {
38572     try {
38573       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
38574     } CALL_CATCH_EXCEPTION(0);
38575   }
38576
38577   jresult = result;
38578   return jresult;
38579 }
38580
38581
38582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
38583   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38584   bool arg2 ;
38585
38586   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38587   arg2 = jarg2 ? true : false;
38588   {
38589     try {
38590       (arg1)->SetAnchoring(arg2);
38591     } CALL_CATCH_EXCEPTION();
38592   }
38593
38594 }
38595
38596 //// ========================= end of part 3 =============================
38597
38598 //// ========================== start part 4 ===============================
38599
38600
38601 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
38602   bool jresult ;
38603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38604   bool result;
38605
38606   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38607   {
38608     try {
38609       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
38610     } CALL_CATCH_EXCEPTION(0);
38611   }
38612
38613   jresult = result;
38614   return jresult;
38615 }
38616
38617
38618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
38619   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38620   float arg2 ;
38621
38622   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38623   arg2 = (float)jarg2;
38624   {
38625     try {
38626       (arg1)->SetAnchoringDuration(arg2);
38627     } CALL_CATCH_EXCEPTION();
38628   }
38629
38630 }
38631
38632
38633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
38634   float jresult ;
38635   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38636   float result;
38637
38638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38639   {
38640     try {
38641       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
38642     } CALL_CATCH_EXCEPTION(0);
38643   }
38644
38645   jresult = result;
38646   return jresult;
38647 }
38648
38649
38650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
38651   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38652   Dali::Toolkit::ItemId arg2 ;
38653   float arg3 ;
38654
38655   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38656   arg2 = (Dali::Toolkit::ItemId)jarg2;
38657   arg3 = (float)jarg3;
38658   {
38659     try {
38660       (arg1)->ScrollToItem(arg2,arg3);
38661     } CALL_CATCH_EXCEPTION();
38662   }
38663
38664 }
38665
38666
38667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
38668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38669   float arg2 ;
38670
38671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38672   arg2 = (float)jarg2;
38673   {
38674     try {
38675       (arg1)->SetRefreshInterval(arg2);
38676     } CALL_CATCH_EXCEPTION();
38677   }
38678
38679 }
38680
38681
38682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
38683   float jresult ;
38684   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38685   float result;
38686
38687   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38688   {
38689     try {
38690       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
38691     } CALL_CATCH_EXCEPTION(0);
38692   }
38693
38694   jresult = result;
38695   return jresult;
38696 }
38697
38698
38699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
38700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38701
38702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38703   {
38704     try {
38705       (arg1)->Refresh();
38706     } CALL_CATCH_EXCEPTION();
38707   }
38708
38709 }
38710
38711
38712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
38713   void * jresult ;
38714   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38715   Dali::Toolkit::ItemId arg2 ;
38716   Dali::Actor result;
38717
38718   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38719   arg2 = (Dali::Toolkit::ItemId)jarg2;
38720   {
38721     try {
38722       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
38723     } CALL_CATCH_EXCEPTION(0);
38724   }
38725
38726   jresult = new Dali::Actor((const Dali::Actor &)result);
38727   return jresult;
38728 }
38729
38730
38731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
38732   unsigned int jresult ;
38733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38734   Dali::Actor arg2 ;
38735   Dali::Actor *argp2 ;
38736   Dali::Toolkit::ItemId result;
38737
38738   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38739   argp2 = (Dali::Actor *)jarg2;
38740   if (!argp2) {
38741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38742     return 0;
38743   }
38744   arg2 = *argp2;
38745   {
38746     try {
38747       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
38748     } CALL_CATCH_EXCEPTION(0);
38749   }
38750
38751   jresult = result;
38752   return jresult;
38753 }
38754
38755
38756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
38757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38758   Dali::Toolkit::Item arg2 ;
38759   float arg3 ;
38760   Dali::Toolkit::Item *argp2 ;
38761
38762   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38763   argp2 = (Dali::Toolkit::Item *)jarg2;
38764   if (!argp2) {
38765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
38766     return ;
38767   }
38768   arg2 = *argp2;
38769   arg3 = (float)jarg3;
38770   {
38771     try {
38772       (arg1)->InsertItem(arg2,arg3);
38773     } CALL_CATCH_EXCEPTION();
38774   }
38775
38776 }
38777
38778
38779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
38780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38781   Dali::Toolkit::ItemContainer *arg2 = 0 ;
38782   float arg3 ;
38783
38784   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38785   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
38786   if (!arg2) {
38787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
38788     return ;
38789   }
38790   arg3 = (float)jarg3;
38791   {
38792     try {
38793       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
38794     } CALL_CATCH_EXCEPTION();
38795   }
38796
38797 }
38798
38799
38800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
38801   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38802   Dali::Toolkit::ItemId arg2 ;
38803   float arg3 ;
38804
38805   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38806   arg2 = (Dali::Toolkit::ItemId)jarg2;
38807   arg3 = (float)jarg3;
38808   {
38809     try {
38810       (arg1)->RemoveItem(arg2,arg3);
38811     } CALL_CATCH_EXCEPTION();
38812   }
38813
38814 }
38815
38816
38817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
38818   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38819   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
38820   float arg3 ;
38821
38822   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38823   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
38824   if (!arg2) {
38825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
38826     return ;
38827   }
38828   arg3 = (float)jarg3;
38829   {
38830     try {
38831       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
38832     } CALL_CATCH_EXCEPTION();
38833   }
38834
38835 }
38836
38837
38838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
38839   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38840   Dali::Toolkit::Item arg2 ;
38841   float arg3 ;
38842   Dali::Toolkit::Item *argp2 ;
38843
38844   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38845   argp2 = (Dali::Toolkit::Item *)jarg2;
38846   if (!argp2) {
38847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
38848     return ;
38849   }
38850   arg2 = *argp2;
38851   arg3 = (float)jarg3;
38852   {
38853     try {
38854       (arg1)->ReplaceItem(arg2,arg3);
38855     } CALL_CATCH_EXCEPTION();
38856   }
38857
38858 }
38859
38860
38861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
38862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38863   Dali::Toolkit::ItemContainer *arg2 = 0 ;
38864   float arg3 ;
38865
38866   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38867   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
38868   if (!arg2) {
38869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
38870     return ;
38871   }
38872   arg3 = (float)jarg3;
38873   {
38874     try {
38875       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
38876     } CALL_CATCH_EXCEPTION();
38877   }
38878
38879 }
38880
38881
38882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
38883   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38884   Dali::Vector3 *arg2 = 0 ;
38885
38886   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38887   arg2 = (Dali::Vector3 *)jarg2;
38888   if (!arg2) {
38889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38890     return ;
38891   }
38892   {
38893     try {
38894       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
38895     } CALL_CATCH_EXCEPTION();
38896   }
38897
38898 }
38899
38900
38901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
38902   void * jresult ;
38903   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38904   Dali::Vector3 result;
38905
38906   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38907   {
38908     try {
38909       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
38910     } CALL_CATCH_EXCEPTION(0);
38911   }
38912
38913   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38914   return jresult;
38915 }
38916
38917
38918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
38919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38920   Dali::Vector3 *arg2 = 0 ;
38921
38922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38923   arg2 = (Dali::Vector3 *)jarg2;
38924   if (!arg2) {
38925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38926     return ;
38927   }
38928   {
38929     try {
38930       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
38931     } CALL_CATCH_EXCEPTION();
38932   }
38933
38934 }
38935
38936
38937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
38938   void * jresult ;
38939   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38940   Dali::Vector3 result;
38941
38942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38943   {
38944     try {
38945       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
38946     } CALL_CATCH_EXCEPTION(0);
38947   }
38948
38949   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38950   return jresult;
38951 }
38952
38953
38954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
38955   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38956   Dali::Toolkit::ItemRange *arg2 = 0 ;
38957
38958   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38959   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
38960   if (!arg2) {
38961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
38962     return ;
38963   }
38964   {
38965     try {
38966       (arg1)->GetItemsRange(*arg2);
38967     } CALL_CATCH_EXCEPTION();
38968   }
38969
38970 }
38971
38972
38973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
38974   void * jresult ;
38975   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
38976   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
38977
38978   arg1 = (Dali::Toolkit::ItemView *)jarg1;
38979   {
38980     try {
38981       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
38982     } CALL_CATCH_EXCEPTION(0);
38983   }
38984
38985   jresult = (void *)result;
38986   return jresult;
38987 }
38988
38989
38990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
38991   Dali::Vector3 *arg1 = 0 ;
38992   PropertyInputContainer *arg2 = 0 ;
38993
38994   arg1 = (Dali::Vector3 *)jarg1;
38995   if (!arg1) {
38996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38997     return ;
38998   }
38999   arg2 = (PropertyInputContainer *)jarg2;
39000   if (!arg2) {
39001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
39002     return ;
39003   }
39004   {
39005     try {
39006       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
39007     } CALL_CATCH_EXCEPTION();
39008   }
39009
39010 }
39011
39012
39013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
39014   Dali::Vector3 *arg1 = 0 ;
39015   PropertyInputContainer *arg2 = 0 ;
39016
39017   arg1 = (Dali::Vector3 *)jarg1;
39018   if (!arg1) {
39019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
39020     return ;
39021   }
39022   arg2 = (PropertyInputContainer *)jarg2;
39023   if (!arg2) {
39024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
39025     return ;
39026   }
39027   {
39028     try {
39029       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
39030     } CALL_CATCH_EXCEPTION();
39031   }
39032
39033 }
39034
39035
39036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
39037   void * jresult ;
39038   Dali::Toolkit::ScrollViewEffect *result = 0 ;
39039
39040   {
39041     try {
39042       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
39043     } CALL_CATCH_EXCEPTION(0);
39044   }
39045
39046   jresult = (void *)result;
39047   return jresult;
39048 }
39049
39050
39051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
39052   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
39053
39054   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
39055   {
39056     try {
39057       delete arg1;
39058     } CALL_CATCH_EXCEPTION();
39059   }
39060
39061 }
39062
39063
39064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
39065   void * jresult ;
39066   Dali::Path arg1 ;
39067   Dali::Vector3 *arg2 = 0 ;
39068   Dali::Property::Index arg3 ;
39069   Dali::Vector3 *arg4 = 0 ;
39070   unsigned int arg5 ;
39071   Dali::Path *argp1 ;
39072   Dali::Toolkit::ScrollViewPagePathEffect result;
39073
39074   argp1 = (Dali::Path *)jarg1;
39075   if (!argp1) {
39076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39077     return 0;
39078   }
39079   arg1 = *argp1;
39080   arg2 = (Dali::Vector3 *)jarg2;
39081   if (!arg2) {
39082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39083     return 0;
39084   }
39085   arg3 = (Dali::Property::Index)jarg3;
39086   arg4 = (Dali::Vector3 *)jarg4;
39087   if (!arg4) {
39088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39089     return 0;
39090   }
39091   arg5 = (unsigned int)jarg5;
39092   {
39093     try {
39094       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39095     } CALL_CATCH_EXCEPTION(0);
39096   }
39097
39098   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
39099   return jresult;
39100 }
39101
39102
39103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
39104   void * jresult ;
39105   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
39106
39107   {
39108     try {
39109       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
39110     } CALL_CATCH_EXCEPTION(0);
39111   }
39112
39113   jresult = (void *)result;
39114   return jresult;
39115 }
39116
39117
39118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
39119   void * jresult ;
39120   Dali::BaseHandle arg1 ;
39121   Dali::BaseHandle *argp1 ;
39122   Dali::Toolkit::ScrollViewPagePathEffect result;
39123
39124   argp1 = (Dali::BaseHandle *)jarg1;
39125   if (!argp1) {
39126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39127     return 0;
39128   }
39129   arg1 = *argp1;
39130   {
39131     try {
39132       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
39133     } CALL_CATCH_EXCEPTION(0);
39134   }
39135
39136   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
39137   return jresult;
39138 }
39139
39140
39141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
39142   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
39143   Dali::Actor arg2 ;
39144   unsigned int arg3 ;
39145   Dali::Actor *argp2 ;
39146
39147   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
39148   argp2 = (Dali::Actor *)jarg2;
39149   if (!argp2) {
39150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39151     return ;
39152   }
39153   arg2 = *argp2;
39154   arg3 = (unsigned int)jarg3;
39155   {
39156     try {
39157       (arg1)->ApplyToPage(arg2,arg3);
39158     } CALL_CATCH_EXCEPTION();
39159   }
39160
39161 }
39162
39163
39164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
39165   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
39166
39167   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
39168   {
39169     try {
39170       delete arg1;
39171     } CALL_CATCH_EXCEPTION();
39172   }
39173
39174 }
39175
39176
39177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
39178   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
39179   Dali::Toolkit::ClampState arg2 ;
39180
39181   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
39182   arg2 = (Dali::Toolkit::ClampState)jarg2;
39183   if (arg1) (arg1)->x = arg2;
39184 }
39185
39186
39187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
39188   int jresult ;
39189   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
39190   Dali::Toolkit::ClampState result;
39191
39192   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
39193   result = (Dali::Toolkit::ClampState) ((arg1)->x);
39194   jresult = (int)result;
39195   return jresult;
39196 }
39197
39198
39199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
39200   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
39201   Dali::Toolkit::ClampState arg2 ;
39202
39203   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
39204   arg2 = (Dali::Toolkit::ClampState)jarg2;
39205   if (arg1) (arg1)->y = arg2;
39206 }
39207
39208
39209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
39210   int jresult ;
39211   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
39212   Dali::Toolkit::ClampState result;
39213
39214   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
39215   result = (Dali::Toolkit::ClampState) ((arg1)->y);
39216   jresult = (int)result;
39217   return jresult;
39218 }
39219
39220
39221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
39222   void * jresult ;
39223   Dali::Toolkit::ClampState2D *result = 0 ;
39224
39225   {
39226     try {
39227       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
39228     } CALL_CATCH_EXCEPTION(0);
39229   }
39230
39231   jresult = (void *)result;
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
39237   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
39238
39239   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
39240   {
39241     try {
39242       delete arg1;
39243     } CALL_CATCH_EXCEPTION();
39244   }
39245
39246 }
39247
39248
39249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
39250   void * jresult ;
39251   float arg1 ;
39252   float arg2 ;
39253   bool arg3 ;
39254   Dali::Toolkit::RulerDomain *result = 0 ;
39255
39256   arg1 = (float)jarg1;
39257   arg2 = (float)jarg2;
39258   arg3 = jarg3 ? true : false;
39259   {
39260     try {
39261       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
39262     } CALL_CATCH_EXCEPTION(0);
39263   }
39264
39265   jresult = (void *)result;
39266   return jresult;
39267 }
39268
39269
39270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
39271   void * jresult ;
39272   float arg1 ;
39273   float arg2 ;
39274   Dali::Toolkit::RulerDomain *result = 0 ;
39275
39276   arg1 = (float)jarg1;
39277   arg2 = (float)jarg2;
39278   {
39279     try {
39280       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
39281     } CALL_CATCH_EXCEPTION(0);
39282   }
39283
39284   jresult = (void *)result;
39285   return jresult;
39286 }
39287
39288
39289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
39290   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39291   float arg2 ;
39292
39293   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39294   arg2 = (float)jarg2;
39295   if (arg1) (arg1)->min = arg2;
39296 }
39297
39298
39299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
39300   float jresult ;
39301   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39302   float result;
39303
39304   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39305   result = (float) ((arg1)->min);
39306   jresult = result;
39307   return jresult;
39308 }
39309
39310
39311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
39312   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39313   float arg2 ;
39314
39315   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39316   arg2 = (float)jarg2;
39317   if (arg1) (arg1)->max = arg2;
39318 }
39319
39320
39321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
39322   float jresult ;
39323   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39324   float result;
39325
39326   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39327   result = (float) ((arg1)->max);
39328   jresult = result;
39329   return jresult;
39330 }
39331
39332
39333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
39334   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39335   bool arg2 ;
39336
39337   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39338   arg2 = jarg2 ? true : false;
39339   if (arg1) (arg1)->enabled = arg2;
39340 }
39341
39342
39343 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
39344   bool jresult ;
39345   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39346   bool result;
39347
39348   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39349   result = (bool) ((arg1)->enabled);
39350   jresult = result;
39351   return jresult;
39352 }
39353
39354
39355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
39356   float jresult ;
39357   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39358   float arg2 ;
39359   float arg3 ;
39360   float arg4 ;
39361   float result;
39362
39363   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39364   arg2 = (float)jarg2;
39365   arg3 = (float)jarg3;
39366   arg4 = (float)jarg4;
39367   {
39368     try {
39369       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
39370     } CALL_CATCH_EXCEPTION(0);
39371   }
39372
39373   jresult = result;
39374   return jresult;
39375 }
39376
39377
39378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
39379   float jresult ;
39380   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39381   float arg2 ;
39382   float arg3 ;
39383   float result;
39384
39385   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39386   arg2 = (float)jarg2;
39387   arg3 = (float)jarg3;
39388   {
39389     try {
39390       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
39391     } CALL_CATCH_EXCEPTION(0);
39392   }
39393
39394   jresult = result;
39395   return jresult;
39396 }
39397
39398
39399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
39400   float jresult ;
39401   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39402   float arg2 ;
39403   float result;
39404
39405   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39406   arg2 = (float)jarg2;
39407   {
39408     try {
39409       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
39410     } CALL_CATCH_EXCEPTION(0);
39411   }
39412
39413   jresult = result;
39414   return jresult;
39415 }
39416
39417
39418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
39419   float jresult ;
39420   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39421   float arg2 ;
39422   float arg3 ;
39423   float arg4 ;
39424   Dali::Toolkit::ClampState *arg5 = 0 ;
39425   float result;
39426
39427   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39428   arg2 = (float)jarg2;
39429   arg3 = (float)jarg3;
39430   arg4 = (float)jarg4;
39431   arg5 = (Dali::Toolkit::ClampState *)jarg5;
39432   if (!arg5) {
39433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
39434     return 0;
39435   }
39436   {
39437     try {
39438       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
39439     } CALL_CATCH_EXCEPTION(0);
39440   }
39441
39442   jresult = result;
39443   return jresult;
39444 }
39445
39446
39447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
39448   float jresult ;
39449   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39450   float result;
39451
39452   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39453   {
39454     try {
39455       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
39456     } CALL_CATCH_EXCEPTION(0);
39457   }
39458
39459   jresult = result;
39460   return jresult;
39461 }
39462
39463
39464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
39465   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
39466
39467   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
39468   {
39469     try {
39470       delete arg1;
39471     } CALL_CATCH_EXCEPTION();
39472   }
39473
39474 }
39475
39476
39477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
39478   float jresult ;
39479   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39480   float arg2 ;
39481   float arg3 ;
39482   float result;
39483
39484   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39485   arg2 = (float)jarg2;
39486   arg3 = (float)jarg3;
39487   {
39488     try {
39489       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
39490     } CALL_CATCH_EXCEPTION(0);
39491   }
39492
39493   jresult = result;
39494   return jresult;
39495 }
39496
39497
39498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
39499   float jresult ;
39500   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39501   float arg2 ;
39502   float result;
39503
39504   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39505   arg2 = (float)jarg2;
39506   {
39507     try {
39508       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
39509     } CALL_CATCH_EXCEPTION(0);
39510   }
39511
39512   jresult = result;
39513   return jresult;
39514 }
39515
39516
39517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
39518   float jresult ;
39519   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39520   unsigned int arg2 ;
39521   unsigned int *arg3 = 0 ;
39522   bool arg4 ;
39523   float result;
39524
39525   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39526   arg2 = (unsigned int)jarg2;
39527   arg3 = (unsigned int *)jarg3;
39528   arg4 = jarg4 ? true : false;
39529   {
39530     try {
39531       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
39532     } CALL_CATCH_EXCEPTION(0);
39533   }
39534
39535   jresult = result;
39536   return jresult;
39537 }
39538
39539
39540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
39541   unsigned int jresult ;
39542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39543   float arg2 ;
39544   bool arg3 ;
39545   unsigned int result;
39546
39547   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39548   arg2 = (float)jarg2;
39549   arg3 = jarg3 ? true : false;
39550   {
39551     try {
39552       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
39553     } CALL_CATCH_EXCEPTION(0);
39554   }
39555
39556   jresult = result;
39557   return jresult;
39558 }
39559
39560
39561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
39562   unsigned int jresult ;
39563   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39564   unsigned int result;
39565
39566   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39567   {
39568     try {
39569       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
39570     } CALL_CATCH_EXCEPTION(0);
39571   }
39572
39573   jresult = result;
39574   return jresult;
39575 }
39576
39577
39578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
39579   int jresult ;
39580   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39581   Dali::Toolkit::Ruler::RulerType result;
39582
39583   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39584   {
39585     try {
39586       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
39587     } CALL_CATCH_EXCEPTION(0);
39588   }
39589
39590   jresult = (int)result;
39591   return jresult;
39592 }
39593
39594
39595 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
39596   bool jresult ;
39597   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39598   bool result;
39599
39600   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39601   {
39602     try {
39603       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
39604     } CALL_CATCH_EXCEPTION(0);
39605   }
39606
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
39613   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39614
39615   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39616   {
39617     try {
39618       (arg1)->Enable();
39619     } CALL_CATCH_EXCEPTION();
39620   }
39621
39622 }
39623
39624
39625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
39626   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39627
39628   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39629   {
39630     try {
39631       (arg1)->Disable();
39632     } CALL_CATCH_EXCEPTION();
39633   }
39634
39635 }
39636
39637
39638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
39639   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39640   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
39641   Dali::Toolkit::RulerDomain *argp2 ;
39642
39643   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39644   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
39645   if (!argp2) {
39646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
39647     return ;
39648   }
39649   arg2 = *argp2;
39650   {
39651     try {
39652       (arg1)->SetDomain(arg2);
39653     } CALL_CATCH_EXCEPTION();
39654   }
39655
39656 }
39657
39658
39659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
39660   void * jresult ;
39661   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39662   Dali::Toolkit::RulerDomain *result = 0 ;
39663
39664   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39665   {
39666     try {
39667       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
39668     } CALL_CATCH_EXCEPTION(0);
39669   }
39670
39671   jresult = (void *)result;
39672   return jresult;
39673 }
39674
39675
39676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
39677   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39678
39679   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39680   {
39681     try {
39682       (arg1)->DisableDomain();
39683     } CALL_CATCH_EXCEPTION();
39684   }
39685
39686 }
39687
39688
39689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
39690   float jresult ;
39691   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39692   float arg2 ;
39693   float arg3 ;
39694   float arg4 ;
39695   float result;
39696
39697   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39698   arg2 = (float)jarg2;
39699   arg3 = (float)jarg3;
39700   arg4 = (float)jarg4;
39701   {
39702     try {
39703       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
39704     } CALL_CATCH_EXCEPTION(0);
39705   }
39706
39707   jresult = result;
39708   return jresult;
39709 }
39710
39711
39712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
39713   float jresult ;
39714   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39715   float arg2 ;
39716   float arg3 ;
39717   float result;
39718
39719   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39720   arg2 = (float)jarg2;
39721   arg3 = (float)jarg3;
39722   {
39723     try {
39724       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
39725     } CALL_CATCH_EXCEPTION(0);
39726   }
39727
39728   jresult = result;
39729   return jresult;
39730 }
39731
39732
39733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
39734   float jresult ;
39735   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39736   float arg2 ;
39737   float result;
39738
39739   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39740   arg2 = (float)jarg2;
39741   {
39742     try {
39743       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
39744     } CALL_CATCH_EXCEPTION(0);
39745   }
39746
39747   jresult = result;
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
39753   float jresult ;
39754   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39755   float arg2 ;
39756   float arg3 ;
39757   float arg4 ;
39758   Dali::Toolkit::ClampState *arg5 = 0 ;
39759   float result;
39760
39761   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39762   arg2 = (float)jarg2;
39763   arg3 = (float)jarg3;
39764   arg4 = (float)jarg4;
39765   arg5 = (Dali::Toolkit::ClampState *)jarg5;
39766   if (!arg5) {
39767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
39768     return 0;
39769   }
39770   {
39771     try {
39772       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
39773     } CALL_CATCH_EXCEPTION(0);
39774   }
39775
39776   jresult = result;
39777   return jresult;
39778 }
39779
39780
39781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
39782   float jresult ;
39783   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39784   float arg2 ;
39785   float arg3 ;
39786   float arg4 ;
39787   float arg5 ;
39788   float result;
39789
39790   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39791   arg2 = (float)jarg2;
39792   arg3 = (float)jarg3;
39793   arg4 = (float)jarg4;
39794   arg5 = (float)jarg5;
39795   {
39796     try {
39797       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
39798     } CALL_CATCH_EXCEPTION(0);
39799   }
39800
39801   jresult = result;
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
39807   float jresult ;
39808   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39809   float arg2 ;
39810   float arg3 ;
39811   float arg4 ;
39812   float result;
39813
39814   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39815   arg2 = (float)jarg2;
39816   arg3 = (float)jarg3;
39817   arg4 = (float)jarg4;
39818   {
39819     try {
39820       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
39821     } CALL_CATCH_EXCEPTION(0);
39822   }
39823
39824   jresult = result;
39825   return jresult;
39826 }
39827
39828
39829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
39830   float jresult ;
39831   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39832   float arg2 ;
39833   float arg3 ;
39834   float result;
39835
39836   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39837   arg2 = (float)jarg2;
39838   arg3 = (float)jarg3;
39839   {
39840     try {
39841       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
39842     } CALL_CATCH_EXCEPTION(0);
39843   }
39844
39845   jresult = result;
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
39851   float jresult ;
39852   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39853   float arg2 ;
39854   float result;
39855
39856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39857   arg2 = (float)jarg2;
39858   {
39859     try {
39860       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
39861     } CALL_CATCH_EXCEPTION(0);
39862   }
39863
39864   jresult = result;
39865   return jresult;
39866 }
39867
39868
39869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
39870   float jresult ;
39871   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
39872   float arg2 ;
39873   float arg3 ;
39874   float arg4 ;
39875   float arg5 ;
39876   Dali::Toolkit::ClampState *arg6 = 0 ;
39877   float result;
39878
39879   arg1 = (Dali::Toolkit::Ruler *)jarg1;
39880   arg2 = (float)jarg2;
39881   arg3 = (float)jarg3;
39882   arg4 = (float)jarg4;
39883   arg5 = (float)jarg5;
39884   arg6 = (Dali::Toolkit::ClampState *)jarg6;
39885   if (!arg6) {
39886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
39887     return 0;
39888   }
39889   {
39890     try {
39891       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
39892     } CALL_CATCH_EXCEPTION(0);
39893   }
39894
39895   jresult = result;
39896   return jresult;
39897 }
39898
39899
39900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
39901   void * jresult ;
39902   Dali::Toolkit::DefaultRuler *result = 0 ;
39903
39904   {
39905     try {
39906       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
39907     } CALL_CATCH_EXCEPTION(0);
39908   }
39909
39910   jresult = (void *)result;
39911   return jresult;
39912 }
39913
39914
39915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
39916   float jresult ;
39917   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
39918   float arg2 ;
39919   float arg3 ;
39920   float result;
39921
39922   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
39923   arg2 = (float)jarg2;
39924   arg3 = (float)jarg3;
39925   {
39926     try {
39927       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
39928     } CALL_CATCH_EXCEPTION(0);
39929   }
39930
39931   jresult = result;
39932   return jresult;
39933 }
39934
39935
39936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
39937   float jresult ;
39938   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
39939   unsigned int arg2 ;
39940   unsigned int *arg3 = 0 ;
39941   bool arg4 ;
39942   float result;
39943
39944   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
39945   arg2 = (unsigned int)jarg2;
39946   arg3 = (unsigned int *)jarg3;
39947   arg4 = jarg4 ? true : false;
39948   {
39949     try {
39950       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
39951     } CALL_CATCH_EXCEPTION(0);
39952   }
39953
39954   jresult = result;
39955   return jresult;
39956 }
39957
39958
39959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
39960   unsigned int jresult ;
39961   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
39962   float arg2 ;
39963   bool arg3 ;
39964   unsigned int result;
39965
39966   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
39967   arg2 = (float)jarg2;
39968   arg3 = jarg3 ? true : false;
39969   {
39970     try {
39971       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
39972     } CALL_CATCH_EXCEPTION(0);
39973   }
39974
39975   jresult = result;
39976   return jresult;
39977 }
39978
39979
39980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
39981   unsigned int jresult ;
39982   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
39983   unsigned int result;
39984
39985   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
39986   {
39987     try {
39988       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
39989     } CALL_CATCH_EXCEPTION(0);
39990   }
39991
39992   jresult = result;
39993   return jresult;
39994 }
39995
39996
39997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
39998   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
39999
40000   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
40001   {
40002     try {
40003       delete arg1;
40004     } CALL_CATCH_EXCEPTION();
40005   }
40006
40007 }
40008
40009
40010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
40011   void * jresult ;
40012   float arg1 ;
40013   Dali::Toolkit::FixedRuler *result = 0 ;
40014
40015   arg1 = (float)jarg1;
40016   {
40017     try {
40018       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
40019     } CALL_CATCH_EXCEPTION(0);
40020   }
40021
40022   jresult = (void *)result;
40023   return jresult;
40024 }
40025
40026
40027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
40028   void * jresult ;
40029   Dali::Toolkit::FixedRuler *result = 0 ;
40030
40031   {
40032     try {
40033       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
40034     } CALL_CATCH_EXCEPTION(0);
40035   }
40036
40037   jresult = (void *)result;
40038   return jresult;
40039 }
40040
40041
40042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
40043   float jresult ;
40044   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
40045   float arg2 ;
40046   float arg3 ;
40047   float result;
40048
40049   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
40050   arg2 = (float)jarg2;
40051   arg3 = (float)jarg3;
40052   {
40053     try {
40054       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
40055     } CALL_CATCH_EXCEPTION(0);
40056   }
40057
40058   jresult = result;
40059   return jresult;
40060 }
40061
40062
40063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
40064   float jresult ;
40065   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
40066   unsigned int arg2 ;
40067   unsigned int *arg3 = 0 ;
40068   bool arg4 ;
40069   float result;
40070
40071   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
40072   arg2 = (unsigned int)jarg2;
40073   arg3 = (unsigned int *)jarg3;
40074   arg4 = jarg4 ? true : false;
40075   {
40076     try {
40077       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
40078     } CALL_CATCH_EXCEPTION(0);
40079   }
40080
40081   jresult = result;
40082   return jresult;
40083 }
40084
40085
40086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
40087   unsigned int jresult ;
40088   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
40089   float arg2 ;
40090   bool arg3 ;
40091   unsigned int result;
40092
40093   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
40094   arg2 = (float)jarg2;
40095   arg3 = jarg3 ? true : false;
40096   {
40097     try {
40098       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
40099     } CALL_CATCH_EXCEPTION(0);
40100   }
40101
40102   jresult = result;
40103   return jresult;
40104 }
40105
40106
40107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
40108   unsigned int jresult ;
40109   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
40110   unsigned int result;
40111
40112   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
40113   {
40114     try {
40115       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
40116     } CALL_CATCH_EXCEPTION(0);
40117   }
40118
40119   jresult = result;
40120   return jresult;
40121 }
40122
40123
40124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
40125   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
40126
40127   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
40128   {
40129     try {
40130       delete arg1;
40131     } CALL_CATCH_EXCEPTION();
40132   }
40133
40134 }
40135
40136
40137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
40138   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40139   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
40140
40141   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40142   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
40143   if (arg1) (arg1)->scale = *arg2;
40144 }
40145
40146
40147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
40148   void * jresult ;
40149   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40150   Dali::Toolkit::ClampState2D *result = 0 ;
40151
40152   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40153   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
40154   jresult = (void *)result;
40155   return jresult;
40156 }
40157
40158
40159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
40160   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40161   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
40162
40163   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40164   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
40165   if (arg1) (arg1)->position = *arg2;
40166 }
40167
40168
40169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
40170   void * jresult ;
40171   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40172   Dali::Toolkit::ClampState2D *result = 0 ;
40173
40174   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40175   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
40176   jresult = (void *)result;
40177   return jresult;
40178 }
40179
40180
40181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
40182   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40183   Dali::Toolkit::ClampState arg2 ;
40184
40185   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40186   arg2 = (Dali::Toolkit::ClampState)jarg2;
40187   if (arg1) (arg1)->rotation = arg2;
40188 }
40189
40190
40191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
40192   int jresult ;
40193   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40194   Dali::Toolkit::ClampState result;
40195
40196   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40197   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
40198   jresult = (int)result;
40199   return jresult;
40200 }
40201
40202
40203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
40204   void * jresult ;
40205   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
40206
40207   {
40208     try {
40209       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
40210     } CALL_CATCH_EXCEPTION(0);
40211   }
40212
40213   jresult = (void *)result;
40214   return jresult;
40215 }
40216
40217
40218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
40219   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
40220
40221   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
40222   {
40223     try {
40224       delete arg1;
40225     } CALL_CATCH_EXCEPTION();
40226   }
40227
40228 }
40229
40230
40231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
40232   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40233   Dali::Toolkit::SnapType arg2 ;
40234
40235   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40236   arg2 = (Dali::Toolkit::SnapType)jarg2;
40237   if (arg1) (arg1)->type = arg2;
40238 }
40239
40240
40241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
40242   int jresult ;
40243   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40244   Dali::Toolkit::SnapType result;
40245
40246   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40247   result = (Dali::Toolkit::SnapType) ((arg1)->type);
40248   jresult = (int)result;
40249   return jresult;
40250 }
40251
40252
40253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
40254   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40255   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40256
40257   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40258   arg2 = (Dali::Vector2 *)jarg2;
40259   if (arg1) (arg1)->position = *arg2;
40260 }
40261
40262
40263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
40264   void * jresult ;
40265   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40266   Dali::Vector2 *result = 0 ;
40267
40268   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40269   result = (Dali::Vector2 *)& ((arg1)->position);
40270   jresult = (void *)result;
40271   return jresult;
40272 }
40273
40274
40275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
40276   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40277   float arg2 ;
40278
40279   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40280   arg2 = (float)jarg2;
40281   if (arg1) (arg1)->duration = arg2;
40282 }
40283
40284
40285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
40286   float jresult ;
40287   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40288   float result;
40289
40290   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40291   result = (float) ((arg1)->duration);
40292   jresult = result;
40293   return jresult;
40294 }
40295
40296
40297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
40298   void * jresult ;
40299   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
40300
40301   {
40302     try {
40303       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
40304     } CALL_CATCH_EXCEPTION(0);
40305   }
40306
40307   jresult = (void *)result;
40308   return jresult;
40309 }
40310
40311
40312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
40313   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
40314
40315   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
40316   {
40317     try {
40318       delete arg1;
40319     } CALL_CATCH_EXCEPTION();
40320   }
40321
40322 }
40323
40324
40325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
40326   int jresult ;
40327   int result;
40328
40329   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
40330   jresult = (int)result;
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
40336   int jresult ;
40337   int result;
40338
40339   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
40340   jresult = (int)result;
40341   return jresult;
40342 }
40343
40344
40345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
40346   int jresult ;
40347   int result;
40348
40349   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
40350   jresult = (int)result;
40351   return jresult;
40352 }
40353
40354
40355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
40356   int jresult ;
40357   int result;
40358
40359   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
40360   jresult = (int)result;
40361   return jresult;
40362 }
40363
40364
40365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
40366   int jresult ;
40367   int result;
40368
40369   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
40370   jresult = (int)result;
40371   return jresult;
40372 }
40373
40374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
40375   int jresult ;
40376   int result;
40377
40378   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
40379   jresult = (int)result;
40380   return jresult;
40381 }
40382
40383
40384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
40385   int jresult ;
40386   int result;
40387
40388   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
40389   jresult = (int)result;
40390   return jresult;
40391 }
40392
40393
40394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
40395   int jresult ;
40396   int result;
40397
40398   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
40399   jresult = (int)result;
40400   return jresult;
40401 }
40402
40403
40404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
40405   int jresult ;
40406   int result;
40407
40408   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
40409   jresult = (int)result;
40410   return jresult;
40411 }
40412
40413
40414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
40415   int jresult ;
40416   int result;
40417
40418   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
40419   jresult = (int)result;
40420   return jresult;
40421 }
40422
40423
40424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
40425   int jresult ;
40426   int result;
40427
40428   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
40429   jresult = (int)result;
40430   return jresult;
40431 }
40432
40433
40434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
40435   int jresult ;
40436   int result;
40437
40438   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
40439   jresult = (int)result;
40440   return jresult;
40441 }
40442
40443
40444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
40445   int jresult ;
40446   int result;
40447
40448   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
40449   jresult = (int)result;
40450   return jresult;
40451 }
40452
40453
40454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
40455   int jresult ;
40456   int result;
40457
40458   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
40459   jresult = (int)result;
40460   return jresult;
40461 }
40462
40463
40464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
40465   int jresult ;
40466   int result;
40467
40468   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
40469   jresult = (int)result;
40470   return jresult;
40471 }
40472
40473
40474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
40475   int jresult ;
40476   int result;
40477
40478   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
40479   jresult = (int)result;
40480   return jresult;
40481 }
40482
40483
40484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
40485   int jresult ;
40486   int result;
40487
40488   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
40489   jresult = (int)result;
40490   return jresult;
40491 }
40492
40493
40494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
40495   int jresult ;
40496   int result;
40497
40498   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
40499   jresult = (int)result;
40500   return jresult;
40501 }
40502
40503
40504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
40505   int jresult ;
40506   int result;
40507
40508   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
40509   jresult = (int)result;
40510   return jresult;
40511 }
40512
40513
40514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
40515   int jresult ;
40516   int result;
40517
40518   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
40519   jresult = (int)result;
40520   return jresult;
40521 }
40522
40523
40524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
40525   int jresult ;
40526   int result;
40527
40528   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
40529   jresult = (int)result;
40530   return jresult;
40531 }
40532
40533
40534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
40535   int jresult ;
40536   int result;
40537
40538   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
40539   jresult = (int)result;
40540   return jresult;
40541 }
40542
40543
40544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
40545   int jresult ;
40546   int result;
40547
40548   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
40549   jresult = (int)result;
40550   return jresult;
40551 }
40552
40553
40554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
40555   int jresult ;
40556   int result;
40557
40558   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
40559   jresult = (int)result;
40560   return jresult;
40561 }
40562
40563
40564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
40565   int jresult ;
40566   int result;
40567
40568   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
40569   jresult = (int)result;
40570   return jresult;
40571 }
40572
40573
40574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
40575   int jresult ;
40576   int result;
40577
40578   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
40579   jresult = (int)result;
40580   return jresult;
40581 }
40582
40583
40584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
40585   void * jresult ;
40586   Dali::Toolkit::ScrollView::Property *result = 0 ;
40587
40588   {
40589     try {
40590       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
40591     } CALL_CATCH_EXCEPTION(0);
40592   }
40593
40594   jresult = (void *)result;
40595   return jresult;
40596 }
40597
40598
40599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
40600   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
40601
40602   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
40603   {
40604     try {
40605       delete arg1;
40606     } CALL_CATCH_EXCEPTION();
40607   }
40608
40609 }
40610
40611
40612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
40613   void * jresult ;
40614   Dali::Toolkit::ScrollView *result = 0 ;
40615
40616   {
40617     try {
40618       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
40619     } CALL_CATCH_EXCEPTION(0);
40620   }
40621
40622   jresult = (void *)result;
40623   return jresult;
40624 }
40625
40626
40627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
40628   void * jresult ;
40629   Dali::Toolkit::ScrollView *arg1 = 0 ;
40630   Dali::Toolkit::ScrollView *result = 0 ;
40631
40632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40633   if (!arg1) {
40634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
40635     return 0;
40636   }
40637   {
40638     try {
40639       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
40640     } CALL_CATCH_EXCEPTION(0);
40641   }
40642
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
40649   void * jresult ;
40650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40651   Dali::Toolkit::ScrollView *arg2 = 0 ;
40652   Dali::Toolkit::ScrollView *result = 0 ;
40653
40654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40655   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
40656   if (!arg2) {
40657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
40658     return 0;
40659   }
40660   {
40661     try {
40662       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
40663     } CALL_CATCH_EXCEPTION(0);
40664   }
40665
40666   jresult = (void *)result;
40667   return jresult;
40668 }
40669
40670
40671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
40672   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40673
40674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40675   {
40676     try {
40677       delete arg1;
40678     } CALL_CATCH_EXCEPTION();
40679   }
40680
40681 }
40682
40683
40684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
40685   void * jresult ;
40686   Dali::Toolkit::ScrollView result;
40687
40688   {
40689     try {
40690       result = Dali::Toolkit::ScrollView::New();
40691     } CALL_CATCH_EXCEPTION(0);
40692   }
40693
40694   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
40695   return jresult;
40696 }
40697
40698
40699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
40700   void * jresult ;
40701   Dali::BaseHandle arg1 ;
40702   Dali::BaseHandle *argp1 ;
40703   Dali::Toolkit::ScrollView result;
40704
40705   argp1 = (Dali::BaseHandle *)jarg1;
40706   if (!argp1) {
40707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40708     return 0;
40709   }
40710   arg1 = *argp1;
40711   {
40712     try {
40713       result = Dali::Toolkit::ScrollView::DownCast(arg1);
40714     } CALL_CATCH_EXCEPTION(0);
40715   }
40716
40717   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
40718   return jresult;
40719 }
40720
40721
40722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
40723   void * jresult ;
40724   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40725   Dali::AlphaFunction result;
40726
40727   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40728   {
40729     try {
40730       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
40731     } CALL_CATCH_EXCEPTION(0);
40732   }
40733
40734   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
40735   return jresult;
40736 }
40737
40738
40739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
40740   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40741   Dali::AlphaFunction arg2 ;
40742   Dali::AlphaFunction *argp2 ;
40743
40744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40745   argp2 = (Dali::AlphaFunction *)jarg2;
40746   if (!argp2) {
40747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40748     return ;
40749   }
40750   arg2 = *argp2;
40751   {
40752     try {
40753       (arg1)->SetScrollSnapAlphaFunction(arg2);
40754     } CALL_CATCH_EXCEPTION();
40755   }
40756
40757 }
40758
40759
40760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
40761   void * jresult ;
40762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40763   Dali::AlphaFunction result;
40764
40765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40766   {
40767     try {
40768       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
40769     } CALL_CATCH_EXCEPTION(0);
40770   }
40771
40772   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
40773   return jresult;
40774 }
40775
40776
40777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
40778   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40779   Dali::AlphaFunction arg2 ;
40780   Dali::AlphaFunction *argp2 ;
40781
40782   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40783   argp2 = (Dali::AlphaFunction *)jarg2;
40784   if (!argp2) {
40785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40786     return ;
40787   }
40788   arg2 = *argp2;
40789   {
40790     try {
40791       (arg1)->SetScrollFlickAlphaFunction(arg2);
40792     } CALL_CATCH_EXCEPTION();
40793   }
40794
40795 }
40796
40797
40798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
40799   float jresult ;
40800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40801   float result;
40802
40803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40804   {
40805     try {
40806       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
40807     } CALL_CATCH_EXCEPTION(0);
40808   }
40809
40810   jresult = result;
40811   return jresult;
40812 }
40813
40814
40815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
40816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40817   float arg2 ;
40818
40819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40820   arg2 = (float)jarg2;
40821   {
40822     try {
40823       (arg1)->SetScrollSnapDuration(arg2);
40824     } CALL_CATCH_EXCEPTION();
40825   }
40826
40827 }
40828
40829
40830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
40831   float jresult ;
40832   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40833   float result;
40834
40835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40836   {
40837     try {
40838       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
40839     } CALL_CATCH_EXCEPTION(0);
40840   }
40841
40842   jresult = result;
40843   return jresult;
40844 }
40845
40846
40847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
40848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40849   float arg2 ;
40850
40851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40852   arg2 = (float)jarg2;
40853   {
40854     try {
40855       (arg1)->SetScrollFlickDuration(arg2);
40856     } CALL_CATCH_EXCEPTION();
40857   }
40858
40859 }
40860
40861
40862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
40863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40864   Dali::Toolkit::RulerPtr arg2 ;
40865   Dali::Toolkit::RulerPtr *argp2 ;
40866
40867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40868   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
40869   if (!argp2) {
40870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
40871     return ;
40872   }
40873   arg2 = *argp2;
40874   {
40875     try {
40876       (arg1)->SetRulerX(arg2);
40877     } CALL_CATCH_EXCEPTION();
40878   }
40879
40880 }
40881
40882
40883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
40884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40885   Dali::Toolkit::RulerPtr arg2 ;
40886   Dali::Toolkit::RulerPtr *argp2 ;
40887
40888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40889   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
40890   if (!argp2) {
40891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
40892     return ;
40893   }
40894   arg2 = *argp2;
40895   {
40896     try {
40897       (arg1)->SetRulerY(arg2);
40898     } CALL_CATCH_EXCEPTION();
40899   }
40900
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
40905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40906   bool arg2 ;
40907
40908   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40909   arg2 = jarg2 ? true : false;
40910   {
40911     try {
40912       (arg1)->SetScrollSensitive(arg2);
40913     } CALL_CATCH_EXCEPTION();
40914   }
40915
40916 }
40917
40918
40919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
40920   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40921   float arg2 ;
40922   float arg3 ;
40923
40924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40925   arg2 = (float)jarg2;
40926   arg3 = (float)jarg3;
40927   {
40928     try {
40929       (arg1)->SetMaxOvershoot(arg2,arg3);
40930     } CALL_CATCH_EXCEPTION();
40931   }
40932
40933 }
40934
40935
40936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
40937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40938   Dali::AlphaFunction arg2 ;
40939   Dali::AlphaFunction *argp2 ;
40940
40941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40942   argp2 = (Dali::AlphaFunction *)jarg2;
40943   if (!argp2) {
40944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40945     return ;
40946   }
40947   arg2 = *argp2;
40948   {
40949     try {
40950       (arg1)->SetSnapOvershootAlphaFunction(arg2);
40951     } CALL_CATCH_EXCEPTION();
40952   }
40953
40954 }
40955
40956
40957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
40958   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40959   float arg2 ;
40960
40961   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40962   arg2 = (float)jarg2;
40963   {
40964     try {
40965       (arg1)->SetSnapOvershootDuration(arg2);
40966     } CALL_CATCH_EXCEPTION();
40967   }
40968
40969 }
40970
40971
40972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
40973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40974   bool arg2 ;
40975
40976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40977   arg2 = jarg2 ? true : false;
40978   {
40979     try {
40980       (arg1)->SetActorAutoSnap(arg2);
40981     } CALL_CATCH_EXCEPTION();
40982   }
40983
40984 }
40985
40986
40987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
40988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
40989   bool arg2 ;
40990
40991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
40992   arg2 = jarg2 ? true : false;
40993   {
40994     try {
40995       (arg1)->SetWrapMode(arg2);
40996     } CALL_CATCH_EXCEPTION();
40997   }
40998
40999 }
41000
41001
41002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
41003   int jresult ;
41004   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41005   int result;
41006
41007   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41008   {
41009     try {
41010       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
41011     } CALL_CATCH_EXCEPTION(0);
41012   }
41013
41014   jresult = result;
41015   return jresult;
41016 }
41017
41018
41019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
41020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41021   int arg2 ;
41022
41023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41024   arg2 = (int)jarg2;
41025   {
41026     try {
41027       (arg1)->SetScrollUpdateDistance(arg2);
41028     } CALL_CATCH_EXCEPTION();
41029   }
41030
41031 }
41032
41033
41034 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
41035   bool jresult ;
41036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41037   bool result;
41038
41039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41040   {
41041     try {
41042       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
41043     } CALL_CATCH_EXCEPTION(0);
41044   }
41045
41046   jresult = result;
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
41052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41053   bool arg2 ;
41054
41055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41056   arg2 = jarg2 ? true : false;
41057   {
41058     try {
41059       (arg1)->SetAxisAutoLock(arg2);
41060     } CALL_CATCH_EXCEPTION();
41061   }
41062
41063 }
41064
41065
41066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
41067   float jresult ;
41068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41069   float result;
41070
41071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41072   {
41073     try {
41074       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
41075     } CALL_CATCH_EXCEPTION(0);
41076   }
41077
41078   jresult = result;
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
41084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41085   float arg2 ;
41086
41087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41088   arg2 = (float)jarg2;
41089   {
41090     try {
41091       (arg1)->SetAxisAutoLockGradient(arg2);
41092     } CALL_CATCH_EXCEPTION();
41093   }
41094
41095 }
41096
41097
41098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
41099   float jresult ;
41100   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41101   float result;
41102
41103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41104   {
41105     try {
41106       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
41107     } CALL_CATCH_EXCEPTION(0);
41108   }
41109
41110   jresult = result;
41111   return jresult;
41112 }
41113
41114
41115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
41116   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41117   float arg2 ;
41118
41119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41120   arg2 = (float)jarg2;
41121   {
41122     try {
41123       (arg1)->SetFrictionCoefficient(arg2);
41124     } CALL_CATCH_EXCEPTION();
41125   }
41126
41127 }
41128
41129
41130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
41131   float jresult ;
41132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41133   float result;
41134
41135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41136   {
41137     try {
41138       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
41139     } CALL_CATCH_EXCEPTION(0);
41140   }
41141
41142   jresult = result;
41143   return jresult;
41144 }
41145
41146
41147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
41148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41149   float arg2 ;
41150
41151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41152   arg2 = (float)jarg2;
41153   {
41154     try {
41155       (arg1)->SetFlickSpeedCoefficient(arg2);
41156     } CALL_CATCH_EXCEPTION();
41157   }
41158
41159 }
41160
41161
41162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
41163   void * jresult ;
41164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41165   Dali::Vector2 result;
41166
41167   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41168   {
41169     try {
41170       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
41171     } CALL_CATCH_EXCEPTION(0);
41172   }
41173
41174   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
41175   return jresult;
41176 }
41177
41178
41179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
41180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41181   Dali::Vector2 *arg2 = 0 ;
41182
41183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41184   arg2 = (Dali::Vector2 *)jarg2;
41185   if (!arg2) {
41186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41187     return ;
41188   }
41189   {
41190     try {
41191       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
41192     } CALL_CATCH_EXCEPTION();
41193   }
41194
41195 }
41196
41197
41198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
41199   float jresult ;
41200   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41201   float result;
41202
41203   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41204   {
41205     try {
41206       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
41207     } CALL_CATCH_EXCEPTION(0);
41208   }
41209
41210   jresult = result;
41211   return jresult;
41212 }
41213
41214
41215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
41216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41217   float arg2 ;
41218
41219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41220   arg2 = (float)jarg2;
41221   {
41222     try {
41223       (arg1)->SetMinimumSpeedForFlick(arg2);
41224     } CALL_CATCH_EXCEPTION();
41225   }
41226
41227 }
41228
41229
41230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
41231   float jresult ;
41232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41233   float result;
41234
41235   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41236   {
41237     try {
41238       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
41239     } CALL_CATCH_EXCEPTION(0);
41240   }
41241
41242   jresult = result;
41243   return jresult;
41244 }
41245
41246
41247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
41248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41249   float arg2 ;
41250
41251   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41252   arg2 = (float)jarg2;
41253   {
41254     try {
41255       (arg1)->SetMaxFlickSpeed(arg2);
41256     } CALL_CATCH_EXCEPTION();
41257   }
41258
41259 }
41260
41261
41262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
41263   void * jresult ;
41264   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41265   Dali::Vector2 result;
41266
41267   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41268   {
41269     try {
41270       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
41271     } CALL_CATCH_EXCEPTION(0);
41272   }
41273
41274   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
41275   return jresult;
41276 }
41277
41278
41279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
41280   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41281   Dali::Vector2 arg2 ;
41282   Dali::Vector2 *argp2 ;
41283
41284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41285   argp2 = (Dali::Vector2 *)jarg2;
41286   if (!argp2) {
41287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
41288     return ;
41289   }
41290   arg2 = *argp2;
41291   {
41292     try {
41293       (arg1)->SetWheelScrollDistanceStep(arg2);
41294     } CALL_CATCH_EXCEPTION();
41295   }
41296
41297 }
41298
41299
41300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
41301   void * jresult ;
41302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41303   Dali::Vector2 result;
41304
41305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41306   {
41307     try {
41308       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
41309     } CALL_CATCH_EXCEPTION(0);
41310   }
41311
41312   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
41318   unsigned int jresult ;
41319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41320   unsigned int result;
41321
41322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41323   {
41324     try {
41325       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
41326     } CALL_CATCH_EXCEPTION(0);
41327   }
41328
41329   jresult = result;
41330   return jresult;
41331 }
41332
41333
41334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
41335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41336   Dali::Vector2 *arg2 = 0 ;
41337
41338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41339   arg2 = (Dali::Vector2 *)jarg2;
41340   if (!arg2) {
41341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41342     return ;
41343   }
41344   {
41345     try {
41346       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
41347     } CALL_CATCH_EXCEPTION();
41348   }
41349
41350 }
41351
41352
41353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
41354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41355   Dali::Vector2 *arg2 = 0 ;
41356   float arg3 ;
41357
41358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41359   arg2 = (Dali::Vector2 *)jarg2;
41360   if (!arg2) {
41361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41362     return ;
41363   }
41364   arg3 = (float)jarg3;
41365   {
41366     try {
41367       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
41368     } CALL_CATCH_EXCEPTION();
41369   }
41370
41371 }
41372
41373
41374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
41375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41376   Dali::Vector2 *arg2 = 0 ;
41377   float arg3 ;
41378   Dali::AlphaFunction arg4 ;
41379   Dali::AlphaFunction *argp4 ;
41380
41381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41382   arg2 = (Dali::Vector2 *)jarg2;
41383   if (!arg2) {
41384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41385     return ;
41386   }
41387   arg3 = (float)jarg3;
41388   argp4 = (Dali::AlphaFunction *)jarg4;
41389   if (!argp4) {
41390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
41391     return ;
41392   }
41393   arg4 = *argp4;
41394   {
41395     try {
41396       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
41397     } CALL_CATCH_EXCEPTION();
41398   }
41399
41400 }
41401
41402
41403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
41404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41405   Dali::Vector2 *arg2 = 0 ;
41406   float arg3 ;
41407   Dali::Toolkit::DirectionBias arg4 ;
41408   Dali::Toolkit::DirectionBias arg5 ;
41409
41410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41411   arg2 = (Dali::Vector2 *)jarg2;
41412   if (!arg2) {
41413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41414     return ;
41415   }
41416   arg3 = (float)jarg3;
41417   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
41418   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
41419   {
41420     try {
41421       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
41422     } CALL_CATCH_EXCEPTION();
41423   }
41424
41425 }
41426
41427
41428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
41429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41430   Dali::Vector2 *arg2 = 0 ;
41431   float arg3 ;
41432   Dali::AlphaFunction arg4 ;
41433   Dali::Toolkit::DirectionBias arg5 ;
41434   Dali::Toolkit::DirectionBias arg6 ;
41435   Dali::AlphaFunction *argp4 ;
41436
41437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41438   arg2 = (Dali::Vector2 *)jarg2;
41439   if (!arg2) {
41440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41441     return ;
41442   }
41443   arg3 = (float)jarg3;
41444   argp4 = (Dali::AlphaFunction *)jarg4;
41445   if (!argp4) {
41446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
41447     return ;
41448   }
41449   arg4 = *argp4;
41450   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
41451   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
41452   {
41453     try {
41454       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
41455     } CALL_CATCH_EXCEPTION();
41456   }
41457
41458 }
41459
41460
41461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
41462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41463   unsigned int arg2 ;
41464
41465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41466   arg2 = (unsigned int)jarg2;
41467   {
41468     try {
41469       (arg1)->ScrollTo(arg2);
41470     } CALL_CATCH_EXCEPTION();
41471   }
41472
41473 }
41474
41475
41476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
41477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41478   unsigned int arg2 ;
41479   float arg3 ;
41480
41481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41482   arg2 = (unsigned int)jarg2;
41483   arg3 = (float)jarg3;
41484   {
41485     try {
41486       (arg1)->ScrollTo(arg2,arg3);
41487     } CALL_CATCH_EXCEPTION();
41488   }
41489
41490 }
41491
41492
41493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
41494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41495   unsigned int arg2 ;
41496   float arg3 ;
41497   Dali::Toolkit::DirectionBias arg4 ;
41498
41499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41500   arg2 = (unsigned int)jarg2;
41501   arg3 = (float)jarg3;
41502   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
41503   {
41504     try {
41505       (arg1)->ScrollTo(arg2,arg3,arg4);
41506     } CALL_CATCH_EXCEPTION();
41507   }
41508
41509 }
41510
41511
41512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
41513   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41514   Dali::Actor *arg2 = 0 ;
41515
41516   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41517   arg2 = (Dali::Actor *)jarg2;
41518   if (!arg2) {
41519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41520     return ;
41521   }
41522   {
41523     try {
41524       (arg1)->ScrollTo(*arg2);
41525     } CALL_CATCH_EXCEPTION();
41526   }
41527
41528 }
41529
41530
41531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
41532   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41533   Dali::Actor *arg2 = 0 ;
41534   float arg3 ;
41535
41536   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41537   arg2 = (Dali::Actor *)jarg2;
41538   if (!arg2) {
41539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41540     return ;
41541   }
41542   arg3 = (float)jarg3;
41543   {
41544     try {
41545       (arg1)->ScrollTo(*arg2,arg3);
41546     } CALL_CATCH_EXCEPTION();
41547   }
41548
41549 }
41550
41551
41552 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
41553   bool jresult ;
41554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41555   bool result;
41556
41557   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41558   {
41559     try {
41560       result = (bool)(arg1)->ScrollToSnapPoint();
41561     } CALL_CATCH_EXCEPTION(0);
41562   }
41563
41564   jresult = result;
41565   return jresult;
41566 }
41567
41568
41569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
41570   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41571   Dali::Constraint arg2 ;
41572   Dali::Constraint *argp2 ;
41573
41574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41575   argp2 = (Dali::Constraint *)jarg2;
41576   if (!argp2) {
41577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
41578     return ;
41579   }
41580   arg2 = *argp2;
41581   {
41582     try {
41583       (arg1)->ApplyConstraintToChildren(arg2);
41584     } CALL_CATCH_EXCEPTION();
41585   }
41586
41587 }
41588
41589
41590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
41591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41592
41593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41594   {
41595     try {
41596       (arg1)->RemoveConstraintsFromChildren();
41597     } CALL_CATCH_EXCEPTION();
41598   }
41599
41600 }
41601
41602
41603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
41604   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41605   Dali::Toolkit::ScrollViewEffect arg2 ;
41606   Dali::Toolkit::ScrollViewEffect *argp2 ;
41607
41608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41609   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
41610   if (!argp2) {
41611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
41612     return ;
41613   }
41614   arg2 = *argp2;
41615   {
41616     try {
41617       (arg1)->ApplyEffect(arg2);
41618     } CALL_CATCH_EXCEPTION();
41619   }
41620
41621 }
41622
41623
41624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
41625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41626   Dali::Toolkit::ScrollViewEffect arg2 ;
41627   Dali::Toolkit::ScrollViewEffect *argp2 ;
41628
41629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41630   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
41631   if (!argp2) {
41632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
41633     return ;
41634   }
41635   arg2 = *argp2;
41636   {
41637     try {
41638       (arg1)->RemoveEffect(arg2);
41639     } CALL_CATCH_EXCEPTION();
41640   }
41641
41642 }
41643
41644
41645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
41646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41647
41648   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41649   {
41650     try {
41651       (arg1)->RemoveAllEffects();
41652     } CALL_CATCH_EXCEPTION();
41653   }
41654
41655 }
41656
41657
41658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
41659   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41660   Dali::Actor arg2 ;
41661   Dali::Actor *argp2 ;
41662
41663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41664   argp2 = (Dali::Actor *)jarg2;
41665   if (!argp2) {
41666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41667     return ;
41668   }
41669   arg2 = *argp2;
41670   {
41671     try {
41672       (arg1)->BindActor(arg2);
41673     } CALL_CATCH_EXCEPTION();
41674   }
41675
41676 }
41677
41678
41679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
41680   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41681   Dali::Actor arg2 ;
41682   Dali::Actor *argp2 ;
41683
41684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41685   argp2 = (Dali::Actor *)jarg2;
41686   if (!argp2) {
41687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41688     return ;
41689   }
41690   arg2 = *argp2;
41691   {
41692     try {
41693       (arg1)->UnbindActor(arg2);
41694     } CALL_CATCH_EXCEPTION();
41695   }
41696
41697 }
41698
41699
41700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41702   Dali::Radian arg2 ;
41703   Dali::Radian arg3 ;
41704   Dali::Radian *argp2 ;
41705   Dali::Radian *argp3 ;
41706
41707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41708   argp2 = (Dali::Radian *)jarg2;
41709   if (!argp2) {
41710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41711     return ;
41712   }
41713   arg2 = *argp2;
41714   argp3 = (Dali::Radian *)jarg3;
41715   if (!argp3) {
41716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41717     return ;
41718   }
41719   arg3 = *argp3;
41720   {
41721     try {
41722       (arg1)->SetScrollingDirection(arg2,arg3);
41723     } CALL_CATCH_EXCEPTION();
41724   }
41725
41726 }
41727
41728
41729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
41730   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41731   Dali::Radian arg2 ;
41732   Dali::Radian *argp2 ;
41733
41734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41735   argp2 = (Dali::Radian *)jarg2;
41736   if (!argp2) {
41737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41738     return ;
41739   }
41740   arg2 = *argp2;
41741   {
41742     try {
41743       (arg1)->SetScrollingDirection(arg2);
41744     } CALL_CATCH_EXCEPTION();
41745   }
41746
41747 }
41748
41749
41750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
41751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41752   Dali::Radian arg2 ;
41753   Dali::Radian *argp2 ;
41754
41755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41756   argp2 = (Dali::Radian *)jarg2;
41757   if (!argp2) {
41758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41759     return ;
41760   }
41761   arg2 = *argp2;
41762   {
41763     try {
41764       (arg1)->RemoveScrollingDirection(arg2);
41765     } CALL_CATCH_EXCEPTION();
41766   }
41767
41768 }
41769
41770
41771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
41772   void * jresult ;
41773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
41774   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
41775
41776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
41777   {
41778     try {
41779       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
41780     } CALL_CATCH_EXCEPTION(0);
41781   }
41782
41783   jresult = (void *)result;
41784   return jresult;
41785 }
41786
41787
41788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
41789   int jresult ;
41790   int result;
41791
41792   result = (int)Dali::Toolkit::TableView::Property::ROWS;
41793   jresult = (int)result;
41794   return jresult;
41795 }
41796
41797
41798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
41799   int jresult ;
41800   int result;
41801
41802   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
41803   jresult = (int)result;
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
41809   int jresult ;
41810   int result;
41811
41812   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
41813   jresult = (int)result;
41814   return jresult;
41815 }
41816
41817
41818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
41819   int jresult ;
41820   int result;
41821
41822   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
41823   jresult = (int)result;
41824   return jresult;
41825 }
41826
41827
41828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
41829   int jresult ;
41830   int result;
41831
41832   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
41833   jresult = (int)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
41839   void * jresult ;
41840   Dali::Toolkit::TableView::Property *result = 0 ;
41841
41842   {
41843     try {
41844       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
41845     } CALL_CATCH_EXCEPTION(0);
41846   }
41847
41848   jresult = (void *)result;
41849   return jresult;
41850 }
41851
41852
41853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
41854   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
41855
41856   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
41857   {
41858     try {
41859       delete arg1;
41860     } CALL_CATCH_EXCEPTION();
41861   }
41862
41863 }
41864
41865
41866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
41867   int jresult ;
41868   int result;
41869
41870   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
41871   jresult = (int)result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
41877   int jresult ;
41878   int result;
41879
41880   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
41881   jresult = (int)result;
41882   return jresult;
41883 }
41884
41885
41886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
41887   int jresult ;
41888   int result;
41889
41890   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
41891   jresult = (int)result;
41892   return jresult;
41893 }
41894
41895
41896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
41897   int jresult ;
41898   int result;
41899
41900   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
41901   jresult = (int)result;
41902   return jresult;
41903 }
41904
41905
41906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
41907   int jresult ;
41908   int result;
41909
41910   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
41911   jresult = (int)result;
41912   return jresult;
41913 }
41914
41915
41916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
41917   void * jresult ;
41918   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
41919
41920   {
41921     try {
41922       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
41923     } CALL_CATCH_EXCEPTION(0);
41924   }
41925
41926   jresult = (void *)result;
41927   return jresult;
41928 }
41929
41930
41931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
41932   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
41933
41934   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
41935   {
41936     try {
41937       delete arg1;
41938     } CALL_CATCH_EXCEPTION();
41939   }
41940
41941 }
41942
41943
41944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
41945   void * jresult ;
41946   unsigned int arg1 ;
41947   unsigned int arg2 ;
41948   unsigned int arg3 ;
41949   unsigned int arg4 ;
41950   Dali::Toolkit::TableView::CellPosition *result = 0 ;
41951
41952   arg1 = (unsigned int)jarg1;
41953   arg2 = (unsigned int)jarg2;
41954   arg3 = (unsigned int)jarg3;
41955   arg4 = (unsigned int)jarg4;
41956   {
41957     try {
41958       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
41959     } CALL_CATCH_EXCEPTION(0);
41960   }
41961
41962   jresult = (void *)result;
41963   return jresult;
41964 }
41965
41966
41967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
41968   void * jresult ;
41969   unsigned int arg1 ;
41970   unsigned int arg2 ;
41971   unsigned int arg3 ;
41972   Dali::Toolkit::TableView::CellPosition *result = 0 ;
41973
41974   arg1 = (unsigned int)jarg1;
41975   arg2 = (unsigned int)jarg2;
41976   arg3 = (unsigned int)jarg3;
41977   {
41978     try {
41979       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
41980     } CALL_CATCH_EXCEPTION(0);
41981   }
41982
41983   jresult = (void *)result;
41984   return jresult;
41985 }
41986
41987
41988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41989   void * jresult ;
41990   unsigned int arg1 ;
41991   unsigned int arg2 ;
41992   Dali::Toolkit::TableView::CellPosition *result = 0 ;
41993
41994   arg1 = (unsigned int)jarg1;
41995   arg2 = (unsigned int)jarg2;
41996   {
41997     try {
41998       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
41999     } CALL_CATCH_EXCEPTION(0);
42000   }
42001
42002   jresult = (void *)result;
42003   return jresult;
42004 }
42005
42006
42007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
42008   void * jresult ;
42009   unsigned int arg1 ;
42010   Dali::Toolkit::TableView::CellPosition *result = 0 ;
42011
42012   arg1 = (unsigned int)jarg1;
42013   {
42014     try {
42015       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
42016     } CALL_CATCH_EXCEPTION(0);
42017   }
42018
42019   jresult = (void *)result;
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
42025   void * jresult ;
42026   Dali::Toolkit::TableView::CellPosition *result = 0 ;
42027
42028   {
42029     try {
42030       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
42031     } CALL_CATCH_EXCEPTION(0);
42032   }
42033
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
42040   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42041   unsigned int arg2 ;
42042
42043   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42044   arg2 = (unsigned int)jarg2;
42045   if (arg1) (arg1)->rowIndex = arg2;
42046 }
42047
42048
42049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
42050   unsigned int jresult ;
42051   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42052   unsigned int result;
42053
42054   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42055   result = (unsigned int) ((arg1)->rowIndex);
42056   jresult = result;
42057   return jresult;
42058 }
42059
42060
42061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
42062   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42063   unsigned int arg2 ;
42064
42065   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42066   arg2 = (unsigned int)jarg2;
42067   if (arg1) (arg1)->columnIndex = arg2;
42068 }
42069
42070
42071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
42072   unsigned int jresult ;
42073   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42074   unsigned int result;
42075
42076   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42077   result = (unsigned int) ((arg1)->columnIndex);
42078   jresult = result;
42079   return jresult;
42080 }
42081
42082
42083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
42084   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42085   unsigned int arg2 ;
42086
42087   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42088   arg2 = (unsigned int)jarg2;
42089   if (arg1) (arg1)->rowSpan = arg2;
42090 }
42091
42092
42093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
42094   unsigned int jresult ;
42095   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42096   unsigned int result;
42097
42098   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42099   result = (unsigned int) ((arg1)->rowSpan);
42100   jresult = result;
42101   return jresult;
42102 }
42103
42104
42105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
42106   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42107   unsigned int arg2 ;
42108
42109   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42110   arg2 = (unsigned int)jarg2;
42111   if (arg1) (arg1)->columnSpan = arg2;
42112 }
42113
42114
42115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
42116   unsigned int jresult ;
42117   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42118   unsigned int result;
42119
42120   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42121   result = (unsigned int) ((arg1)->columnSpan);
42122   jresult = result;
42123   return jresult;
42124 }
42125
42126
42127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
42128   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
42129
42130   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
42131   {
42132     try {
42133       delete arg1;
42134     } CALL_CATCH_EXCEPTION();
42135   }
42136
42137 }
42138
42139
42140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
42141   void * jresult ;
42142   Dali::Toolkit::TableView *result = 0 ;
42143
42144   {
42145     try {
42146       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
42147     } CALL_CATCH_EXCEPTION(0);
42148   }
42149
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
42156   void * jresult ;
42157   Dali::Toolkit::TableView *arg1 = 0 ;
42158   Dali::Toolkit::TableView *result = 0 ;
42159
42160   arg1 = (Dali::Toolkit::TableView *)jarg1;
42161   if (!arg1) {
42162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
42163     return 0;
42164   }
42165   {
42166     try {
42167       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
42168     } CALL_CATCH_EXCEPTION(0);
42169   }
42170
42171   jresult = (void *)result;
42172   return jresult;
42173 }
42174
42175
42176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
42177   void * jresult ;
42178   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42179   Dali::Toolkit::TableView *arg2 = 0 ;
42180   Dali::Toolkit::TableView *result = 0 ;
42181
42182   arg1 = (Dali::Toolkit::TableView *)jarg1;
42183   arg2 = (Dali::Toolkit::TableView *)jarg2;
42184   if (!arg2) {
42185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
42186     return 0;
42187   }
42188   {
42189     try {
42190       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
42191     } CALL_CATCH_EXCEPTION(0);
42192   }
42193
42194   jresult = (void *)result;
42195   return jresult;
42196 }
42197
42198
42199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
42200   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42201
42202   arg1 = (Dali::Toolkit::TableView *)jarg1;
42203   {
42204     try {
42205       delete arg1;
42206     } CALL_CATCH_EXCEPTION();
42207   }
42208
42209 }
42210
42211
42212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
42213   void * jresult ;
42214   unsigned int arg1 ;
42215   unsigned int arg2 ;
42216   Dali::Toolkit::TableView result;
42217
42218   arg1 = (unsigned int)jarg1;
42219   arg2 = (unsigned int)jarg2;
42220   {
42221     try {
42222       result = Dali::Toolkit::TableView::New(arg1,arg2);
42223     } CALL_CATCH_EXCEPTION(0);
42224   }
42225
42226   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
42227   return jresult;
42228 }
42229
42230
42231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
42232   void * jresult ;
42233   Dali::BaseHandle arg1 ;
42234   Dali::BaseHandle *argp1 ;
42235   Dali::Toolkit::TableView result;
42236
42237   argp1 = (Dali::BaseHandle *)jarg1;
42238   if (!argp1) {
42239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42240     return 0;
42241   }
42242   arg1 = *argp1;
42243   {
42244     try {
42245       result = Dali::Toolkit::TableView::DownCast(arg1);
42246     } CALL_CATCH_EXCEPTION(0);
42247   }
42248
42249   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
42250   return jresult;
42251 }
42252
42253
42254 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
42255   bool jresult ;
42256   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42257   Dali::Actor arg2 ;
42258   Dali::Toolkit::TableView::CellPosition arg3 ;
42259   Dali::Actor *argp2 ;
42260   Dali::Toolkit::TableView::CellPosition *argp3 ;
42261   bool result;
42262
42263   arg1 = (Dali::Toolkit::TableView *)jarg1;
42264   argp2 = (Dali::Actor *)jarg2;
42265   if (!argp2) {
42266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42267     return 0;
42268   }
42269   arg2 = *argp2;
42270   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
42271   if (!argp3) {
42272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
42273     return 0;
42274   }
42275   arg3 = *argp3;
42276   {
42277     try {
42278       result = (bool)(arg1)->AddChild(arg2,arg3);
42279     } CALL_CATCH_EXCEPTION(0);
42280   }
42281
42282   jresult = result;
42283   return jresult;
42284 }
42285
42286
42287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
42288   void * jresult ;
42289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42290   Dali::Toolkit::TableView::CellPosition arg2 ;
42291   Dali::Toolkit::TableView::CellPosition *argp2 ;
42292   Dali::Actor result;
42293
42294   arg1 = (Dali::Toolkit::TableView *)jarg1;
42295   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
42296   if (!argp2) {
42297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
42298     return 0;
42299   }
42300   arg2 = *argp2;
42301   {
42302     try {
42303       result = (arg1)->GetChildAt(arg2);
42304     } CALL_CATCH_EXCEPTION(0);
42305   }
42306
42307   jresult = new Dali::Actor((const Dali::Actor &)result);
42308   return jresult;
42309 }
42310
42311
42312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
42313   void * jresult ;
42314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42315   Dali::Toolkit::TableView::CellPosition arg2 ;
42316   Dali::Toolkit::TableView::CellPosition *argp2 ;
42317   Dali::Actor result;
42318
42319   arg1 = (Dali::Toolkit::TableView *)jarg1;
42320   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
42321   if (!argp2) {
42322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
42323     return 0;
42324   }
42325   arg2 = *argp2;
42326   {
42327     try {
42328       result = (arg1)->RemoveChildAt(arg2);
42329     } CALL_CATCH_EXCEPTION(0);
42330   }
42331
42332   jresult = new Dali::Actor((const Dali::Actor &)result);
42333   return jresult;
42334 }
42335
42336
42337 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
42338   bool jresult ;
42339   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42340   Dali::Actor arg2 ;
42341   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
42342   Dali::Actor *argp2 ;
42343   bool result;
42344
42345   arg1 = (Dali::Toolkit::TableView *)jarg1;
42346   argp2 = (Dali::Actor *)jarg2;
42347   if (!argp2) {
42348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42349     return 0;
42350   }
42351   arg2 = *argp2;
42352   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
42353   if (!arg3) {
42354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
42355     return 0;
42356   }
42357   {
42358     try {
42359       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
42360     } CALL_CATCH_EXCEPTION(0);
42361   }
42362
42363   jresult = result;
42364   return jresult;
42365 }
42366
42367
42368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
42369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42370   unsigned int arg2 ;
42371
42372   arg1 = (Dali::Toolkit::TableView *)jarg1;
42373   arg2 = (unsigned int)jarg2;
42374   {
42375     try {
42376       (arg1)->InsertRow(arg2);
42377     } CALL_CATCH_EXCEPTION();
42378   }
42379
42380 }
42381
42382
42383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
42384   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42385   unsigned int arg2 ;
42386
42387   arg1 = (Dali::Toolkit::TableView *)jarg1;
42388   arg2 = (unsigned int)jarg2;
42389   {
42390     try {
42391       (arg1)->DeleteRow(arg2);
42392     } CALL_CATCH_EXCEPTION();
42393   }
42394
42395 }
42396
42397
42398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
42399   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42400   unsigned int arg2 ;
42401   std::vector< Dali::Actor > *arg3 = 0 ;
42402
42403   arg1 = (Dali::Toolkit::TableView *)jarg1;
42404   arg2 = (unsigned int)jarg2;
42405   arg3 = (std::vector< Dali::Actor > *)jarg3;
42406   if (!arg3) {
42407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
42408     return ;
42409   }
42410   {
42411     try {
42412       (arg1)->DeleteRow(arg2,*arg3);
42413     } CALL_CATCH_EXCEPTION();
42414   }
42415
42416 }
42417
42418
42419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
42420   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42421   unsigned int arg2 ;
42422
42423   arg1 = (Dali::Toolkit::TableView *)jarg1;
42424   arg2 = (unsigned int)jarg2;
42425   {
42426     try {
42427       (arg1)->InsertColumn(arg2);
42428     } CALL_CATCH_EXCEPTION();
42429   }
42430
42431 }
42432
42433
42434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
42435   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42436   unsigned int arg2 ;
42437
42438   arg1 = (Dali::Toolkit::TableView *)jarg1;
42439   arg2 = (unsigned int)jarg2;
42440   {
42441     try {
42442       (arg1)->DeleteColumn(arg2);
42443     } CALL_CATCH_EXCEPTION();
42444   }
42445
42446 }
42447
42448
42449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
42450   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42451   unsigned int arg2 ;
42452   std::vector< Dali::Actor > *arg3 = 0 ;
42453
42454   arg1 = (Dali::Toolkit::TableView *)jarg1;
42455   arg2 = (unsigned int)jarg2;
42456   arg3 = (std::vector< Dali::Actor > *)jarg3;
42457   if (!arg3) {
42458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
42459     return ;
42460   }
42461   {
42462     try {
42463       (arg1)->DeleteColumn(arg2,*arg3);
42464     } CALL_CATCH_EXCEPTION();
42465   }
42466
42467 }
42468
42469
42470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
42471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42472   unsigned int arg2 ;
42473   unsigned int arg3 ;
42474
42475   arg1 = (Dali::Toolkit::TableView *)jarg1;
42476   arg2 = (unsigned int)jarg2;
42477   arg3 = (unsigned int)jarg3;
42478   {
42479     try {
42480       (arg1)->Resize(arg2,arg3);
42481     } CALL_CATCH_EXCEPTION();
42482   }
42483
42484 }
42485
42486
42487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
42488   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42489   unsigned int arg2 ;
42490   unsigned int arg3 ;
42491   std::vector< Dali::Actor > *arg4 = 0 ;
42492
42493   arg1 = (Dali::Toolkit::TableView *)jarg1;
42494   arg2 = (unsigned int)jarg2;
42495   arg3 = (unsigned int)jarg3;
42496   arg4 = (std::vector< Dali::Actor > *)jarg4;
42497   if (!arg4) {
42498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
42499     return ;
42500   }
42501   {
42502     try {
42503       (arg1)->Resize(arg2,arg3,*arg4);
42504     } CALL_CATCH_EXCEPTION();
42505   }
42506
42507 }
42508
42509
42510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
42511   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42512   Dali::Size arg2 ;
42513   Dali::Size *argp2 ;
42514
42515   arg1 = (Dali::Toolkit::TableView *)jarg1;
42516   argp2 = (Dali::Size *)jarg2;
42517   if (!argp2) {
42518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
42519     return ;
42520   }
42521   arg2 = *argp2;
42522   {
42523     try {
42524       (arg1)->SetCellPadding(arg2);
42525     } CALL_CATCH_EXCEPTION();
42526   }
42527
42528 }
42529
42530
42531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
42532   void * jresult ;
42533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42534   Dali::Size result;
42535
42536   arg1 = (Dali::Toolkit::TableView *)jarg1;
42537   {
42538     try {
42539       result = (arg1)->GetCellPadding();
42540     } CALL_CATCH_EXCEPTION(0);
42541   }
42542
42543   jresult = new Dali::Size((const Dali::Size &)result);
42544   return jresult;
42545 }
42546
42547
42548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
42549   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42550   unsigned int arg2 ;
42551
42552   arg1 = (Dali::Toolkit::TableView *)jarg1;
42553   arg2 = (unsigned int)jarg2;
42554   {
42555     try {
42556       (arg1)->SetFitHeight(arg2);
42557     } CALL_CATCH_EXCEPTION();
42558   }
42559
42560 }
42561
42562
42563 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
42564   bool jresult ;
42565   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42566   unsigned int arg2 ;
42567   bool result;
42568
42569   arg1 = (Dali::Toolkit::TableView *)jarg1;
42570   arg2 = (unsigned int)jarg2;
42571   {
42572     try {
42573       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
42574     } CALL_CATCH_EXCEPTION(0);
42575   }
42576
42577   jresult = result;
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
42583   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42584   unsigned int arg2 ;
42585
42586   arg1 = (Dali::Toolkit::TableView *)jarg1;
42587   arg2 = (unsigned int)jarg2;
42588   {
42589     try {
42590       (arg1)->SetFitWidth(arg2);
42591     } CALL_CATCH_EXCEPTION();
42592   }
42593
42594 }
42595
42596
42597 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
42598   bool jresult ;
42599   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42600   unsigned int arg2 ;
42601   bool result;
42602
42603   arg1 = (Dali::Toolkit::TableView *)jarg1;
42604   arg2 = (unsigned int)jarg2;
42605   {
42606     try {
42607       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
42608     } CALL_CATCH_EXCEPTION(0);
42609   }
42610
42611   jresult = result;
42612   return jresult;
42613 }
42614
42615
42616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
42617   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42618   unsigned int arg2 ;
42619   float arg3 ;
42620
42621   arg1 = (Dali::Toolkit::TableView *)jarg1;
42622   arg2 = (unsigned int)jarg2;
42623   arg3 = (float)jarg3;
42624   {
42625     try {
42626       (arg1)->SetFixedHeight(arg2,arg3);
42627     } CALL_CATCH_EXCEPTION();
42628   }
42629
42630 }
42631
42632
42633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
42634   float jresult ;
42635   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42636   unsigned int arg2 ;
42637   float result;
42638
42639   arg1 = (Dali::Toolkit::TableView *)jarg1;
42640   arg2 = (unsigned int)jarg2;
42641   {
42642     try {
42643       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
42644     } CALL_CATCH_EXCEPTION(0);
42645   }
42646
42647   jresult = result;
42648   return jresult;
42649 }
42650
42651
42652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
42653   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42654   unsigned int arg2 ;
42655   float arg3 ;
42656
42657   arg1 = (Dali::Toolkit::TableView *)jarg1;
42658   arg2 = (unsigned int)jarg2;
42659   arg3 = (float)jarg3;
42660   {
42661     try {
42662       (arg1)->SetRelativeHeight(arg2,arg3);
42663     } CALL_CATCH_EXCEPTION();
42664   }
42665
42666 }
42667
42668
42669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
42670   float jresult ;
42671   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42672   unsigned int arg2 ;
42673   float result;
42674
42675   arg1 = (Dali::Toolkit::TableView *)jarg1;
42676   arg2 = (unsigned int)jarg2;
42677   {
42678     try {
42679       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
42680     } CALL_CATCH_EXCEPTION(0);
42681   }
42682
42683   jresult = result;
42684   return jresult;
42685 }
42686
42687
42688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
42689   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42690   unsigned int arg2 ;
42691   float arg3 ;
42692
42693   arg1 = (Dali::Toolkit::TableView *)jarg1;
42694   arg2 = (unsigned int)jarg2;
42695   arg3 = (float)jarg3;
42696   {
42697     try {
42698       (arg1)->SetFixedWidth(arg2,arg3);
42699     } CALL_CATCH_EXCEPTION();
42700   }
42701
42702 }
42703
42704
42705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
42706   float jresult ;
42707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42708   unsigned int arg2 ;
42709   float result;
42710
42711   arg1 = (Dali::Toolkit::TableView *)jarg1;
42712   arg2 = (unsigned int)jarg2;
42713   {
42714     try {
42715       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
42716     } CALL_CATCH_EXCEPTION(0);
42717   }
42718
42719   jresult = result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
42725   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42726   unsigned int arg2 ;
42727   float arg3 ;
42728
42729   arg1 = (Dali::Toolkit::TableView *)jarg1;
42730   arg2 = (unsigned int)jarg2;
42731   arg3 = (float)jarg3;
42732   {
42733     try {
42734       (arg1)->SetRelativeWidth(arg2,arg3);
42735     } CALL_CATCH_EXCEPTION();
42736   }
42737
42738 }
42739
42740
42741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
42742   float jresult ;
42743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42744   unsigned int arg2 ;
42745   float result;
42746
42747   arg1 = (Dali::Toolkit::TableView *)jarg1;
42748   arg2 = (unsigned int)jarg2;
42749   {
42750     try {
42751       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
42752     } CALL_CATCH_EXCEPTION(0);
42753   }
42754
42755   jresult = result;
42756   return jresult;
42757 }
42758
42759
42760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
42761   unsigned int jresult ;
42762   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42763   unsigned int result;
42764
42765   arg1 = (Dali::Toolkit::TableView *)jarg1;
42766   {
42767     try {
42768       result = (unsigned int)(arg1)->GetRows();
42769     } CALL_CATCH_EXCEPTION(0);
42770   }
42771
42772   jresult = result;
42773   return jresult;
42774 }
42775
42776
42777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
42778   unsigned int jresult ;
42779   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42780   unsigned int result;
42781
42782   arg1 = (Dali::Toolkit::TableView *)jarg1;
42783   {
42784     try {
42785       result = (unsigned int)(arg1)->GetColumns();
42786     } CALL_CATCH_EXCEPTION(0);
42787   }
42788
42789   jresult = result;
42790   return jresult;
42791 }
42792
42793
42794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
42795   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
42796   Dali::Toolkit::TableView::CellPosition arg2 ;
42797   Dali::HorizontalAlignment::Type arg3 ;
42798   Dali::VerticalAlignment::Type arg4 ;
42799   Dali::Toolkit::TableView::CellPosition *argp2 ;
42800
42801   arg1 = (Dali::Toolkit::TableView *)jarg1;
42802   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
42803   if (!argp2) {
42804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
42805     return ;
42806   }
42807   arg2 = *argp2;
42808   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
42809   arg4 = (Dali::VerticalAlignment::Type)jarg4;
42810   {
42811     try {
42812       (arg1)->SetCellAlignment(arg2,arg3,arg4);
42813     } CALL_CATCH_EXCEPTION();
42814   }
42815
42816 }
42817
42818
42819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
42820   unsigned int jresult ;
42821   unsigned int result;
42822
42823   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
42824   jresult = result;
42825   return jresult;
42826 }
42827
42828
42829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
42830   int jresult ;
42831   int result;
42832
42833   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
42834   jresult = (int)result;
42835   return jresult;
42836 }
42837
42838
42839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
42840   int jresult ;
42841   int result;
42842
42843   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
42844   jresult = (int)result;
42845   return jresult;
42846 }
42847
42848
42849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
42850   int jresult ;
42851   int result;
42852
42853   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
42854   jresult = (int)result;
42855   return jresult;
42856 }
42857
42858
42859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
42860   int jresult ;
42861   int result;
42862
42863   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
42864   jresult = (int)result;
42865   return jresult;
42866 }
42867
42868
42869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
42870   int jresult ;
42871   int result;
42872
42873   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
42874   jresult = (int)result;
42875   return jresult;
42876 }
42877
42878
42879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
42880   int jresult ;
42881   int result;
42882
42883   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
42884   jresult = (int)result;
42885   return jresult;
42886 }
42887
42888
42889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
42890   int jresult ;
42891   int result;
42892
42893   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
42894   jresult = (int)result;
42895   return jresult;
42896 }
42897
42898
42899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
42900   int jresult ;
42901   int result;
42902
42903   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
42904   jresult = (int)result;
42905   return jresult;
42906 }
42907
42908
42909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
42910   int jresult ;
42911   int result;
42912
42913   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
42914   jresult = (int)result;
42915   return jresult;
42916 }
42917
42918
42919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
42920   int jresult ;
42921   int result;
42922
42923   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
42924   jresult = (int)result;
42925   return jresult;
42926 }
42927
42928
42929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
42930   int jresult ;
42931   int result;
42932
42933   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
42934   jresult = (int)result;
42935   return jresult;
42936 }
42937
42938
42939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
42940   int jresult ;
42941   int result;
42942
42943   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
42944   jresult = (int)result;
42945   return jresult;
42946 }
42947
42948
42949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
42950   int jresult ;
42951   int result;
42952
42953   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
42954   jresult = (int)result;
42955   return jresult;
42956 }
42957
42958
42959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
42960   int jresult ;
42961   int result;
42962
42963   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
42964   jresult = (int)result;
42965   return jresult;
42966 }
42967
42968
42969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
42970   int jresult ;
42971   int result;
42972
42973   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
42974   jresult = (int)result;
42975   return jresult;
42976 }
42977
42978
42979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
42980   int jresult ;
42981   int result;
42982
42983   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
42984   jresult = (int)result;
42985   return jresult;
42986 }
42987
42988
42989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
42990   int jresult ;
42991   int result;
42992
42993   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
42994   jresult = (int)result;
42995   return jresult;
42996 }
42997
42998
42999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
43000   int jresult ;
43001   int result;
43002
43003   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
43004   jresult = (int)result;
43005   return jresult;
43006 }
43007
43008
43009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
43010   void * jresult ;
43011   Dali::Toolkit::TextLabel::Property *result = 0 ;
43012
43013   {
43014     try {
43015       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
43016     } CALL_CATCH_EXCEPTION(0);
43017   }
43018
43019   jresult = (void *)result;
43020   return jresult;
43021 }
43022
43023
43024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
43025   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
43026
43027   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
43028   {
43029     try {
43030       delete arg1;
43031     } CALL_CATCH_EXCEPTION();
43032   }
43033
43034 }
43035
43036
43037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
43038   void * jresult ;
43039   Dali::Toolkit::TextLabel result;
43040
43041   {
43042     try {
43043       result = Dali::Toolkit::TextLabel::New();
43044     } CALL_CATCH_EXCEPTION(0);
43045   }
43046
43047   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
43048   return jresult;
43049 }
43050
43051
43052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) {
43053   void * jresult ;
43054   std::string *arg1 = 0 ;
43055   Dali::Toolkit::TextLabel result;
43056
43057   if (!text) {
43058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43059     return 0;
43060   }
43061   std::string arg1_str(text);
43062   arg1 = &arg1_str;
43063   {
43064     try {
43065       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
43066     } CALL_CATCH_EXCEPTION(0);
43067   }
43068
43069   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
43070
43071   //argout typemap for const std::string&
43072
43073   return jresult;
43074 }
43075
43076
43077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) {
43078   void * jresult ;
43079   Dali::Toolkit::TextLabel result;
43080
43081   {
43082     try {
43083       if (hasStyle) {
43084         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
43085       } else {
43086         result = Dali::Toolkit::TextLabel::New();
43087       }
43088     } CALL_CATCH_EXCEPTION(0);
43089   }
43090
43091   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
43092   return jresult;
43093 }
43094
43095
43096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) {
43097   void * jresult ;
43098   std::string *arg1 = 0 ;
43099   Dali::Toolkit::TextLabel result;
43100
43101   if (!text) {
43102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43103     return 0;
43104   }
43105   std::string arg1_str(text);
43106   arg1 = &arg1_str;
43107   {
43108     try {
43109       if (hasStyle) {
43110         result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
43111       } else {
43112         result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
43113       }
43114     } CALL_CATCH_EXCEPTION(0);
43115   }
43116
43117   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
43118
43119   //argout typemap for const std::string&
43120
43121   return jresult;
43122 }
43123
43124
43125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
43126   void * jresult ;
43127   Dali::Toolkit::TextLabel *result = 0 ;
43128
43129   {
43130     try {
43131       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
43132     } CALL_CATCH_EXCEPTION(0);
43133   }
43134
43135   jresult = (void *)result;
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
43141   void * jresult ;
43142   Dali::Toolkit::TextLabel *arg1 = 0 ;
43143   Dali::Toolkit::TextLabel *result = 0 ;
43144
43145   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
43146   if (!arg1) {
43147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
43148     return 0;
43149   }
43150   {
43151     try {
43152       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
43153     } CALL_CATCH_EXCEPTION(0);
43154   }
43155
43156   jresult = (void *)result;
43157   return jresult;
43158 }
43159
43160
43161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
43162   void * jresult ;
43163   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
43164   Dali::Toolkit::TextLabel *arg2 = 0 ;
43165   Dali::Toolkit::TextLabel *result = 0 ;
43166
43167   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
43168   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
43169   if (!arg2) {
43170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
43171     return 0;
43172   }
43173   {
43174     try {
43175       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
43176     } CALL_CATCH_EXCEPTION(0);
43177   }
43178
43179   jresult = (void *)result;
43180   return jresult;
43181 }
43182
43183
43184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
43185   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
43186
43187   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
43188   {
43189     try {
43190       delete arg1;
43191     } CALL_CATCH_EXCEPTION();
43192   }
43193
43194 }
43195
43196
43197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
43198   void * jresult ;
43199   Dali::BaseHandle arg1 ;
43200   Dali::BaseHandle *argp1 ;
43201   Dali::Toolkit::TextLabel result;
43202
43203   argp1 = (Dali::BaseHandle *)jarg1;
43204   if (!argp1) {
43205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43206     return 0;
43207   }
43208   arg1 = *argp1;
43209   {
43210     try {
43211       result = Dali::Toolkit::TextLabel::DownCast(arg1);
43212     } CALL_CATCH_EXCEPTION(0);
43213   }
43214
43215   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
43221   void * jresult ;
43222   Dali::Toolkit::AccessibilityManager *result = 0 ;
43223
43224   {
43225     try {
43226       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
43227     } CALL_CATCH_EXCEPTION(0);
43228   }
43229
43230   jresult = (void *)result;
43231   return jresult;
43232 }
43233
43234
43235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
43236   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43237
43238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43239   {
43240     try {
43241       delete arg1;
43242     } CALL_CATCH_EXCEPTION();
43243   }
43244
43245 }
43246
43247
43248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
43249   void * jresult ;
43250   Dali::Toolkit::AccessibilityManager result;
43251
43252   {
43253     try {
43254       result = Dali::Toolkit::AccessibilityManager::Get();
43255     } CALL_CATCH_EXCEPTION(0);
43256   }
43257
43258   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
43259   return jresult;
43260 }
43261
43262
43263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
43264   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43265   Dali::Actor arg2 ;
43266   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
43267   std::string *arg4 = 0 ;
43268   Dali::Actor *argp2 ;
43269
43270   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43271   argp2 = (Dali::Actor *)jarg2;
43272   if (!argp2) {
43273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43274     return ;
43275   }
43276   arg2 = *argp2;
43277   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
43278   if (!jarg4) {
43279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43280     return ;
43281   }
43282   std::string arg4_str(jarg4);
43283   arg4 = &arg4_str;
43284   {
43285     try {
43286       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
43287     } CALL_CATCH_EXCEPTION();
43288   }
43289
43290
43291   //argout typemap for const std::string&
43292
43293 }
43294
43295
43296 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
43297   char * jresult ;
43298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43299   Dali::Actor arg2 ;
43300   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
43301   Dali::Actor *argp2 ;
43302   std::string result;
43303
43304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43305   argp2 = (Dali::Actor *)jarg2;
43306   if (!argp2) {
43307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43308     return 0;
43309   }
43310   arg2 = *argp2;
43311   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
43312   {
43313     try {
43314       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
43315     } CALL_CATCH_EXCEPTION(0);
43316   }
43317
43318   jresult = SWIG_csharp_string_callback((&result)->c_str());
43319   return jresult;
43320 }
43321
43322
43323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
43324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43325   Dali::Actor arg2 ;
43326   unsigned int arg3 ;
43327   Dali::Actor *argp2 ;
43328
43329   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43330   argp2 = (Dali::Actor *)jarg2;
43331   if (!argp2) {
43332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43333     return ;
43334   }
43335   arg2 = *argp2;
43336   arg3 = (unsigned int)jarg3;
43337   {
43338     try {
43339       (arg1)->SetFocusOrder(arg2,arg3);
43340     } CALL_CATCH_EXCEPTION();
43341   }
43342
43343 }
43344
43345
43346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
43347   unsigned int jresult ;
43348   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43349   Dali::Actor arg2 ;
43350   Dali::Actor *argp2 ;
43351   unsigned int result;
43352
43353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43354   argp2 = (Dali::Actor *)jarg2;
43355   if (!argp2) {
43356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43357     return 0;
43358   }
43359   arg2 = *argp2;
43360   {
43361     try {
43362       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
43363     } CALL_CATCH_EXCEPTION(0);
43364   }
43365
43366   jresult = result;
43367   return jresult;
43368 }
43369
43370
43371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
43372   unsigned int jresult ;
43373   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43374   unsigned int result;
43375
43376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43377   {
43378     try {
43379       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
43380     } CALL_CATCH_EXCEPTION(0);
43381   }
43382
43383   jresult = result;
43384   return jresult;
43385 }
43386
43387
43388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
43389   void * jresult ;
43390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43391   unsigned int arg2 ;
43392   Dali::Actor result;
43393
43394   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43395   arg2 = (unsigned int)jarg2;
43396   {
43397     try {
43398       result = (arg1)->GetActorByFocusOrder(arg2);
43399     } CALL_CATCH_EXCEPTION(0);
43400   }
43401
43402   jresult = new Dali::Actor((const Dali::Actor &)result);
43403   return jresult;
43404 }
43405
43406
43407 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
43408   bool jresult ;
43409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43410   Dali::Actor arg2 ;
43411   Dali::Actor *argp2 ;
43412   bool result;
43413
43414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43415   argp2 = (Dali::Actor *)jarg2;
43416   if (!argp2) {
43417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43418     return 0;
43419   }
43420   arg2 = *argp2;
43421   {
43422     try {
43423       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
43424     } CALL_CATCH_EXCEPTION(0);
43425   }
43426
43427   jresult = result;
43428   return jresult;
43429 }
43430
43431
43432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
43433   void * jresult ;
43434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43435   Dali::Actor result;
43436
43437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43438   {
43439     try {
43440       result = (arg1)->GetCurrentFocusActor();
43441     } CALL_CATCH_EXCEPTION(0);
43442   }
43443
43444   jresult = new Dali::Actor((const Dali::Actor &)result);
43445   return jresult;
43446 }
43447
43448
43449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
43450   void * jresult ;
43451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43452   Dali::Actor result;
43453
43454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43455   {
43456     try {
43457       result = (arg1)->GetCurrentFocusGroup();
43458     } CALL_CATCH_EXCEPTION(0);
43459   }
43460
43461   jresult = new Dali::Actor((const Dali::Actor &)result);
43462   return jresult;
43463 }
43464
43465
43466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
43467   unsigned int jresult ;
43468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43469   unsigned int result;
43470
43471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43472   {
43473     try {
43474       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
43475     } CALL_CATCH_EXCEPTION(0);
43476   }
43477
43478   jresult = result;
43479   return jresult;
43480 }
43481
43482
43483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
43484   bool jresult ;
43485   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43486   bool result;
43487
43488   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43489   {
43490     try {
43491       result = (bool)(arg1)->MoveFocusForward();
43492     } CALL_CATCH_EXCEPTION(0);
43493   }
43494
43495   jresult = result;
43496   return jresult;
43497 }
43498
43499
43500 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
43501   bool jresult ;
43502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43503   bool result;
43504
43505   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43506   {
43507     try {
43508       result = (bool)(arg1)->MoveFocusBackward();
43509     } CALL_CATCH_EXCEPTION(0);
43510   }
43511
43512   jresult = result;
43513   return jresult;
43514 }
43515
43516
43517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
43518   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43519
43520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43521   {
43522     try {
43523       (arg1)->ClearFocus();
43524     } CALL_CATCH_EXCEPTION();
43525   }
43526
43527 }
43528
43529
43530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
43531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43532
43533   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43534   {
43535     try {
43536       (arg1)->Reset();
43537     } CALL_CATCH_EXCEPTION();
43538   }
43539
43540 }
43541
43542
43543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
43544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43545   Dali::Actor arg2 ;
43546   bool arg3 ;
43547   Dali::Actor *argp2 ;
43548
43549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43550   argp2 = (Dali::Actor *)jarg2;
43551   if (!argp2) {
43552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43553     return ;
43554   }
43555   arg2 = *argp2;
43556   arg3 = jarg3 ? true : false;
43557   {
43558     try {
43559       (arg1)->SetFocusGroup(arg2,arg3);
43560     } CALL_CATCH_EXCEPTION();
43561   }
43562
43563 }
43564
43565
43566 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
43567   bool jresult ;
43568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43569   Dali::Actor arg2 ;
43570   Dali::Actor *argp2 ;
43571   bool result;
43572
43573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43574   argp2 = (Dali::Actor *)jarg2;
43575   if (!argp2) {
43576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43577     return 0;
43578   }
43579   arg2 = *argp2;
43580   {
43581     try {
43582       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
43583     } CALL_CATCH_EXCEPTION(0);
43584   }
43585
43586   jresult = result;
43587   return jresult;
43588 }
43589
43590
43591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
43592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43593   bool arg2 ;
43594
43595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43596   arg2 = jarg2 ? true : false;
43597   {
43598     try {
43599       (arg1)->SetGroupMode(arg2);
43600     } CALL_CATCH_EXCEPTION();
43601   }
43602
43603 }
43604
43605
43606 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
43607   bool jresult ;
43608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43609   bool result;
43610
43611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43612   {
43613     try {
43614       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
43615     } CALL_CATCH_EXCEPTION(0);
43616   }
43617
43618   jresult = result;
43619   return jresult;
43620 }
43621
43622
43623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
43624   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43625   bool arg2 ;
43626
43627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43628   arg2 = jarg2 ? true : false;
43629   {
43630     try {
43631       (arg1)->SetWrapMode(arg2);
43632     } CALL_CATCH_EXCEPTION();
43633   }
43634
43635 }
43636
43637
43638 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
43639   bool jresult ;
43640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43641   bool result;
43642
43643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43644   {
43645     try {
43646       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
43647     } CALL_CATCH_EXCEPTION(0);
43648   }
43649
43650   jresult = result;
43651   return jresult;
43652 }
43653
43654
43655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
43656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43657   Dali::Actor arg2 ;
43658   Dali::Actor *argp2 ;
43659
43660   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43661   argp2 = (Dali::Actor *)jarg2;
43662   if (!argp2) {
43663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43664     return ;
43665   }
43666   arg2 = *argp2;
43667   {
43668     try {
43669       (arg1)->SetFocusIndicatorActor(arg2);
43670     } CALL_CATCH_EXCEPTION();
43671   }
43672
43673 }
43674
43675
43676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
43677   void * jresult ;
43678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43679   Dali::Actor result;
43680
43681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43682   {
43683     try {
43684       result = (arg1)->GetFocusIndicatorActor();
43685     } CALL_CATCH_EXCEPTION(0);
43686   }
43687
43688   jresult = new Dali::Actor((const Dali::Actor &)result);
43689   return jresult;
43690 }
43691
43692
43693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
43694   void * jresult ;
43695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43696   Dali::Actor arg2 ;
43697   Dali::Actor *argp2 ;
43698   Dali::Actor result;
43699
43700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43701   argp2 = (Dali::Actor *)jarg2;
43702   if (!argp2) {
43703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43704     return 0;
43705   }
43706   arg2 = *argp2;
43707   {
43708     try {
43709       result = (arg1)->GetFocusGroup(arg2);
43710     } CALL_CATCH_EXCEPTION(0);
43711   }
43712
43713   jresult = new Dali::Actor((const Dali::Actor &)result);
43714   return jresult;
43715 }
43716
43717
43718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
43719   void * jresult ;
43720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43721   Dali::Vector2 result;
43722
43723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43724   {
43725     try {
43726       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
43727     } CALL_CATCH_EXCEPTION(0);
43728   }
43729
43730   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
43731   return jresult;
43732 }
43733
43734
43735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
43736   void * jresult ;
43737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43738   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
43739
43740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43741   {
43742     try {
43743       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
43744     } CALL_CATCH_EXCEPTION(0);
43745   }
43746
43747   jresult = (void *)result;
43748   return jresult;
43749 }
43750
43751
43752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
43753   void * jresult ;
43754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43755   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
43756
43757   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43758   {
43759     try {
43760       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
43761     } CALL_CATCH_EXCEPTION(0);
43762   }
43763
43764   jresult = (void *)result;
43765   return jresult;
43766 }
43767
43768 GENERATE_SIGNAL(Dali::Toolkit::AccessibilityManager*, void(*)(Dali::Actor), Dali_AccessibilityManager, FocusedActorActivatedSignal)
43769 // CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Connect
43770 // CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Disconnect
43771
43772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
43773   void * jresult ;
43774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43775   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43776
43777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43778   {
43779     try {
43780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
43781     } CALL_CATCH_EXCEPTION(0);
43782   }
43783
43784   jresult = (void *)result;
43785   return jresult;
43786 }
43787
43788
43789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
43790   void * jresult ;
43791   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43792   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43793
43794   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43795   {
43796     try {
43797       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
43798     } CALL_CATCH_EXCEPTION(0);
43799   }
43800
43801   jresult = (void *)result;
43802   return jresult;
43803 }
43804
43805
43806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
43807   void * jresult ;
43808   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43809   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43810
43811   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43812   {
43813     try {
43814       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
43815     } CALL_CATCH_EXCEPTION(0);
43816   }
43817
43818   jresult = (void *)result;
43819   return jresult;
43820 }
43821
43822
43823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
43824   void * jresult ;
43825   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43826   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43827
43828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43829   {
43830     try {
43831       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
43832     } CALL_CATCH_EXCEPTION(0);
43833   }
43834
43835   jresult = (void *)result;
43836   return jresult;
43837 }
43838
43839
43840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
43841   void * jresult ;
43842   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43843   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43844
43845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43846   {
43847     try {
43848       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
43849     } CALL_CATCH_EXCEPTION(0);
43850   }
43851
43852   jresult = (void *)result;
43853   return jresult;
43854 }
43855
43856
43857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
43858   void * jresult ;
43859   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43860   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43861
43862   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43863   {
43864     try {
43865       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
43866     } CALL_CATCH_EXCEPTION(0);
43867   }
43868
43869   jresult = (void *)result;
43870   return jresult;
43871 }
43872
43873
43874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
43875   void * jresult ;
43876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43877   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43878
43879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43880   {
43881     try {
43882       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
43883     } CALL_CATCH_EXCEPTION(0);
43884   }
43885
43886   jresult = (void *)result;
43887   return jresult;
43888 }
43889
43890
43891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
43892   void * jresult ;
43893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43894   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43895
43896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43897   {
43898     try {
43899       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
43900     } CALL_CATCH_EXCEPTION(0);
43901   }
43902
43903   jresult = (void *)result;
43904   return jresult;
43905 }
43906
43907
43908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
43909   void * jresult ;
43910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43911   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43912
43913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43914   {
43915     try {
43916       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
43917     } CALL_CATCH_EXCEPTION(0);
43918   }
43919
43920   jresult = (void *)result;
43921   return jresult;
43922 }
43923
43924
43925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
43926   void * jresult ;
43927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43929
43930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43931   {
43932     try {
43933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
43934     } CALL_CATCH_EXCEPTION(0);
43935   }
43936
43937   jresult = (void *)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
43943   void * jresult ;
43944   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43945   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43946
43947   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43948   {
43949     try {
43950       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
43951     } CALL_CATCH_EXCEPTION(0);
43952   }
43953
43954   jresult = (void *)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
43960   void * jresult ;
43961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43963
43964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43965   {
43966     try {
43967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
43968     } CALL_CATCH_EXCEPTION(0);
43969   }
43970
43971   jresult = (void *)result;
43972   return jresult;
43973 }
43974
43975
43976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
43977   void * jresult ;
43978   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43979   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43980
43981   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43982   {
43983     try {
43984       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
43985     } CALL_CATCH_EXCEPTION(0);
43986   }
43987
43988   jresult = (void *)result;
43989   return jresult;
43990 }
43991
43992
43993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
43994   void * jresult ;
43995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
43996   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
43997
43998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
43999   {
44000     try {
44001       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
44002     } CALL_CATCH_EXCEPTION(0);
44003   }
44004
44005   jresult = (void *)result;
44006   return jresult;
44007 }
44008
44009
44010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
44011   void * jresult ;
44012   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44013   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44014
44015   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44016   {
44017     try {
44018       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
44019     } CALL_CATCH_EXCEPTION(0);
44020   }
44021
44022   jresult = (void *)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
44028   void * jresult ;
44029   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44030   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44031
44032   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44033   {
44034     try {
44035       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
44036     } CALL_CATCH_EXCEPTION(0);
44037   }
44038
44039   jresult = (void *)result;
44040   return jresult;
44041 }
44042
44043
44044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
44045   void * jresult ;
44046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44047   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44048
44049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44050   {
44051     try {
44052       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
44053     } CALL_CATCH_EXCEPTION(0);
44054   }
44055
44056   jresult = (void *)result;
44057   return jresult;
44058 }
44059
44060
44061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
44062   void * jresult ;
44063   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44064   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44065
44066   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44067   {
44068     try {
44069       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
44070     } CALL_CATCH_EXCEPTION(0);
44071   }
44072
44073   jresult = (void *)result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
44079   void * jresult ;
44080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44081   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44082
44083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44084   {
44085     try {
44086       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
44087     } CALL_CATCH_EXCEPTION(0);
44088   }
44089
44090   jresult = (void *)result;
44091   return jresult;
44092 }
44093
44094
44095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
44096   void * jresult ;
44097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44098   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44099
44100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44101   {
44102     try {
44103       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
44104     } CALL_CATCH_EXCEPTION(0);
44105   }
44106
44107   jresult = (void *)result;
44108   return jresult;
44109 }
44110
44111
44112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
44113   void * jresult ;
44114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44116
44117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44118   {
44119     try {
44120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
44121     } CALL_CATCH_EXCEPTION(0);
44122   }
44123
44124   jresult = (void *)result;
44125   return jresult;
44126 }
44127
44128
44129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
44130   void * jresult ;
44131   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44132   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44133
44134   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44135   {
44136     try {
44137       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
44138     } CALL_CATCH_EXCEPTION(0);
44139   }
44140
44141   jresult = (void *)result;
44142   return jresult;
44143 }
44144
44145
44146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
44147   void * jresult ;
44148   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44149   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44150
44151   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44152   {
44153     try {
44154       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
44155     } CALL_CATCH_EXCEPTION(0);
44156   }
44157
44158   jresult = (void *)result;
44159   return jresult;
44160 }
44161
44162
44163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
44164   void * jresult ;
44165   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44166   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44167
44168   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44169   {
44170     try {
44171       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
44172     } CALL_CATCH_EXCEPTION(0);
44173   }
44174
44175   jresult = (void *)result;
44176   return jresult;
44177 }
44178
44179
44180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
44181   void * jresult ;
44182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
44184
44185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44186   {
44187     try {
44188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
44189     } CALL_CATCH_EXCEPTION(0);
44190   }
44191
44192   jresult = (void *)result;
44193   return jresult;
44194 }
44195
44196
44197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
44198   void * jresult ;
44199   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
44200   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
44201
44202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
44203   {
44204     try {
44205       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
44206     } CALL_CATCH_EXCEPTION(0);
44207   }
44208
44209   jresult = (void *)result;
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
44215   void * jresult ;
44216   Dali::Toolkit::StyleManager *result = 0 ;
44217
44218   {
44219     try {
44220       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
44221     } CALL_CATCH_EXCEPTION(0);
44222   }
44223
44224   jresult = (void *)result;
44225   return jresult;
44226 }
44227
44228
44229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
44230   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44231
44232   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44233   {
44234     try {
44235       delete arg1;
44236     } CALL_CATCH_EXCEPTION();
44237   }
44238
44239 }
44240
44241
44242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
44243   void * jresult ;
44244   Dali::Toolkit::StyleManager result;
44245
44246   {
44247     try {
44248       result = Dali::Toolkit::StyleManager::Get();
44249     } CALL_CATCH_EXCEPTION(0);
44250   }
44251
44252   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
44253   return jresult;
44254 }
44255
44256
44257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
44258   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44259   std::string *arg2 = 0 ;
44260
44261   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44262   if (!jarg2) {
44263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44264     return ;
44265   }
44266   std::string arg2_str(jarg2);
44267   arg2 = &arg2_str;
44268   {
44269     try {
44270       (arg1)->ApplyTheme((std::string const &)*arg2);
44271     } CALL_CATCH_EXCEPTION();
44272   }
44273
44274
44275   //argout typemap for const std::string&
44276
44277 }
44278
44279
44280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
44281   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44282
44283   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44284   {
44285     try {
44286       (arg1)->ApplyDefaultTheme();
44287     } CALL_CATCH_EXCEPTION();
44288   }
44289
44290 }
44291
44292
44293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
44294   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44295   std::string *arg2 = 0 ;
44296   Dali::Property::Value *arg3 = 0 ;
44297
44298   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44299   if (!jarg2) {
44300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44301     return ;
44302   }
44303   std::string arg2_str(jarg2);
44304   arg2 = &arg2_str;
44305   arg3 = (Dali::Property::Value *)jarg3;
44306   if (!arg3) {
44307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
44308     return ;
44309   }
44310   {
44311     try {
44312       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
44313     } CALL_CATCH_EXCEPTION();
44314   }
44315
44316
44317   //argout typemap for const std::string&
44318
44319 }
44320
44321
44322 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
44323   bool jresult ;
44324   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44325   std::string *arg2 = 0 ;
44326   Dali::Property::Value *arg3 = 0 ;
44327   bool result;
44328
44329   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44330   if (!jarg2) {
44331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44332     return 0;
44333   }
44334   std::string arg2_str(jarg2);
44335   arg2 = &arg2_str;
44336   arg3 = (Dali::Property::Value *)jarg3;
44337   if (!arg3) {
44338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
44339     return 0;
44340   }
44341   {
44342     try {
44343       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
44344     } CALL_CATCH_EXCEPTION(0);
44345   }
44346
44347   jresult = result;
44348
44349   //argout typemap for const std::string&
44350
44351   return jresult;
44352 }
44353
44354
44355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
44356   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44357   Dali::Toolkit::Control arg2 ;
44358   std::string *arg3 = 0 ;
44359   std::string *arg4 = 0 ;
44360   Dali::Toolkit::Control *argp2 ;
44361
44362   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44363   argp2 = (Dali::Toolkit::Control *)jarg2;
44364   if (!argp2) {
44365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
44366     return ;
44367   }
44368   arg2 = *argp2;
44369   if (!jarg3) {
44370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44371     return ;
44372   }
44373   std::string arg3_str(jarg3);
44374   arg3 = &arg3_str;
44375   if (!jarg4) {
44376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44377     return ;
44378   }
44379   std::string arg4_str(jarg4);
44380   arg4 = &arg4_str;
44381   {
44382     try {
44383       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
44384     } CALL_CATCH_EXCEPTION();
44385   }
44386
44387
44388   //argout typemap for const std::string&
44389
44390
44391   //argout typemap for const std::string&
44392
44393 }
44394
44395
44396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
44397   void * jresult ;
44398   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
44399   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
44400
44401   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
44402   {
44403     try {
44404       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
44405     } CALL_CATCH_EXCEPTION(0);
44406   }
44407
44408   jresult = (void *)result;
44409   return jresult;
44410 }
44411
44412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
44413   int jresult ;
44414   int result;
44415
44416   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
44417   jresult = (int)result;
44418   return jresult;
44419 }
44420
44421
44422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
44423   int jresult ;
44424   int result;
44425
44426   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
44427   jresult = (int)result;
44428   return jresult;
44429 }
44430
44431
44432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
44433   int jresult ;
44434   int result;
44435
44436   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
44437   jresult = (int)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
44443   int jresult ;
44444   int result;
44445
44446   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
44447   jresult = (int)result;
44448   return jresult;
44449 }
44450
44451
44452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
44453   int result;
44454
44455   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
44456
44457   return result;
44458 }
44459
44460
44461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
44462   void * jresult ;
44463   Dali::Toolkit::VideoView::Property *result = 0 ;
44464
44465   {
44466     try {
44467       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
44468     } CALL_CATCH_EXCEPTION(0);
44469   }
44470
44471   jresult = (void *)result;
44472   return jresult;
44473 }
44474
44475
44476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
44477   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
44478
44479   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
44480   {
44481     try {
44482       delete arg1;
44483     } CALL_CATCH_EXCEPTION();
44484   }
44485
44486 }
44487
44488
44489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
44490   void * jresult ;
44491   Dali::Toolkit::VideoView result;
44492
44493   {
44494     try {
44495       result = Dali::Toolkit::VideoView::New();
44496     } CALL_CATCH_EXCEPTION(0);
44497   }
44498
44499   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44500   return jresult;
44501 }
44502
44503
44504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
44505   void * jresult ;
44506   std::string *arg1 = 0 ;
44507   Dali::Toolkit::VideoView result;
44508
44509   if (!jarg1) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44511     return 0;
44512   }
44513   std::string arg1_str(jarg1);
44514   arg1 = &arg1_str;
44515   {
44516     try {
44517       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
44518     } CALL_CATCH_EXCEPTION(0);
44519   }
44520
44521   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44522
44523   //argout typemap for const std::string&
44524
44525   return jresult;
44526 }
44527
44528
44529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
44530   void * jresult ;
44531   Dali::Toolkit::VideoView result;
44532   {
44533     try {
44534       result = Dali::Toolkit::VideoView::New(swCodec);
44535     } CALL_CATCH_EXCEPTION(0);
44536   }
44537
44538   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44539
44540   //argout typemap for const std::string&
44541
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
44547   void * jresult ;
44548   std::string *arg1 = 0 ;
44549   Dali::Toolkit::VideoView result;
44550
44551   if (!jarg1) {
44552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44553     return 0;
44554   }
44555   std::string arg1_str(jarg1);
44556   arg1 = &arg1_str;
44557   {
44558     try {
44559       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
44560     } CALL_CATCH_EXCEPTION(0);
44561   }
44562
44563   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44564
44565   //argout typemap for const std::string&
44566
44567   return jresult;
44568 }
44569
44570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
44571   void * jresult ;
44572   Dali::VideoSyncMode syncMode;
44573   Dali::Toolkit::VideoView result;
44574
44575   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
44576
44577   {
44578     try {
44579       result = Dali::Toolkit::DevelVideoView::New(syncMode);
44580     } CALL_CATCH_EXCEPTION(0);
44581   }
44582
44583   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44584
44585   return jresult;
44586 }
44587
44588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
44589   void * jresult ;
44590   Dali::Toolkit::VideoView *result = 0 ;
44591
44592   {
44593     try {
44594       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
44595     } CALL_CATCH_EXCEPTION(0);
44596   }
44597
44598   jresult = (void *)result;
44599   return jresult;
44600 }
44601
44602
44603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
44604   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44605
44606   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44607   {
44608     try {
44609       delete arg1;
44610     } CALL_CATCH_EXCEPTION();
44611   }
44612
44613 }
44614
44615
44616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
44617   void * jresult ;
44618   Dali::Toolkit::VideoView *arg1 = 0 ;
44619   Dali::Toolkit::VideoView *result = 0 ;
44620
44621   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44622   if (!arg1) {
44623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
44624     return 0;
44625   }
44626   {
44627     try {
44628       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
44629     } CALL_CATCH_EXCEPTION(0);
44630   }
44631
44632   jresult = (void *)result;
44633   return jresult;
44634 }
44635
44636
44637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
44638   void * jresult ;
44639   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44640   Dali::Toolkit::VideoView *arg2 = 0 ;
44641   Dali::Toolkit::VideoView *result = 0 ;
44642
44643   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44644   arg2 = (Dali::Toolkit::VideoView *)jarg2;
44645   if (!arg2) {
44646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
44647     return 0;
44648   }
44649   {
44650     try {
44651       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
44652     } CALL_CATCH_EXCEPTION(0);
44653   }
44654
44655   jresult = (void *)result;
44656   return jresult;
44657 }
44658
44659
44660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
44661   void * jresult ;
44662   Dali::BaseHandle arg1 ;
44663   Dali::BaseHandle *argp1 ;
44664   Dali::Toolkit::VideoView result;
44665
44666   argp1 = (Dali::BaseHandle *)jarg1;
44667   if (!argp1) {
44668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44669     return 0;
44670   }
44671   arg1 = *argp1;
44672   {
44673     try {
44674       result = Dali::Toolkit::VideoView::DownCast(arg1);
44675     } CALL_CATCH_EXCEPTION(0);
44676   }
44677
44678   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
44679   return jresult;
44680 }
44681
44682
44683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
44684   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44685
44686   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44687   {
44688     try {
44689       (arg1)->Play();
44690     } CALL_CATCH_EXCEPTION();
44691   }
44692
44693 }
44694
44695
44696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
44697   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44698
44699   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44700   {
44701     try {
44702       (arg1)->Pause();
44703     } CALL_CATCH_EXCEPTION();
44704   }
44705
44706 }
44707
44708
44709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
44710   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44711
44712   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44713   {
44714     try {
44715       (arg1)->Stop();
44716     } CALL_CATCH_EXCEPTION();
44717   }
44718
44719 }
44720
44721
44722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
44723   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44724   int arg2 ;
44725
44726   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44727   arg2 = (int)jarg2;
44728   {
44729     try {
44730       (arg1)->Forward(arg2);
44731     } CALL_CATCH_EXCEPTION();
44732   }
44733
44734 }
44735
44736
44737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
44738   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44739   int arg2 ;
44740
44741   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44742   arg2 = (int)jarg2;
44743   {
44744     try {
44745       (arg1)->Backward(arg2);
44746     } CALL_CATCH_EXCEPTION();
44747   }
44748
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
44753   void * jresult ;
44754   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
44755   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
44756
44757   arg1 = (Dali::Toolkit::VideoView *)jarg1;
44758   {
44759     try {
44760       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
44761     } CALL_CATCH_EXCEPTION(0);
44762   }
44763
44764   jresult = (void *)result;
44765   return jresult;
44766 }
44767
44768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
44769 {
44770   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
44771   if( arg1 == nullptr )
44772   {
44773     DALI_LOG_ERROR("VideoView is nullptr!");
44774     return nullptr;
44775   }
44776   void * ret = nullptr;
44777   {
44778     try{
44779
44780       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
44781       ret = Dali::AnyCast< void * >( result );
44782
44783     } CALL_CATCH_EXCEPTION(0);
44784   }
44785   return ret;
44786 }
44787
44788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
44789   void * jresult ;
44790   Dali::Toolkit::CameraView result;
44791
44792   Dali::Any arg1(jarg1);
44793   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
44794   {
44795     try {
44796       result = Dali::Toolkit::CameraView::New(arg1, arg2);
44797     } CALL_CATCH_EXCEPTION(0);
44798   }
44799
44800   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
44801   return jresult;
44802 }
44803
44804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
44805   void * jresult ;
44806   Dali::Toolkit::CameraView *result = 0 ;
44807
44808   {
44809     try {
44810       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
44811     } CALL_CATCH_EXCEPTION(0);
44812   }
44813
44814   jresult = (void *)result;
44815   return jresult;
44816 }
44817
44818
44819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
44820   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
44821
44822   arg1 = (Dali::Toolkit::CameraView *)jarg1;
44823   {
44824     try {
44825       delete arg1;
44826     } CALL_CATCH_EXCEPTION();
44827   }
44828
44829 }
44830
44831
44832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
44833   void * jresult ;
44834   Dali::Toolkit::CameraView *arg1 = 0 ;
44835   Dali::Toolkit::CameraView *result = 0 ;
44836
44837   arg1 = (Dali::Toolkit::CameraView *)jarg1;
44838   if (!arg1) {
44839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
44840     return 0;
44841   }
44842   {
44843     try {
44844       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
44845     } CALL_CATCH_EXCEPTION(0);
44846   }
44847
44848   jresult = (void *)result;
44849   return jresult;
44850 }
44851
44852
44853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
44854   void * jresult ;
44855   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
44856   Dali::Toolkit::CameraView *arg2 = 0 ;
44857   Dali::Toolkit::CameraView *result = 0 ;
44858
44859   arg1 = (Dali::Toolkit::CameraView *)jarg1;
44860   arg2 = (Dali::Toolkit::CameraView *)jarg2;
44861   if (!arg2) {
44862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
44863     return 0;
44864   }
44865   {
44866     try {
44867       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
44868     } CALL_CATCH_EXCEPTION(0);
44869   }
44870
44871   jresult = (void *)result;
44872   return jresult;
44873 }
44874
44875
44876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
44877   void * jresult ;
44878   Dali::BaseHandle arg1 ;
44879   Dali::BaseHandle *argp1 ;
44880   Dali::Toolkit::CameraView result;
44881
44882   argp1 = (Dali::BaseHandle *)jarg1;
44883   if (!argp1) {
44884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44885     return 0;
44886   }
44887   arg1 = *argp1;
44888   {
44889     try {
44890       result = Dali::Toolkit::CameraView::DownCast(arg1);
44891     } CALL_CATCH_EXCEPTION(0);
44892   }
44893
44894   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
44895   return jresult;
44896 }
44897
44898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
44899   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
44900
44901   arg1 = (Dali::Toolkit::CameraView *)jarg1;
44902   {
44903     try {
44904       (arg1)->Update();
44905     } CALL_CATCH_EXCEPTION();
44906   }
44907 }
44908
44909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
44910 {
44911   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
44912   if(arg1 == nullptr)
44913   {
44914     DALI_LOG_ERROR("VideoView is nullptr!");
44915     return;
44916   }
44917   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
44918   if(arg2 == nullptr)
44919   {
44920     DALI_LOG_ERROR("Animation is nullptr!");
44921     return;
44922   }
44923
44924   {
44925     try{
44926
44927       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
44928     } CALL_CATCH_EXCEPTION();
44929   }
44930
44931 }
44932
44933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
44934   void * jresult ;
44935   Dali::Toolkit::GaussianBlurView *result = 0 ;
44936
44937   {
44938     try {
44939       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
44940     } CALL_CATCH_EXCEPTION(0);
44941   }
44942
44943   jresult = (void *)result;
44944   return jresult;
44945 }
44946
44947
44948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
44949   void * jresult ;
44950   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
44951   Dali::Toolkit::GaussianBlurView *result = 0 ;
44952
44953   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
44954   if (!arg1) {
44955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
44956     return 0;
44957   }
44958   {
44959     try {
44960       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
44961     } CALL_CATCH_EXCEPTION(0);
44962   }
44963
44964   jresult = (void *)result;
44965   return jresult;
44966 }
44967
44968
44969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
44970   void * jresult ;
44971   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
44972   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
44973   Dali::Toolkit::GaussianBlurView *result = 0 ;
44974
44975   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
44976   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
44977   if (!arg2) {
44978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
44979     return 0;
44980   }
44981   {
44982     try {
44983       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
44984     } CALL_CATCH_EXCEPTION(0);
44985   }
44986
44987   jresult = (void *)result;
44988   return jresult;
44989 }
44990
44991
44992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
44993   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
44994
44995   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
44996   {
44997     try {
44998       delete arg1;
44999     } CALL_CATCH_EXCEPTION();
45000   }
45001
45002 }
45003
45004
45005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
45006   void * jresult ;
45007   Dali::BaseHandle arg1 ;
45008   Dali::BaseHandle *argp1 ;
45009   Dali::Toolkit::GaussianBlurView result;
45010
45011   argp1 = (Dali::BaseHandle *)jarg1;
45012   if (!argp1) {
45013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45014     return 0;
45015   }
45016   arg1 = *argp1;
45017   {
45018     try {
45019       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
45020     } CALL_CATCH_EXCEPTION(0);
45021   }
45022
45023   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
45024   return jresult;
45025 }
45026
45027
45028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
45029   void * jresult ;
45030   Dali::Toolkit::GaussianBlurView result;
45031
45032   {
45033     try {
45034       result = Dali::Toolkit::GaussianBlurView::New();
45035     } CALL_CATCH_EXCEPTION(0);
45036   }
45037
45038   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
45039   return jresult;
45040 }
45041
45042
45043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
45044   void * jresult ;
45045   unsigned int arg1 ;
45046   float arg2 ;
45047   Dali::Pixel::Format arg3 ;
45048   float arg4 ;
45049   float arg5 ;
45050   bool arg6 ;
45051   Dali::Toolkit::GaussianBlurView result;
45052
45053   arg1 = (unsigned int)jarg1;
45054   arg2 = (float)jarg2;
45055   arg3 = (Dali::Pixel::Format)jarg3;
45056   arg4 = (float)jarg4;
45057   arg5 = (float)jarg5;
45058   arg6 = jarg6 ? true : false;
45059   {
45060     try {
45061       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
45062     } CALL_CATCH_EXCEPTION(0);
45063   }
45064
45065   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
45066   return jresult;
45067 }
45068
45069
45070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
45071   void * jresult ;
45072   unsigned int arg1 ;
45073   float arg2 ;
45074   Dali::Pixel::Format arg3 ;
45075   float arg4 ;
45076   float arg5 ;
45077   Dali::Toolkit::GaussianBlurView result;
45078
45079   arg1 = (unsigned int)jarg1;
45080   arg2 = (float)jarg2;
45081   arg3 = (Dali::Pixel::Format)jarg3;
45082   arg4 = (float)jarg4;
45083   arg5 = (float)jarg5;
45084   {
45085     try {
45086       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
45087     } CALL_CATCH_EXCEPTION(0);
45088   }
45089
45090   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
45091   return jresult;
45092 }
45093
45094
45095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
45096   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45097   Dali::Actor arg2 ;
45098   Dali::Actor *argp2 ;
45099
45100   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45101   argp2 = (Dali::Actor *)jarg2;
45102   if (!argp2) {
45103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45104     return ;
45105   }
45106   arg2 = *argp2;
45107   {
45108     try {
45109       (arg1)->Add(arg2);
45110     } CALL_CATCH_EXCEPTION();
45111   }
45112
45113 }
45114
45115
45116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
45117   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45118   Dali::Actor arg2 ;
45119   Dali::Actor *argp2 ;
45120
45121   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45122   argp2 = (Dali::Actor *)jarg2;
45123   if (!argp2) {
45124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45125     return ;
45126   }
45127   arg2 = *argp2;
45128   {
45129     try {
45130       (arg1)->Remove(arg2);
45131     } CALL_CATCH_EXCEPTION();
45132   }
45133
45134 }
45135
45136
45137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
45138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45139
45140   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45141   {
45142     try {
45143       (arg1)->Activate();
45144     } CALL_CATCH_EXCEPTION();
45145   }
45146
45147 }
45148
45149
45150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
45151   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45152
45153   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45154   {
45155     try {
45156       (arg1)->ActivateOnce();
45157     } CALL_CATCH_EXCEPTION();
45158   }
45159
45160 }
45161
45162
45163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
45164   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45165
45166   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45167   {
45168     try {
45169       (arg1)->Deactivate();
45170     } CALL_CATCH_EXCEPTION();
45171   }
45172
45173 }
45174
45175
45176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
45177   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45178   Dali::Texture arg2 ;
45179   Dali::FrameBuffer arg3 ;
45180   Dali::Texture *argp2 ;
45181   Dali::FrameBuffer *argp3 ;
45182
45183   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45184   argp2 = (Dali::Texture *)jarg2;
45185   if (!argp2) {
45186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
45187     return ;
45188   }
45189   arg2 = *argp2;
45190   argp3 = (Dali::FrameBuffer *)jarg3;
45191   if (!argp3) {
45192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
45193     return ;
45194   }
45195   arg3 = *argp3;
45196   {
45197     try {
45198       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
45199     } CALL_CATCH_EXCEPTION();
45200   }
45201
45202 }
45203
45204
45205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
45206   int jresult ;
45207   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45208   Dali::Property::Index result;
45209
45210   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45211   {
45212     try {
45213       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
45214     } CALL_CATCH_EXCEPTION(0);
45215   }
45216
45217   jresult = result;
45218   return jresult;
45219 }
45220
45221
45222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
45223   void * jresult ;
45224   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45225   Dali::FrameBuffer result;
45226
45227   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45228   {
45229     try {
45230       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
45231     } CALL_CATCH_EXCEPTION(0);
45232   }
45233
45234   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
45235   return jresult;
45236 }
45237
45238
45239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
45240   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45241   Dali::Vector4 *arg2 = 0 ;
45242
45243   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45244   arg2 = (Dali::Vector4 *)jarg2;
45245   if (!arg2) {
45246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
45247     return ;
45248   }
45249   {
45250     try {
45251       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
45252     } CALL_CATCH_EXCEPTION();
45253   }
45254
45255 }
45256
45257
45258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
45259   void * jresult ;
45260   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45261   Dali::Vector4 result;
45262
45263   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45264   {
45265     try {
45266       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
45267     } CALL_CATCH_EXCEPTION(0);
45268   }
45269
45270   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
45271   return jresult;
45272 }
45273
45274
45275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
45276   void * jresult ;
45277   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
45278   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
45279
45280   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
45281   {
45282     try {
45283       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
45284     } CALL_CATCH_EXCEPTION(0);
45285   }
45286
45287   jresult = (void *)result;
45288   return jresult;
45289 }
45290
45291
45292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
45293   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
45294
45295   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
45296   {
45297     try {
45298       delete arg1;
45299     } CALL_CATCH_EXCEPTION();
45300   }
45301
45302 }
45303
45304
45305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
45306   unsigned int jresult ;
45307   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
45308   unsigned int result;
45309
45310   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
45311   {
45312     try {
45313       result = (unsigned int)(arg1)->GetNumberOfPages();
45314     } CALL_CATCH_EXCEPTION(0);
45315   }
45316
45317   jresult = result;
45318   return jresult;
45319 }
45320
45321
45322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
45323   void * jresult ;
45324   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
45325   unsigned int arg2 ;
45326   Dali::Texture result;
45327
45328   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
45329   arg2 = (unsigned int)jarg2;
45330   {
45331     try {
45332       result = (arg1)->NewPage(arg2);
45333     } CALL_CATCH_EXCEPTION(0);
45334   }
45335
45336   jresult = new Dali::Texture((const Dali::Texture &)result);
45337   return jresult;
45338 }
45339
45340
45341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
45342   int jresult ;
45343   int result;
45344
45345   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
45346   jresult = (int)result;
45347   return jresult;
45348 }
45349
45350
45351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
45352   int jresult ;
45353   int result;
45354
45355   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
45356   jresult = (int)result;
45357   return jresult;
45358 }
45359
45360
45361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
45362   int jresult ;
45363   int result;
45364
45365   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
45366   jresult = (int)result;
45367   return jresult;
45368 }
45369
45370
45371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
45372   void * jresult ;
45373   Dali::Toolkit::PageTurnView::Property *result = 0 ;
45374
45375   {
45376     try {
45377       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
45378     } CALL_CATCH_EXCEPTION(0);
45379   }
45380
45381   jresult = (void *)result;
45382   return jresult;
45383 }
45384
45385
45386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
45387   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
45388
45389   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
45390   {
45391     try {
45392       delete arg1;
45393     } CALL_CATCH_EXCEPTION();
45394   }
45395
45396 }
45397
45398
45399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
45400   void * jresult ;
45401   Dali::Toolkit::PageTurnView *result = 0 ;
45402
45403   {
45404     try {
45405       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
45406     } CALL_CATCH_EXCEPTION(0);
45407   }
45408
45409   jresult = (void *)result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
45415   void * jresult ;
45416   Dali::Toolkit::PageTurnView *arg1 = 0 ;
45417   Dali::Toolkit::PageTurnView *result = 0 ;
45418
45419   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45420   if (!arg1) {
45421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
45422     return 0;
45423   }
45424   {
45425     try {
45426       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
45427     } CALL_CATCH_EXCEPTION(0);
45428   }
45429
45430   jresult = (void *)result;
45431   return jresult;
45432 }
45433
45434
45435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
45436   void * jresult ;
45437   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45438   Dali::Toolkit::PageTurnView *arg2 = 0 ;
45439   Dali::Toolkit::PageTurnView *result = 0 ;
45440
45441   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45442   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
45443   if (!arg2) {
45444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
45445     return 0;
45446   }
45447   {
45448     try {
45449       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
45450     } CALL_CATCH_EXCEPTION(0);
45451   }
45452
45453   jresult = (void *)result;
45454   return jresult;
45455 }
45456
45457
45458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
45459   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45460
45461   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45462   {
45463     try {
45464       delete arg1;
45465     } CALL_CATCH_EXCEPTION();
45466   }
45467
45468 }
45469
45470
45471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
45472   void * jresult ;
45473   Dali::BaseHandle arg1 ;
45474   Dali::BaseHandle *argp1 ;
45475   Dali::Toolkit::PageTurnView result;
45476
45477   argp1 = (Dali::BaseHandle *)jarg1;
45478   if (!argp1) {
45479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45480     return 0;
45481   }
45482   arg1 = *argp1;
45483   {
45484     try {
45485       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
45486     } CALL_CATCH_EXCEPTION(0);
45487   }
45488
45489   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
45490   return jresult;
45491 }
45492
45493
45494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
45495   void * jresult ;
45496   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45497   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
45498
45499   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45500   {
45501     try {
45502       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
45503     } CALL_CATCH_EXCEPTION(0);
45504   }
45505
45506   jresult = (void *)result;
45507   return jresult;
45508 }
45509
45510
45511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
45512   void * jresult ;
45513   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45514   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
45515
45516   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45517   {
45518     try {
45519       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
45520     } CALL_CATCH_EXCEPTION(0);
45521   }
45522
45523   jresult = (void *)result;
45524   return jresult;
45525 }
45526
45527
45528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
45529   void * jresult ;
45530   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45531   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
45532
45533   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45534   {
45535     try {
45536       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
45537     } CALL_CATCH_EXCEPTION(0);
45538   }
45539
45540   jresult = (void *)result;
45541   return jresult;
45542 }
45543
45544
45545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
45546   void * jresult ;
45547   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
45548   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
45549
45550   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
45551   {
45552     try {
45553       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
45554     } CALL_CATCH_EXCEPTION(0);
45555   }
45556
45557   jresult = (void *)result;
45558   return jresult;
45559 }
45560
45561
45562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
45563   void * jresult ;
45564   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
45565
45566   {
45567     try {
45568       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
45569     } CALL_CATCH_EXCEPTION(0);
45570   }
45571
45572   jresult = (void *)result;
45573   return jresult;
45574 }
45575
45576
45577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
45578   void * jresult ;
45579   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
45580   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
45581
45582   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
45583   if (!arg1) {
45584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
45585     return 0;
45586   }
45587   {
45588     try {
45589       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
45590     } CALL_CATCH_EXCEPTION(0);
45591   }
45592
45593   jresult = (void *)result;
45594   return jresult;
45595 }
45596
45597
45598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
45599   void * jresult ;
45600   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
45601   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
45602   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
45603
45604   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
45605   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
45606   if (!arg2) {
45607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
45608     return 0;
45609   }
45610   {
45611     try {
45612       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
45613     } CALL_CATCH_EXCEPTION(0);
45614   }
45615
45616   jresult = (void *)result;
45617   return jresult;
45618 }
45619
45620
45621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
45622   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
45623
45624   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
45625   {
45626     try {
45627       delete arg1;
45628     } CALL_CATCH_EXCEPTION();
45629   }
45630
45631 }
45632
45633
45634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
45635   void * jresult ;
45636   Dali::Toolkit::PageFactory *arg1 = 0 ;
45637   Dali::Vector2 *arg2 = 0 ;
45638   Dali::Toolkit::PageTurnLandscapeView result;
45639
45640   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
45641   if (!arg1) {
45642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
45643     return 0;
45644   }
45645   arg2 = (Dali::Vector2 *)jarg2;
45646   if (!arg2) {
45647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45648     return 0;
45649   }
45650   {
45651     try {
45652       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
45653     } CALL_CATCH_EXCEPTION(0);
45654   }
45655
45656   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
45657   return jresult;
45658 }
45659
45660
45661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
45662   void * jresult ;
45663   Dali::BaseHandle arg1 ;
45664   Dali::BaseHandle *argp1 ;
45665   Dali::Toolkit::PageTurnLandscapeView result;
45666
45667   argp1 = (Dali::BaseHandle *)jarg1;
45668   if (!argp1) {
45669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45670     return 0;
45671   }
45672   arg1 = *argp1;
45673   {
45674     try {
45675       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
45676     } CALL_CATCH_EXCEPTION(0);
45677   }
45678
45679   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
45685   void * jresult ;
45686   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
45687
45688   {
45689     try {
45690       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
45691     } CALL_CATCH_EXCEPTION(0);
45692   }
45693
45694   jresult = (void *)result;
45695   return jresult;
45696 }
45697
45698
45699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
45700   void * jresult ;
45701   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
45702   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
45703
45704   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
45705   if (!arg1) {
45706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
45707     return 0;
45708   }
45709   {
45710     try {
45711       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
45712     } CALL_CATCH_EXCEPTION(0);
45713   }
45714
45715   jresult = (void *)result;
45716   return jresult;
45717 }
45718
45719
45720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
45721   void * jresult ;
45722   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
45723   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
45724   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
45725
45726   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
45727   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
45728   if (!arg2) {
45729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
45730     return 0;
45731   }
45732   {
45733     try {
45734       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
45735     } CALL_CATCH_EXCEPTION(0);
45736   }
45737
45738   jresult = (void *)result;
45739   return jresult;
45740 }
45741
45742
45743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
45744   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
45745
45746   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
45747   {
45748     try {
45749       delete arg1;
45750     } CALL_CATCH_EXCEPTION();
45751   }
45752
45753 }
45754
45755
45756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
45757   void * jresult ;
45758   Dali::Toolkit::PageFactory *arg1 = 0 ;
45759   Dali::Vector2 *arg2 = 0 ;
45760   Dali::Toolkit::PageTurnPortraitView result;
45761
45762   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
45763   if (!arg1) {
45764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
45765     return 0;
45766   }
45767   arg2 = (Dali::Vector2 *)jarg2;
45768   if (!arg2) {
45769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45770     return 0;
45771   }
45772   {
45773     try {
45774       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
45775     } CALL_CATCH_EXCEPTION(0);
45776   }
45777
45778   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
45779   return jresult;
45780 }
45781
45782
45783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
45784   void * jresult ;
45785   Dali::BaseHandle arg1 ;
45786   Dali::BaseHandle *argp1 ;
45787   Dali::Toolkit::PageTurnPortraitView result;
45788
45789   argp1 = (Dali::BaseHandle *)jarg1;
45790   if (!argp1) {
45791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45792     return 0;
45793   }
45794   arg1 = *argp1;
45795   {
45796     try {
45797       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
45798     } CALL_CATCH_EXCEPTION(0);
45799   }
45800
45801   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
45802   return jresult;
45803 }
45804
45805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
45806   void * jresult ;
45807   Dali::Toolkit::Visual::Base *result = 0 ;
45808
45809   {
45810     try {
45811       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
45812     } CALL_CATCH_EXCEPTION(0);
45813   }
45814
45815   jresult = (void *)result;
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
45821   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45822
45823   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45824   {
45825     try {
45826       delete arg1;
45827     } CALL_CATCH_EXCEPTION();
45828   }
45829
45830 }
45831
45832
45833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
45834   void * jresult ;
45835   Dali::Toolkit::Visual::Base *arg1 = 0 ;
45836   Dali::Toolkit::Visual::Base *result = 0 ;
45837
45838   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45839   if (!arg1) {
45840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
45841     return 0;
45842   }
45843   {
45844     try {
45845       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
45846     } CALL_CATCH_EXCEPTION(0);
45847   }
45848
45849   jresult = (void *)result;
45850   return jresult;
45851 }
45852
45853
45854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
45855   void * jresult ;
45856   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45857   Dali::Toolkit::Visual::Base *arg2 = 0 ;
45858   Dali::Toolkit::Visual::Base *result = 0 ;
45859
45860   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45861   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
45862   if (!arg2) {
45863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
45864     return 0;
45865   }
45866   {
45867     try {
45868       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
45869     } CALL_CATCH_EXCEPTION(0);
45870   }
45871
45872   jresult = (void *)result;
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
45878   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45879   std::string *arg2 = 0 ;
45880
45881   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45882   if (!jarg2) {
45883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45884     return ;
45885   }
45886   std::string arg2_str(jarg2);
45887   arg2 = &arg2_str;
45888   {
45889     try {
45890       (arg1)->SetName((std::string const &)*arg2);
45891     } CALL_CATCH_EXCEPTION();
45892   }
45893
45894
45895   //argout typemap for const std::string&
45896
45897 }
45898
45899
45900 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
45901   char * jresult ;
45902   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45903   std::string *result = 0 ;
45904
45905   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45906   {
45907     try {
45908       result = (std::string *) &(arg1)->GetName();
45909     } CALL_CATCH_EXCEPTION(0);
45910   }
45911
45912   jresult = SWIG_csharp_string_callback(result->c_str());
45913   return jresult;
45914 }
45915
45916
45917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
45918   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45919   Dali::Property::Map *arg2 = 0 ;
45920   Dali::Size arg3 ;
45921   Dali::Size *argp3 ;
45922
45923   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45924   arg2 = (Dali::Property::Map *)jarg2;
45925   if (!arg2) {
45926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
45927     return ;
45928   }
45929   argp3 = (Dali::Size *)jarg3;
45930   if (!argp3) {
45931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
45932     return ;
45933   }
45934   arg3 = *argp3;
45935   {
45936     try {
45937       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
45938     } CALL_CATCH_EXCEPTION();
45939   }
45940
45941 }
45942
45943
45944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
45945   float jresult ;
45946   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45947   float arg2 ;
45948   float result;
45949
45950   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45951   arg2 = (float)jarg2;
45952   {
45953     try {
45954       result = (float)(arg1)->GetHeightForWidth(arg2);
45955     } CALL_CATCH_EXCEPTION(0);
45956   }
45957
45958   jresult = result;
45959   return jresult;
45960 }
45961
45962
45963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
45964   float jresult ;
45965   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45966   float arg2 ;
45967   float result;
45968
45969   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45970   arg2 = (float)jarg2;
45971   {
45972     try {
45973       result = (float)(arg1)->GetWidthForHeight(arg2);
45974     } CALL_CATCH_EXCEPTION(0);
45975   }
45976
45977   jresult = result;
45978   return jresult;
45979 }
45980
45981
45982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
45983   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
45984   Dali::Vector2 *arg2 = 0 ;
45985
45986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
45987   arg2 = (Dali::Vector2 *)jarg2;
45988   if (!arg2) {
45989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
45990     return ;
45991   }
45992   {
45993     try {
45994       (arg1)->GetNaturalSize(*arg2);
45995     } CALL_CATCH_EXCEPTION();
45996   }
45997
45998 }
45999
46000
46001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
46002   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
46003   float arg2 ;
46004
46005   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
46006   arg2 = (int)jarg2;
46007   {
46008     try {
46009       (arg1)->SetDepthIndex(arg2);
46010     } CALL_CATCH_EXCEPTION();
46011   }
46012
46013 }
46014
46015
46016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
46017   int jresult ;
46018   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
46019   int result;
46020
46021   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
46022   {
46023     try {
46024       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
46025     } CALL_CATCH_EXCEPTION(0);
46026   }
46027
46028   jresult = result;
46029   return jresult;
46030 }
46031
46032
46033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
46034   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
46035   Dali::Property::Map *arg2 = 0 ;
46036
46037   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
46038   arg2 = (Dali::Property::Map *)jarg2;
46039   if (!arg2) {
46040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
46041     return ;
46042   }
46043   {
46044     try {
46045       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
46046     } CALL_CATCH_EXCEPTION();
46047   }
46048
46049 }
46050
46051
46052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
46053   void * jresult ;
46054   Dali::Toolkit::VisualFactory result;
46055
46056   {
46057     try {
46058       result = Dali::Toolkit::VisualFactory::Get();
46059     } CALL_CATCH_EXCEPTION(0);
46060   }
46061
46062   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
46063   return jresult;
46064 }
46065
46066
46067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
46068   void * jresult ;
46069   Dali::Toolkit::VisualFactory *result = 0 ;
46070
46071   {
46072     try {
46073       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
46074     } CALL_CATCH_EXCEPTION(0);
46075   }
46076
46077   jresult = (void *)result;
46078   return jresult;
46079 }
46080
46081
46082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
46083   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
46084
46085   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
46086   {
46087     try {
46088       delete arg1;
46089     } CALL_CATCH_EXCEPTION();
46090   }
46091
46092 }
46093
46094
46095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
46096   void * jresult ;
46097   Dali::Toolkit::VisualFactory *arg1 = 0 ;
46098   Dali::Toolkit::VisualFactory *result = 0 ;
46099
46100   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
46101   if (!arg1) {
46102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
46103     return 0;
46104   }
46105   {
46106     try {
46107       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
46108     } CALL_CATCH_EXCEPTION(0);
46109   }
46110
46111   jresult = (void *)result;
46112   return jresult;
46113 }
46114
46115
46116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
46117   void * jresult ;
46118   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
46119   Dali::Toolkit::VisualFactory *arg2 = 0 ;
46120   Dali::Toolkit::VisualFactory *result = 0 ;
46121
46122   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
46123   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
46124   if (!arg2) {
46125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
46126     return 0;
46127   }
46128   {
46129     try {
46130       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
46131     } CALL_CATCH_EXCEPTION(0);
46132   }
46133
46134   jresult = (void *)result;
46135   return jresult;
46136 }
46137
46138
46139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
46140   void * jresult ;
46141   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
46142   Dali::Property::Map *arg2 = 0 ;
46143   Dali::Toolkit::Visual::Base result;
46144
46145   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
46146   arg2 = (Dali::Property::Map *)jarg2;
46147   if (!arg2) {
46148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
46149     return 0;
46150   }
46151   {
46152     try {
46153       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
46154     } CALL_CATCH_EXCEPTION(0);
46155   }
46156
46157   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
46158   return jresult;
46159 }
46160
46161
46162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
46163   void * jresult ;
46164   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
46165   std::string *arg2 = 0 ;
46166   Dali::ImageDimensions arg3 ;
46167   Dali::ImageDimensions *argp3 ;
46168   Dali::Toolkit::Visual::Base result;
46169
46170   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
46171   if (!jarg2) {
46172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46173     return 0;
46174   }
46175   std::string arg2_str(jarg2);
46176   arg2 = &arg2_str;
46177   argp3 = (Dali::ImageDimensions *)jarg3;
46178   if (!argp3) {
46179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46180     return 0;
46181   }
46182   arg3 = *argp3;
46183   {
46184     try {
46185       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
46186     } CALL_CATCH_EXCEPTION(0);
46187   }
46188
46189   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
46190
46191   //argout typemap for const std::string&
46192
46193   return jresult;
46194 }
46195
46196
46197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
46198   void * jresult ;
46199   Dali::Toolkit::AsyncImageLoader *result = 0 ;
46200
46201   {
46202     try {
46203       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
46204     } CALL_CATCH_EXCEPTION(0);
46205   }
46206
46207   jresult = (void *)result;
46208   return jresult;
46209 }
46210
46211
46212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
46213   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46214
46215   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46216   {
46217     try {
46218       delete arg1;
46219     } CALL_CATCH_EXCEPTION();
46220   }
46221
46222 }
46223
46224
46225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
46226   void * jresult ;
46227   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
46228   Dali::Toolkit::AsyncImageLoader *result = 0 ;
46229
46230   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46231   if (!arg1) {
46232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
46233     return 0;
46234   }
46235   {
46236     try {
46237       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
46238     } CALL_CATCH_EXCEPTION(0);
46239   }
46240
46241   jresult = (void *)result;
46242   return jresult;
46243 }
46244
46245
46246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
46247   void * jresult ;
46248   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46249   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
46250   Dali::Toolkit::AsyncImageLoader *result = 0 ;
46251
46252   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46253   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
46254   if (!arg2) {
46255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
46256     return 0;
46257   }
46258   {
46259     try {
46260       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
46261     } CALL_CATCH_EXCEPTION(0);
46262   }
46263
46264   jresult = (void *)result;
46265   return jresult;
46266 }
46267
46268
46269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
46270   void * jresult ;
46271   Dali::Toolkit::AsyncImageLoader result;
46272
46273   {
46274     try {
46275       result = Dali::Toolkit::AsyncImageLoader::New();
46276     } CALL_CATCH_EXCEPTION(0);
46277   }
46278
46279   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
46280   return jresult;
46281 }
46282
46283
46284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
46285   void * jresult ;
46286   Dali::BaseHandle arg1 ;
46287   Dali::BaseHandle *argp1 ;
46288   Dali::Toolkit::AsyncImageLoader result;
46289
46290   argp1 = (Dali::BaseHandle *)jarg1;
46291   if (!argp1) {
46292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46293     return 0;
46294   }
46295   arg1 = *argp1;
46296   {
46297     try {
46298       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
46299     } CALL_CATCH_EXCEPTION(0);
46300   }
46301
46302   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
46303   return jresult;
46304 }
46305
46306
46307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
46308   unsigned int jresult ;
46309   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46310   std::string *arg2 = 0 ;
46311   uint32_t result;
46312
46313   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46314   if (!jarg2) {
46315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46316     return 0;
46317   }
46318   std::string arg2_str(jarg2);
46319   arg2 = &arg2_str;
46320   {
46321     try {
46322       result = (arg1)->Load((std::string const &)*arg2);
46323     } CALL_CATCH_EXCEPTION(0);
46324   }
46325
46326   jresult = result;
46327
46328   //argout typemap for const std::string&
46329
46330   return jresult;
46331 }
46332
46333
46334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
46335   unsigned int jresult ;
46336   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46337   std::string *arg2 = 0 ;
46338   Dali::ImageDimensions arg3 ;
46339   Dali::ImageDimensions *argp3 ;
46340   uint32_t result;
46341
46342   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46343   if (!jarg2) {
46344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46345     return 0;
46346   }
46347   std::string arg2_str(jarg2);
46348   arg2 = &arg2_str;
46349   argp3 = (Dali::ImageDimensions *)jarg3;
46350   if (!argp3) {
46351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46352     return 0;
46353   }
46354   arg3 = *argp3;
46355   {
46356     try {
46357       result = (arg1)->Load((std::string const &)*arg2,arg3);
46358     } CALL_CATCH_EXCEPTION(0);
46359   }
46360
46361   jresult = result;
46362
46363   //argout typemap for const std::string&
46364
46365   return jresult;
46366 }
46367
46368
46369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
46370   unsigned int jresult ;
46371   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46372   std::string *arg2 = 0 ;
46373   Dali::ImageDimensions arg3 ;
46374   Dali::FittingMode::Type arg4 ;
46375   Dali::SamplingMode::Type arg5 ;
46376   bool arg6 ;
46377   Dali::ImageDimensions *argp3 ;
46378   uint32_t result;
46379
46380   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46381   if (!jarg2) {
46382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46383     return 0;
46384   }
46385   std::string arg2_str(jarg2);
46386   arg2 = &arg2_str;
46387   argp3 = (Dali::ImageDimensions *)jarg3;
46388   if (!argp3) {
46389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46390     return 0;
46391   }
46392   arg3 = *argp3;
46393   arg4 = (Dali::FittingMode::Type)jarg4;
46394   arg5 = (Dali::SamplingMode::Type)jarg5;
46395   arg6 = jarg6 ? true : false;
46396   {
46397     try {
46398       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
46399     } CALL_CATCH_EXCEPTION(0);
46400   }
46401
46402   jresult = result;
46403
46404   //argout typemap for const std::string&
46405
46406   return jresult;
46407 }
46408
46409
46410 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
46411   bool jresult ;
46412   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46413   uint32_t arg2 ;
46414   bool result;
46415
46416   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46417   arg2 = (uint32_t)jarg2;
46418   {
46419     try {
46420       result = (bool)(arg1)->Cancel(arg2);
46421     } CALL_CATCH_EXCEPTION(0);
46422   }
46423
46424   jresult = result;
46425   return jresult;
46426 }
46427
46428
46429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
46430   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46431
46432   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46433   {
46434     try {
46435       (arg1)->CancelAll();
46436     } CALL_CATCH_EXCEPTION();
46437   }
46438
46439 }
46440
46441
46442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
46443   void * jresult ;
46444   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
46445   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
46446
46447   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
46448   {
46449     try {
46450       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
46451     } CALL_CATCH_EXCEPTION(0);
46452   }
46453
46454   jresult = (void *)result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
46460   void * jresult ;
46461   std::string *arg1 = 0 ;
46462   Dali::PixelData result;
46463
46464   if (!jarg1) {
46465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46466     return 0;
46467   }
46468   std::string arg1_str(jarg1);
46469   arg1 = &arg1_str;
46470   {
46471     try {
46472       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
46473     } CALL_CATCH_EXCEPTION(0);
46474   }
46475
46476   jresult = new Dali::PixelData((const Dali::PixelData &)result);
46477
46478   //argout typemap for const std::string&
46479
46480   return jresult;
46481 }
46482
46483
46484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
46485   void * jresult ;
46486   std::string *arg1 = 0 ;
46487   Dali::ImageDimensions arg2 ;
46488   Dali::ImageDimensions *argp2 ;
46489   Dali::PixelData result;
46490
46491   if (!jarg1) {
46492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46493     return 0;
46494   }
46495   std::string arg1_str(jarg1);
46496   arg1 = &arg1_str;
46497   argp2 = (Dali::ImageDimensions *)jarg2;
46498   if (!argp2) {
46499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46500     return 0;
46501   }
46502   arg2 = *argp2;
46503   {
46504     try {
46505       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
46506     } CALL_CATCH_EXCEPTION(0);
46507   }
46508
46509   jresult = new Dali::PixelData((const Dali::PixelData &)result);
46510
46511   //argout typemap for const std::string&
46512
46513   return jresult;
46514 }
46515
46516
46517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
46518   void * jresult ;
46519   std::string *arg1 = 0 ;
46520   Dali::ImageDimensions arg2 ;
46521   Dali::FittingMode::Type arg3 ;
46522   Dali::SamplingMode::Type arg4 ;
46523   bool arg5 ;
46524   Dali::ImageDimensions *argp2 ;
46525   Dali::PixelData result;
46526
46527   if (!jarg1) {
46528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46529     return 0;
46530   }
46531   std::string arg1_str(jarg1);
46532   arg1 = &arg1_str;
46533   argp2 = (Dali::ImageDimensions *)jarg2;
46534   if (!argp2) {
46535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46536     return 0;
46537   }
46538   arg2 = *argp2;
46539   arg3 = (Dali::FittingMode::Type)jarg3;
46540   arg4 = (Dali::SamplingMode::Type)jarg4;
46541   arg5 = jarg5 ? true : false;
46542   {
46543     try {
46544       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46545     } CALL_CATCH_EXCEPTION(0);
46546   }
46547
46548   jresult = new Dali::PixelData((const Dali::PixelData &)result);
46549
46550   //argout typemap for const std::string&
46551
46552   return jresult;
46553 }
46554
46555
46556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
46557   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
46558
46559   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
46560   {
46561     try {
46562       delete arg1;
46563     } CALL_CATCH_EXCEPTION();
46564   }
46565
46566 }
46567
46568
46569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
46570   void * jresult ;
46571   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
46572   Dali::Actor arg2 ;
46573   Dali::Actor arg3 ;
46574   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
46575   std::string *arg5 = 0 ;
46576   Dali::Actor *argp2 ;
46577   Dali::Actor *argp3 ;
46578   Dali::Actor result;
46579
46580   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
46581   argp2 = (Dali::Actor *)currentFocusedActor;
46582   if (!argp2) {
46583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46584     return 0;
46585   }
46586   arg2 = *argp2;
46587   argp3 = (Dali::Actor *)proposedActorToFocus;
46588   if (!argp3) {
46589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46590     return 0;
46591   }
46592   arg3 = *argp3;
46593   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
46594
46595   std::string arg5_str(deviceName);
46596   arg5 = &arg5_str;
46597
46598   {
46599     try {
46600       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
46601     } CALL_CATCH_EXCEPTION(0);
46602   }
46603
46604   jresult = new Dali::Actor((const Dali::Actor &)result);
46605   return jresult;
46606 }
46607
46608
46609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
46610   void * jresult ;
46611   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
46612
46613   {
46614     try {
46615       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
46616     } CALL_CATCH_EXCEPTION(0);
46617   }
46618
46619   jresult = (void *)result;
46620   return jresult;
46621 }
46622
46623
46624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
46625   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
46626   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
46627   if (director) {
46628     director->swig_connect_director(callback0);
46629   }
46630 }
46631
46632
46633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
46634   void * jresult ;
46635   Dali::FrameCallbackInterface *result = 0 ;
46636
46637   {
46638     try {
46639       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
46640     } CALL_CATCH_EXCEPTION(0);
46641   }
46642
46643   jresult = (void *)result;
46644   return jresult;
46645 }
46646
46647 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
46648   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46649   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
46650   return proxy->GetPosition(id, *vector3);
46651 }
46652
46653 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
46654   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46655   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
46656   return proxy->SetPosition(id, *vector3);
46657 }
46658
46659 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
46660   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46661   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
46662   return proxy->BakePosition(id, *vector3);
46663 }
46664
46665 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
46666   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46667   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
46668   return proxy->GetSize(id, *vector3);
46669 }
46670
46671 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
46672   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46673   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
46674   return proxy->SetSize(id, *vector3);
46675 }
46676 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
46677   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46678   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
46679   return proxy->BakeSize(id, *vector3);
46680 }
46681
46682 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
46683   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46684   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
46685   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
46686   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
46687 }
46688
46689 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
46690   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46691   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
46692   return proxy->GetScale(id,* vector3);
46693 }
46694
46695 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
46696   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46697   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
46698   return proxy->SetScale(id, *vector3);
46699 }
46700
46701 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
46702   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46703   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
46704   return proxy->BakeScale(id, *vector3);
46705 }
46706
46707 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
46708   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46709   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
46710   return proxy->GetColor(id, *vector4);
46711 }
46712
46713 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
46714   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46715   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
46716   return proxy->SetColor(id, *vector4);
46717 }
46718
46719 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
46720   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
46721   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
46722   return proxy->BakeColor(id, *vector4);
46723 }
46724
46725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
46726   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
46727   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
46728
46729   Dali::Stage *arg1 = (Dali::Stage *) 0;
46730   Dali::Actor *arg3 = 0;
46731
46732   arg1 = (Dali::Stage *)jarg1;
46733   arg3 = (Dali::Actor *)jarg3;
46734
46735   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
46736   return;
46737 }
46738
46739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
46740
46741   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
46742   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
46743
46744   Dali::Stage *arg1 = (Dali::Stage *) 0;
46745
46746   arg1 = (Dali::Stage *)jarg1;
46747
46748   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
46749   return;
46750 }
46751
46752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
46753   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
46754   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
46755   if (director) {
46756     director->swig_connect_director(callback0);
46757   }
46758 }
46759
46760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
46761   KeyboardFocusManager arg1 ;
46762   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
46763   KeyboardFocusManager *argp1 ;
46764
46765   argp1 = (KeyboardFocusManager *)jarg1;
46766   if (!argp1) {
46767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
46768     return ;
46769   }
46770   arg1 = *argp1;
46771   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
46772   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
46773   {
46774     try {
46775       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
46776     } CALL_CATCH_EXCEPTION();
46777   }
46778
46779 }
46780
46781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
46782   KeyboardFocusManager arg1 ;
46783   bool arg2 ;
46784   KeyboardFocusManager *argp1 ;
46785
46786   argp1 = (KeyboardFocusManager *)jarg1;
46787   if (!argp1) {
46788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
46789     return ;
46790   }
46791   arg1 = *argp1;
46792   arg2 = jarg2;
46793   {
46794     try {
46795       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
46796     } CALL_CATCH_EXCEPTION();
46797   }
46798 }
46799
46800 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
46801   bool jresult ;
46802   KeyboardFocusManager arg1 ;
46803   KeyboardFocusManager *argp1 ;
46804   bool result;
46805
46806   argp1 = (KeyboardFocusManager *)jarg1;
46807   if (!argp1) {
46808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
46809     return false;
46810   }
46811   arg1 = *argp1;
46812   {
46813     try {
46814       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
46815     } CALL_CATCH_EXCEPTION(0);
46816   }
46817   jresult = result;
46818   return jresult;
46819 }
46820
46821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
46822   if (!manager) {
46823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
46824     return ;
46825   }
46826   if (!actor) {
46827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
46828     return ;
46829   }
46830   {
46831     try {
46832       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
46833     } CALL_CATCH_EXCEPTION();
46834   }
46835 }
46836
46837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
46838   if (!manager) {
46839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
46840     return ;
46841   }
46842   {
46843     try {
46844       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
46845     } CALL_CATCH_EXCEPTION();
46846   }
46847 }
46848
46849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
46850   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46851
46852   arg1 = (std::vector< unsigned int > *)jarg1;
46853   {
46854     try {
46855       (arg1)->clear();
46856     } CALL_CATCH_EXCEPTION();
46857   }
46858
46859 }
46860
46861
46862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
46863   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46864   unsigned int *arg2 = 0 ;
46865   unsigned int temp2 ;
46866
46867   arg1 = (std::vector< unsigned int > *)jarg1;
46868   temp2 = (unsigned int)jarg2;
46869   arg2 = &temp2;
46870   {
46871     try {
46872       (arg1)->push_back((unsigned int const &)*arg2);
46873     } CALL_CATCH_EXCEPTION();
46874   }
46875
46876 }
46877
46878
46879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
46880   unsigned long jresult ;
46881   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46882   std::vector< unsigned int >::size_type result;
46883
46884   arg1 = (std::vector< unsigned int > *)jarg1;
46885   {
46886     try {
46887       result = ((std::vector< unsigned int > const *)arg1)->size();
46888     } CALL_CATCH_EXCEPTION(0);
46889   }
46890
46891   jresult = (unsigned long)result;
46892   return jresult;
46893 }
46894
46895
46896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
46897   unsigned long jresult ;
46898   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46899   std::vector< unsigned int >::size_type result;
46900
46901   arg1 = (std::vector< unsigned int > *)jarg1;
46902   {
46903     try {
46904       result = ((std::vector< unsigned int > const *)arg1)->capacity();
46905     } CALL_CATCH_EXCEPTION(0);
46906   }
46907
46908   jresult = (unsigned long)result;
46909   return jresult;
46910 }
46911
46912
46913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
46914   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46915   std::vector< unsigned int >::size_type arg2 ;
46916
46917   arg1 = (std::vector< unsigned int > *)jarg1;
46918   arg2 = (std::vector< unsigned int >::size_type)jarg2;
46919   {
46920     try {
46921       (arg1)->reserve(arg2);
46922     } CALL_CATCH_EXCEPTION();
46923   }
46924
46925 }
46926
46927
46928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
46929   void * jresult ;
46930   std::vector< unsigned int > *result = 0 ;
46931
46932   {
46933     try {
46934       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
46935     } CALL_CATCH_EXCEPTION(0);
46936   }
46937
46938   jresult = (void *)result;
46939   return jresult;
46940 }
46941
46942
46943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
46944   void * jresult ;
46945   std::vector< unsigned int > *arg1 = 0 ;
46946   std::vector< unsigned int > *result = 0 ;
46947
46948   arg1 = (std::vector< unsigned int > *)jarg1;
46949   if (!arg1) {
46950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
46951     return 0;
46952   }
46953   {
46954     try {
46955       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
46956     } CALL_CATCH_EXCEPTION(0);
46957   }
46958
46959   jresult = (void *)result;
46960   return jresult;
46961 }
46962
46963
46964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
46965   void * jresult ;
46966   int arg1 ;
46967   std::vector< unsigned int > *result = 0 ;
46968
46969   arg1 = (int)jarg1;
46970   {
46971     try {
46972       try {
46973         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
46974       }
46975       catch(std::out_of_range &_e) {
46976         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46977         return 0;
46978       }
46979
46980     } CALL_CATCH_EXCEPTION(0);
46981   }
46982
46983   jresult = (void *)result;
46984   return jresult;
46985 }
46986
46987
46988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
46989   unsigned int jresult ;
46990   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
46991   int arg2 ;
46992   unsigned int result;
46993
46994   arg1 = (std::vector< unsigned int > *)jarg1;
46995   arg2 = (int)jarg2;
46996   {
46997     try {
46998       try {
46999         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
47000       }
47001       catch(std::out_of_range &_e) {
47002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47003         return 0;
47004       }
47005
47006     } CALL_CATCH_EXCEPTION(0);
47007   }
47008
47009   jresult = result;
47010   return jresult;
47011 }
47012
47013
47014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
47015   unsigned int jresult ;
47016   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47017   int arg2 ;
47018   unsigned int *result = 0 ;
47019
47020   arg1 = (std::vector< unsigned int > *)jarg1;
47021   arg2 = (int)jarg2;
47022   {
47023     try {
47024       try {
47025         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
47026       }
47027       catch(std::out_of_range &_e) {
47028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47029         return 0;
47030       }
47031
47032     } CALL_CATCH_EXCEPTION(0);
47033   }
47034
47035   jresult = *result;
47036   return jresult;
47037 }
47038
47039
47040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
47041   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47042   int arg2 ;
47043   unsigned int *arg3 = 0 ;
47044   unsigned int temp3 ;
47045
47046   arg1 = (std::vector< unsigned int > *)jarg1;
47047   arg2 = (int)jarg2;
47048   temp3 = (unsigned int)jarg3;
47049   arg3 = &temp3;
47050   {
47051     try {
47052       try {
47053         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
47054       }
47055       catch(std::out_of_range &_e) {
47056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47057         return ;
47058       }
47059
47060     } CALL_CATCH_EXCEPTION();
47061   }
47062
47063 }
47064
47065
47066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
47067   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47068   std::vector< unsigned int > *arg2 = 0 ;
47069
47070   arg1 = (std::vector< unsigned int > *)jarg1;
47071   arg2 = (std::vector< unsigned int > *)jarg2;
47072   if (!arg2) {
47073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
47074     return ;
47075   }
47076   {
47077     try {
47078       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
47079     } CALL_CATCH_EXCEPTION();
47080   }
47081
47082 }
47083
47084
47085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
47086   void * jresult ;
47087   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47088   int arg2 ;
47089   int arg3 ;
47090   std::vector< unsigned int > *result = 0 ;
47091
47092   arg1 = (std::vector< unsigned int > *)jarg1;
47093   arg2 = (int)jarg2;
47094   arg3 = (int)jarg3;
47095   {
47096     try {
47097       try {
47098         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
47099       }
47100       catch(std::out_of_range &_e) {
47101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47102         return 0;
47103       }
47104       catch(std::invalid_argument &_e) {
47105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47106         return 0;
47107       }
47108
47109     } CALL_CATCH_EXCEPTION(0);
47110   }
47111
47112   jresult = (void *)result;
47113   return jresult;
47114 }
47115
47116
47117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
47118   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47119   int arg2 ;
47120   unsigned int *arg3 = 0 ;
47121   unsigned int temp3 ;
47122
47123   arg1 = (std::vector< unsigned int > *)jarg1;
47124   arg2 = (int)jarg2;
47125   temp3 = (unsigned int)jarg3;
47126   arg3 = &temp3;
47127   {
47128     try {
47129       try {
47130         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
47131       }
47132       catch(std::out_of_range &_e) {
47133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47134         return ;
47135       }
47136
47137     } CALL_CATCH_EXCEPTION();
47138   }
47139
47140 }
47141
47142
47143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
47144   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47145   int arg2 ;
47146   std::vector< unsigned int > *arg3 = 0 ;
47147
47148   arg1 = (std::vector< unsigned int > *)jarg1;
47149   arg2 = (int)jarg2;
47150   arg3 = (std::vector< unsigned int > *)jarg3;
47151   if (!arg3) {
47152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
47153     return ;
47154   }
47155   {
47156     try {
47157       try {
47158         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
47159       }
47160       catch(std::out_of_range &_e) {
47161         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47162         return ;
47163       }
47164
47165     } CALL_CATCH_EXCEPTION();
47166   }
47167
47168 }
47169
47170
47171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
47172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47173   int arg2 ;
47174
47175   arg1 = (std::vector< unsigned int > *)jarg1;
47176   arg2 = (int)jarg2;
47177   {
47178     try {
47179       try {
47180         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
47181       }
47182       catch(std::out_of_range &_e) {
47183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47184         return ;
47185       }
47186
47187     } CALL_CATCH_EXCEPTION();
47188   }
47189
47190 }
47191
47192
47193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
47194   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47195   int arg2 ;
47196   int arg3 ;
47197
47198   arg1 = (std::vector< unsigned int > *)jarg1;
47199   arg2 = (int)jarg2;
47200   arg3 = (int)jarg3;
47201   {
47202     try {
47203       try {
47204         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
47205       }
47206       catch(std::out_of_range &_e) {
47207         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47208         return ;
47209       }
47210       catch(std::invalid_argument &_e) {
47211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47212         return ;
47213       }
47214
47215     } CALL_CATCH_EXCEPTION();
47216   }
47217
47218 }
47219
47220
47221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
47222   void * jresult ;
47223   unsigned int *arg1 = 0 ;
47224   int arg2 ;
47225   unsigned int temp1 ;
47226   std::vector< unsigned int > *result = 0 ;
47227
47228   temp1 = (unsigned int)jarg1;
47229   arg1 = &temp1;
47230   arg2 = (int)jarg2;
47231   {
47232     try {
47233       try {
47234         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
47235       }
47236       catch(std::out_of_range &_e) {
47237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47238         return 0;
47239       }
47240
47241     } CALL_CATCH_EXCEPTION(0);
47242   }
47243
47244   jresult = (void *)result;
47245   return jresult;
47246 }
47247
47248
47249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
47250   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47251
47252   arg1 = (std::vector< unsigned int > *)jarg1;
47253   {
47254     try {
47255       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
47256     } CALL_CATCH_EXCEPTION();
47257   }
47258
47259 }
47260
47261
47262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
47263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47264   int arg2 ;
47265   int arg3 ;
47266
47267   arg1 = (std::vector< unsigned int > *)jarg1;
47268   arg2 = (int)jarg2;
47269   arg3 = (int)jarg3;
47270   {
47271     try {
47272       try {
47273         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
47274       }
47275       catch(std::out_of_range &_e) {
47276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47277         return ;
47278       }
47279       catch(std::invalid_argument &_e) {
47280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47281         return ;
47282       }
47283
47284     } CALL_CATCH_EXCEPTION();
47285   }
47286
47287 }
47288
47289
47290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
47291   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47292   int arg2 ;
47293   std::vector< unsigned int > *arg3 = 0 ;
47294
47295   arg1 = (std::vector< unsigned int > *)jarg1;
47296   arg2 = (int)jarg2;
47297   arg3 = (std::vector< unsigned int > *)jarg3;
47298   if (!arg3) {
47299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
47300     return ;
47301   }
47302   {
47303     try {
47304       try {
47305         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
47306       }
47307       catch(std::out_of_range &_e) {
47308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47309         return ;
47310       }
47311
47312     } CALL_CATCH_EXCEPTION();
47313   }
47314
47315 }
47316
47317
47318 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
47319   bool jresult ;
47320   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47321   unsigned int *arg2 = 0 ;
47322   unsigned int temp2 ;
47323   bool result;
47324
47325   arg1 = (std::vector< unsigned int > *)jarg1;
47326   temp2 = (unsigned int)jarg2;
47327   arg2 = &temp2;
47328   {
47329     try {
47330       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
47331     } CALL_CATCH_EXCEPTION(0);
47332   }
47333
47334   jresult = result;
47335   return jresult;
47336 }
47337
47338
47339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
47340   int jresult ;
47341   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47342   unsigned int *arg2 = 0 ;
47343   unsigned int temp2 ;
47344   int result;
47345
47346   arg1 = (std::vector< unsigned int > *)jarg1;
47347   temp2 = (unsigned int)jarg2;
47348   arg2 = &temp2;
47349   {
47350     try {
47351       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
47352     } CALL_CATCH_EXCEPTION(0);
47353   }
47354
47355   jresult = result;
47356   return jresult;
47357 }
47358
47359
47360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
47361   int jresult ;
47362   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47363   unsigned int *arg2 = 0 ;
47364   unsigned int temp2 ;
47365   int result;
47366
47367   arg1 = (std::vector< unsigned int > *)jarg1;
47368   temp2 = (unsigned int)jarg2;
47369   arg2 = &temp2;
47370   {
47371     try {
47372       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
47373     } CALL_CATCH_EXCEPTION(0);
47374   }
47375
47376   jresult = result;
47377   return jresult;
47378 }
47379
47380
47381 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
47382   bool jresult ;
47383   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47384   unsigned int *arg2 = 0 ;
47385   unsigned int temp2 ;
47386   bool result;
47387
47388   arg1 = (std::vector< unsigned int > *)jarg1;
47389   temp2 = (unsigned int)jarg2;
47390   arg2 = &temp2;
47391   {
47392     try {
47393       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
47394     } CALL_CATCH_EXCEPTION(0);
47395   }
47396
47397   jresult = result;
47398   return jresult;
47399 }
47400
47401
47402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
47403   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
47404
47405   arg1 = (std::vector< unsigned int > *)jarg1;
47406   {
47407     try {
47408       delete arg1;
47409     } CALL_CATCH_EXCEPTION();
47410   }
47411
47412 }
47413
47414
47415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
47416   void * jresult ;
47417   std::pair< unsigned int,Dali::Actor > *result = 0 ;
47418
47419   {
47420     try {
47421       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
47422     } CALL_CATCH_EXCEPTION(0);
47423   }
47424
47425   jresult = (void *)result;
47426   return jresult;
47427 }
47428
47429
47430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
47431   void * jresult ;
47432   unsigned int arg1 ;
47433   Dali::Actor arg2 ;
47434   Dali::Actor *argp2 ;
47435   std::pair< unsigned int,Dali::Actor > *result = 0 ;
47436
47437   arg1 = (unsigned int)jarg1;
47438   argp2 = (Dali::Actor *)jarg2;
47439   if (!argp2) {
47440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47441     return 0;
47442   }
47443   arg2 = *argp2;
47444   {
47445     try {
47446       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
47447     } CALL_CATCH_EXCEPTION(0);
47448   }
47449
47450   jresult = (void *)result;
47451   return jresult;
47452 }
47453
47454
47455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
47456   void * jresult ;
47457   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
47458   std::pair< unsigned int,Dali::Actor > *result = 0 ;
47459
47460   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47461   if (!arg1) {
47462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
47463     return 0;
47464   }
47465   {
47466     try {
47467       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
47468     } CALL_CATCH_EXCEPTION(0);
47469   }
47470
47471   jresult = (void *)result;
47472   return jresult;
47473 }
47474
47475
47476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
47477   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
47478   unsigned int arg2 ;
47479
47480   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47481   arg2 = (unsigned int)jarg2;
47482   if (arg1) (arg1)->first = arg2;
47483 }
47484
47485
47486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
47487   unsigned int jresult ;
47488   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
47489   unsigned int result;
47490
47491   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47492   result = (unsigned int) ((arg1)->first);
47493   jresult = result;
47494   return jresult;
47495 }
47496
47497
47498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
47499   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
47500   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
47501
47502   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47503   arg2 = (Dali::Actor *)jarg2;
47504   if (arg1) (arg1)->second = *arg2;
47505 }
47506
47507
47508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
47509   void * jresult ;
47510   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
47511   Dali::Actor *result = 0 ;
47512
47513   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47514   result = (Dali::Actor *)& ((arg1)->second);
47515   jresult = (void *)result;
47516   return jresult;
47517 }
47518
47519
47520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
47521   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
47522
47523   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47524   {
47525     try {
47526       delete arg1;
47527     } CALL_CATCH_EXCEPTION();
47528   }
47529
47530 }
47531
47532
47533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
47534   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47535
47536   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47537   {
47538     try {
47539       (arg1)->clear();
47540     } CALL_CATCH_EXCEPTION();
47541   }
47542
47543 }
47544
47545
47546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
47547   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47548   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
47549
47550   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47551   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
47552   if (!arg2) {
47553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
47554     return ;
47555   }
47556   {
47557     try {
47558       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
47559     } CALL_CATCH_EXCEPTION();
47560   }
47561
47562 }
47563
47564
47565 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
47566   unsigned long jresult ;
47567   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47568   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
47569
47570   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47571   {
47572     try {
47573       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
47574     } CALL_CATCH_EXCEPTION(0);
47575   }
47576
47577   jresult = (unsigned long)result;
47578   return jresult;
47579 }
47580
47581
47582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
47583   unsigned long jresult ;
47584   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47585   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
47586
47587   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47588   {
47589     try {
47590       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
47591     } CALL_CATCH_EXCEPTION(0);
47592   }
47593
47594   jresult = (unsigned long)result;
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
47600   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47601   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
47602
47603   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47604   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
47605   {
47606     try {
47607       (arg1)->reserve(arg2);
47608     } CALL_CATCH_EXCEPTION();
47609   }
47610
47611 }
47612
47613
47614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
47615   void * jresult ;
47616   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
47617
47618   {
47619     try {
47620       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
47621     } CALL_CATCH_EXCEPTION(0);
47622   }
47623
47624   jresult = (void *)result;
47625   return jresult;
47626 }
47627
47628
47629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
47630   void * jresult ;
47631   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
47632   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
47633
47634   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47635   if (!arg1) {
47636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
47637     return 0;
47638   }
47639   {
47640     try {
47641       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);
47642     } CALL_CATCH_EXCEPTION(0);
47643   }
47644
47645   jresult = (void *)result;
47646   return jresult;
47647 }
47648
47649
47650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
47651   void * jresult ;
47652   int arg1 ;
47653   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
47654
47655   arg1 = (int)jarg1;
47656   {
47657     try {
47658       try {
47659         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);
47660       }
47661       catch(std::out_of_range &_e) {
47662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47663         return 0;
47664       }
47665
47666     } CALL_CATCH_EXCEPTION(0);
47667   }
47668
47669   jresult = (void *)result;
47670   return jresult;
47671 }
47672
47673
47674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
47675   void * jresult ;
47676   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47677   int arg2 ;
47678   std::pair< unsigned int,Dali::Actor > result;
47679
47680   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47681   arg2 = (int)jarg2;
47682   {
47683     try {
47684       try {
47685         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
47686       }
47687       catch(std::out_of_range &_e) {
47688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47689         return 0;
47690       }
47691
47692     } CALL_CATCH_EXCEPTION(0);
47693   }
47694
47695   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
47696   return jresult;
47697 }
47698
47699
47700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
47701   void * jresult ;
47702   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47703   int arg2 ;
47704   std::pair< unsigned int,Dali::Actor > *result = 0 ;
47705
47706   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47707   arg2 = (int)jarg2;
47708   {
47709     try {
47710       try {
47711         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
47712       }
47713       catch(std::out_of_range &_e) {
47714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47715         return 0;
47716       }
47717
47718     } CALL_CATCH_EXCEPTION(0);
47719   }
47720
47721   jresult = (void *)result;
47722   return jresult;
47723 }
47724
47725
47726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
47727   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47728   int arg2 ;
47729   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
47730
47731   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47732   arg2 = (int)jarg2;
47733   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
47734   if (!arg3) {
47735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
47736     return ;
47737   }
47738   {
47739     try {
47740       try {
47741         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);
47742       }
47743       catch(std::out_of_range &_e) {
47744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47745         return ;
47746       }
47747
47748     } CALL_CATCH_EXCEPTION();
47749   }
47750
47751 }
47752
47753
47754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
47755   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47756   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
47757
47758   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47759   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
47760   if (!arg2) {
47761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
47762     return ;
47763   }
47764   {
47765     try {
47766       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);
47767     } CALL_CATCH_EXCEPTION();
47768   }
47769
47770 }
47771
47772
47773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
47774   void * jresult ;
47775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47776   int arg2 ;
47777   int arg3 ;
47778   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
47779
47780   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47781   arg2 = (int)jarg2;
47782   arg3 = (int)jarg3;
47783   {
47784     try {
47785       try {
47786         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);
47787       }
47788       catch(std::out_of_range &_e) {
47789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47790         return 0;
47791       }
47792       catch(std::invalid_argument &_e) {
47793         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47794         return 0;
47795       }
47796
47797     } CALL_CATCH_EXCEPTION(0);
47798   }
47799
47800   jresult = (void *)result;
47801   return jresult;
47802 }
47803
47804
47805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
47806   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47807   int arg2 ;
47808   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
47809
47810   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47811   arg2 = (int)jarg2;
47812   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
47813   if (!arg3) {
47814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
47815     return ;
47816   }
47817   {
47818     try {
47819       try {
47820         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);
47821       }
47822       catch(std::out_of_range &_e) {
47823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47824         return ;
47825       }
47826
47827     } CALL_CATCH_EXCEPTION();
47828   }
47829
47830 }
47831
47832
47833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
47834   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47835   int arg2 ;
47836   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
47837
47838   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47839   arg2 = (int)jarg2;
47840   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
47841   if (!arg3) {
47842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
47843     return ;
47844   }
47845   {
47846     try {
47847       try {
47848         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);
47849       }
47850       catch(std::out_of_range &_e) {
47851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47852         return ;
47853       }
47854
47855     } CALL_CATCH_EXCEPTION();
47856   }
47857
47858 }
47859
47860
47861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
47862   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47863   int arg2 ;
47864
47865   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47866   arg2 = (int)jarg2;
47867   {
47868     try {
47869       try {
47870         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
47871       }
47872       catch(std::out_of_range &_e) {
47873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47874         return ;
47875       }
47876
47877     } CALL_CATCH_EXCEPTION();
47878   }
47879
47880 }
47881
47882
47883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
47884   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47885   int arg2 ;
47886   int arg3 ;
47887
47888   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47889   arg2 = (int)jarg2;
47890   arg3 = (int)jarg3;
47891   {
47892     try {
47893       try {
47894         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
47895       }
47896       catch(std::out_of_range &_e) {
47897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47898         return ;
47899       }
47900       catch(std::invalid_argument &_e) {
47901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47902         return ;
47903       }
47904
47905     } CALL_CATCH_EXCEPTION();
47906   }
47907
47908 }
47909
47910
47911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
47912   void * jresult ;
47913   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
47914   int arg2 ;
47915   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
47916
47917   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
47918   if (!arg1) {
47919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
47920     return 0;
47921   }
47922   arg2 = (int)jarg2;
47923   {
47924     try {
47925       try {
47926         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);
47927       }
47928       catch(std::out_of_range &_e) {
47929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47930         return 0;
47931       }
47932
47933     } CALL_CATCH_EXCEPTION(0);
47934   }
47935
47936   jresult = (void *)result;
47937   return jresult;
47938 }
47939
47940
47941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
47942   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47943
47944   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47945   {
47946     try {
47947       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
47948     } CALL_CATCH_EXCEPTION();
47949   }
47950
47951 }
47952
47953
47954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
47955   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47956   int arg2 ;
47957   int arg3 ;
47958
47959   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47960   arg2 = (int)jarg2;
47961   arg3 = (int)jarg3;
47962   {
47963     try {
47964       try {
47965         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
47966       }
47967       catch(std::out_of_range &_e) {
47968         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47969         return ;
47970       }
47971       catch(std::invalid_argument &_e) {
47972         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47973         return ;
47974       }
47975
47976     } CALL_CATCH_EXCEPTION();
47977   }
47978
47979 }
47980
47981
47982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
47983   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
47984   int arg2 ;
47985   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
47986
47987   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
47988   arg2 = (int)jarg2;
47989   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
47990   if (!arg3) {
47991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
47992     return ;
47993   }
47994   {
47995     try {
47996       try {
47997         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);
47998       }
47999       catch(std::out_of_range &_e) {
48000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48001         return ;
48002       }
48003
48004     } CALL_CATCH_EXCEPTION();
48005   }
48006
48007 }
48008
48009
48010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
48011   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
48012
48013   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
48014   {
48015     try {
48016       delete arg1;
48017     } CALL_CATCH_EXCEPTION();
48018   }
48019
48020 }
48021
48022
48023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
48024   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48025
48026   arg1 = (std::vector< Dali::Actor > *)jarg1;
48027   {
48028     try {
48029       (arg1)->clear();
48030     } CALL_CATCH_EXCEPTION();
48031   }
48032
48033 }
48034
48035
48036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
48037   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48038   Dali::Actor *arg2 = 0 ;
48039
48040   arg1 = (std::vector< Dali::Actor > *)jarg1;
48041   arg2 = (Dali::Actor *)jarg2;
48042   if (!arg2) {
48043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
48044     return ;
48045   }
48046   {
48047     try {
48048       (arg1)->push_back((Dali::Actor const &)*arg2);
48049     } CALL_CATCH_EXCEPTION();
48050   }
48051
48052 }
48053
48054
48055 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
48056   unsigned long jresult ;
48057   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48058   std::vector< Dali::Actor >::size_type result;
48059
48060   arg1 = (std::vector< Dali::Actor > *)jarg1;
48061   {
48062     try {
48063       result = ((std::vector< Dali::Actor > const *)arg1)->size();
48064     } CALL_CATCH_EXCEPTION(0);
48065   }
48066
48067   jresult = (unsigned long)result;
48068   return jresult;
48069 }
48070
48071
48072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
48073   unsigned long jresult ;
48074   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48075   std::vector< Dali::Actor >::size_type result;
48076
48077   arg1 = (std::vector< Dali::Actor > *)jarg1;
48078   {
48079     try {
48080       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
48081     } CALL_CATCH_EXCEPTION(0);
48082   }
48083
48084   jresult = (unsigned long)result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
48090   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48091   std::vector< Dali::Actor >::size_type arg2 ;
48092
48093   arg1 = (std::vector< Dali::Actor > *)jarg1;
48094   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
48095   {
48096     try {
48097       (arg1)->reserve(arg2);
48098     } CALL_CATCH_EXCEPTION();
48099   }
48100
48101 }
48102
48103
48104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
48105   void * jresult ;
48106   std::vector< Dali::Actor > *result = 0 ;
48107
48108   {
48109     try {
48110       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
48111     } CALL_CATCH_EXCEPTION(0);
48112   }
48113
48114   jresult = (void *)result;
48115   return jresult;
48116 }
48117
48118
48119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
48120   void * jresult ;
48121   std::vector< Dali::Actor > *arg1 = 0 ;
48122   std::vector< Dali::Actor > *result = 0 ;
48123
48124   arg1 = (std::vector< Dali::Actor > *)jarg1;
48125   if (!arg1) {
48126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
48127     return 0;
48128   }
48129   {
48130     try {
48131       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
48132     } CALL_CATCH_EXCEPTION(0);
48133   }
48134
48135   jresult = (void *)result;
48136   return jresult;
48137 }
48138
48139
48140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
48141   void * jresult ;
48142   int arg1 ;
48143   std::vector< Dali::Actor > *result = 0 ;
48144
48145   arg1 = (int)jarg1;
48146   {
48147     try {
48148       try {
48149         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
48150       }
48151       catch(std::out_of_range &_e) {
48152         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48153         return 0;
48154       }
48155
48156     } CALL_CATCH_EXCEPTION(0);
48157   }
48158
48159   jresult = (void *)result;
48160   return jresult;
48161 }
48162
48163
48164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
48165   void * jresult ;
48166   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48167   int arg2 ;
48168   Dali::Actor result;
48169
48170   arg1 = (std::vector< Dali::Actor > *)jarg1;
48171   arg2 = (int)jarg2;
48172   {
48173     try {
48174       try {
48175         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
48176       }
48177       catch(std::out_of_range &_e) {
48178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48179         return 0;
48180       }
48181
48182     } CALL_CATCH_EXCEPTION(0);
48183   }
48184
48185   jresult = new Dali::Actor((const Dali::Actor &)result);
48186   return jresult;
48187 }
48188
48189
48190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
48191   void * jresult ;
48192   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48193   int arg2 ;
48194   Dali::Actor *result = 0 ;
48195
48196   arg1 = (std::vector< Dali::Actor > *)jarg1;
48197   arg2 = (int)jarg2;
48198   {
48199     try {
48200       try {
48201         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
48202       }
48203       catch(std::out_of_range &_e) {
48204         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48205         return 0;
48206       }
48207
48208     } CALL_CATCH_EXCEPTION(0);
48209   }
48210
48211   jresult = (void *)result;
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
48217   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48218   int arg2 ;
48219   Dali::Actor *arg3 = 0 ;
48220
48221   arg1 = (std::vector< Dali::Actor > *)jarg1;
48222   arg2 = (int)jarg2;
48223   arg3 = (Dali::Actor *)jarg3;
48224   if (!arg3) {
48225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
48226     return ;
48227   }
48228   {
48229     try {
48230       try {
48231         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
48232       }
48233       catch(std::out_of_range &_e) {
48234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48235         return ;
48236       }
48237
48238     } CALL_CATCH_EXCEPTION();
48239   }
48240
48241 }
48242
48243
48244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
48245   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48246   std::vector< Dali::Actor > *arg2 = 0 ;
48247
48248   arg1 = (std::vector< Dali::Actor > *)jarg1;
48249   arg2 = (std::vector< Dali::Actor > *)jarg2;
48250   if (!arg2) {
48251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
48252     return ;
48253   }
48254   {
48255     try {
48256       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
48257     } CALL_CATCH_EXCEPTION();
48258   }
48259
48260 }
48261
48262
48263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
48264   void * jresult ;
48265   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48266   int arg2 ;
48267   int arg3 ;
48268   std::vector< Dali::Actor > *result = 0 ;
48269
48270   arg1 = (std::vector< Dali::Actor > *)jarg1;
48271   arg2 = (int)jarg2;
48272   arg3 = (int)jarg3;
48273   {
48274     try {
48275       try {
48276         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
48277       }
48278       catch(std::out_of_range &_e) {
48279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48280         return 0;
48281       }
48282       catch(std::invalid_argument &_e) {
48283         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48284         return 0;
48285       }
48286
48287     } CALL_CATCH_EXCEPTION(0);
48288   }
48289
48290   jresult = (void *)result;
48291   return jresult;
48292 }
48293
48294
48295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
48296   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48297   int arg2 ;
48298   Dali::Actor *arg3 = 0 ;
48299
48300   arg1 = (std::vector< Dali::Actor > *)jarg1;
48301   arg2 = (int)jarg2;
48302   arg3 = (Dali::Actor *)jarg3;
48303   if (!arg3) {
48304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
48305     return ;
48306   }
48307   {
48308     try {
48309       try {
48310         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
48311       }
48312       catch(std::out_of_range &_e) {
48313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48314         return ;
48315       }
48316
48317     } CALL_CATCH_EXCEPTION();
48318   }
48319
48320 }
48321
48322
48323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
48324   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48325   int arg2 ;
48326   std::vector< Dali::Actor > *arg3 = 0 ;
48327
48328   arg1 = (std::vector< Dali::Actor > *)jarg1;
48329   arg2 = (int)jarg2;
48330   arg3 = (std::vector< Dali::Actor > *)jarg3;
48331   if (!arg3) {
48332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
48333     return ;
48334   }
48335   {
48336     try {
48337       try {
48338         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
48339       }
48340       catch(std::out_of_range &_e) {
48341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48342         return ;
48343       }
48344
48345     } CALL_CATCH_EXCEPTION();
48346   }
48347
48348 }
48349
48350
48351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
48352   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48353   int arg2 ;
48354
48355   arg1 = (std::vector< Dali::Actor > *)jarg1;
48356   arg2 = (int)jarg2;
48357   {
48358     try {
48359       try {
48360         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
48361       }
48362       catch(std::out_of_range &_e) {
48363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48364         return ;
48365       }
48366
48367     } CALL_CATCH_EXCEPTION();
48368   }
48369
48370 }
48371
48372
48373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
48374   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48375   int arg2 ;
48376   int arg3 ;
48377
48378   arg1 = (std::vector< Dali::Actor > *)jarg1;
48379   arg2 = (int)jarg2;
48380   arg3 = (int)jarg3;
48381   {
48382     try {
48383       try {
48384         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
48385       }
48386       catch(std::out_of_range &_e) {
48387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48388         return ;
48389       }
48390       catch(std::invalid_argument &_e) {
48391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48392         return ;
48393       }
48394
48395     } CALL_CATCH_EXCEPTION();
48396   }
48397
48398 }
48399
48400
48401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
48402   void * jresult ;
48403   Dali::Actor *arg1 = 0 ;
48404   int arg2 ;
48405   std::vector< Dali::Actor > *result = 0 ;
48406
48407   arg1 = (Dali::Actor *)jarg1;
48408   if (!arg1) {
48409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
48410     return 0;
48411   }
48412   arg2 = (int)jarg2;
48413   {
48414     try {
48415       try {
48416         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
48417       }
48418       catch(std::out_of_range &_e) {
48419         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48420         return 0;
48421       }
48422
48423     } CALL_CATCH_EXCEPTION(0);
48424   }
48425
48426   jresult = (void *)result;
48427   return jresult;
48428 }
48429
48430
48431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
48432   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48433
48434   arg1 = (std::vector< Dali::Actor > *)jarg1;
48435   {
48436     try {
48437       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
48438     } CALL_CATCH_EXCEPTION();
48439   }
48440
48441 }
48442
48443
48444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
48445   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48446   int arg2 ;
48447   int arg3 ;
48448
48449   arg1 = (std::vector< Dali::Actor > *)jarg1;
48450   arg2 = (int)jarg2;
48451   arg3 = (int)jarg3;
48452   {
48453     try {
48454       try {
48455         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
48456       }
48457       catch(std::out_of_range &_e) {
48458         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48459         return ;
48460       }
48461       catch(std::invalid_argument &_e) {
48462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48463         return ;
48464       }
48465
48466     } CALL_CATCH_EXCEPTION();
48467   }
48468
48469 }
48470
48471
48472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
48473   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48474   int arg2 ;
48475   std::vector< Dali::Actor > *arg3 = 0 ;
48476
48477   arg1 = (std::vector< Dali::Actor > *)jarg1;
48478   arg2 = (int)jarg2;
48479   arg3 = (std::vector< Dali::Actor > *)jarg3;
48480   if (!arg3) {
48481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
48482     return ;
48483   }
48484   {
48485     try {
48486       try {
48487         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
48488       }
48489       catch(std::out_of_range &_e) {
48490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48491         return ;
48492       }
48493
48494     } CALL_CATCH_EXCEPTION();
48495   }
48496
48497 }
48498
48499
48500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
48501   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
48502
48503   arg1 = (std::vector< Dali::Actor > *)jarg1;
48504   {
48505     try {
48506       delete arg1;
48507     } CALL_CATCH_EXCEPTION();
48508   }
48509
48510 }
48511
48512
48513 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
48514   bool jresult ;
48515   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48516   bool result;
48517
48518   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48519   {
48520     try {
48521       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
48522     } CALL_CATCH_EXCEPTION(0);
48523   }
48524
48525   jresult = result;
48526   return jresult;
48527 }
48528
48529
48530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
48531   unsigned long jresult ;
48532   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48533   std::size_t result;
48534
48535   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48536   {
48537     try {
48538       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
48539     } CALL_CATCH_EXCEPTION(0);
48540   }
48541
48542   jresult = (unsigned long)result;
48543   return jresult;
48544 }
48545
48546
48547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
48548   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48549   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
48550
48551   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48552   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
48553   {
48554     try {
48555       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
48556     } CALL_CATCH_EXCEPTION();
48557   }
48558
48559 }
48560
48561
48562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
48563   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48564   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
48565
48566   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48567   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
48568   {
48569     try {
48570       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
48571     } CALL_CATCH_EXCEPTION();
48572   }
48573
48574 }
48575
48576
48577 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
48578   bool jresult ;
48579   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48580   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
48581   bool result;
48582
48583   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48584   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
48585   if (!arg2) {
48586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
48587     return 0;
48588   }
48589   {
48590     try {
48591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
48592     } CALL_CATCH_EXCEPTION(0);
48593   }
48594
48595   jresult = result;
48596   return jresult;
48597 }
48598
48599
48600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
48601   void * jresult ;
48602   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
48603
48604   {
48605     try {
48606       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
48607     } CALL_CATCH_EXCEPTION(0);
48608   }
48609
48610   jresult = (void *)result;
48611   return jresult;
48612 }
48613
48614
48615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
48616   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
48617
48618   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
48619   {
48620     try {
48621       delete arg1;
48622     } CALL_CATCH_EXCEPTION();
48623   }
48624
48625 }
48626
48627
48628 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
48629   bool jresult ;
48630   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48631   bool result;
48632
48633   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48634   {
48635     try {
48636       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);
48637     } CALL_CATCH_EXCEPTION(0);
48638   }
48639
48640   jresult = result;
48641   return jresult;
48642 }
48643
48644
48645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
48646   unsigned long jresult ;
48647   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48648   std::size_t result;
48649
48650   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48651   {
48652     try {
48653       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);
48654     } CALL_CATCH_EXCEPTION(0);
48655   }
48656
48657   jresult = (unsigned long)result;
48658   return jresult;
48659 }
48660
48661
48662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
48663   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48664   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
48665
48666   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48667   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
48668   {
48669     try {
48670       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
48671     } CALL_CATCH_EXCEPTION();
48672   }
48673
48674 }
48675
48676
48677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
48678   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48679   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
48680
48681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48682   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
48683   {
48684     try {
48685       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
48686     } CALL_CATCH_EXCEPTION();
48687   }
48688
48689 }
48690
48691
48692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
48693   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48694   Dali::Actor arg2 ;
48695   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
48696   Dali::Actor *argp2 ;
48697
48698   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48699   argp2 = (Dali::Actor *)jarg2;
48700   if (!argp2) {
48701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48702     return ;
48703   }
48704   arg2 = *argp2;
48705   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
48706   {
48707     try {
48708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
48709     } CALL_CATCH_EXCEPTION();
48710   }
48711
48712 }
48713
48714
48715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
48716   void * jresult ;
48717   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
48718
48719   {
48720     try {
48721       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
48722     } CALL_CATCH_EXCEPTION(0);
48723   }
48724
48725   jresult = (void *)result;
48726   return jresult;
48727 }
48728
48729
48730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
48731   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
48732
48733   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
48734   {
48735     try {
48736       delete arg1;
48737     } CALL_CATCH_EXCEPTION();
48738   }
48739
48740 }
48741
48742
48743 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
48744   bool jresult ;
48745   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48746   bool result;
48747
48748   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48749   {
48750     try {
48751       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
48752     } CALL_CATCH_EXCEPTION(0);
48753   }
48754
48755   jresult = result;
48756   return jresult;
48757 }
48758
48759
48760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
48761   unsigned long jresult ;
48762   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48763   std::size_t result;
48764
48765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48766   {
48767     try {
48768       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
48769     } CALL_CATCH_EXCEPTION(0);
48770   }
48771
48772   jresult = (unsigned long)result;
48773   return jresult;
48774 }
48775
48776
48777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
48778   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48779   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
48780
48781   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48782   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
48783   {
48784     try {
48785       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48786     } CALL_CATCH_EXCEPTION();
48787   }
48788
48789 }
48790
48791
48792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
48793   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48794   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
48795
48796   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48797   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
48798   {
48799     try {
48800       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48801     } CALL_CATCH_EXCEPTION();
48802   }
48803
48804 }
48805
48806
48807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48808   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48809   Dali::Actor arg2 ;
48810   Dali::Actor arg3 ;
48811   Dali::Actor *argp2 ;
48812   Dali::Actor *argp3 ;
48813
48814   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48815   argp2 = (Dali::Actor *)jarg2;
48816   if (!argp2) {
48817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48818     return ;
48819   }
48820   arg2 = *argp2;
48821   argp3 = (Dali::Actor *)jarg3;
48822   if (!argp3) {
48823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48824     return ;
48825   }
48826   arg3 = *argp3;
48827   {
48828     try {
48829       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
48830     } CALL_CATCH_EXCEPTION();
48831   }
48832
48833 }
48834
48835
48836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
48837   void * jresult ;
48838   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
48839
48840   {
48841     try {
48842       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
48843     } CALL_CATCH_EXCEPTION(0);
48844   }
48845
48846   jresult = (void *)result;
48847   return jresult;
48848 }
48849
48850
48851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
48852   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
48853
48854   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
48855   {
48856     try {
48857       delete arg1;
48858     } CALL_CATCH_EXCEPTION();
48859   }
48860
48861 }
48862
48863
48864 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
48865   bool jresult ;
48866   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48867   bool result;
48868
48869   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48870   {
48871     try {
48872       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
48873     } CALL_CATCH_EXCEPTION(0);
48874   }
48875
48876   jresult = result;
48877   return jresult;
48878 }
48879
48880
48881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
48882   unsigned long jresult ;
48883   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48884   std::size_t result;
48885
48886   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48887   {
48888     try {
48889       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
48890     } CALL_CATCH_EXCEPTION(0);
48891   }
48892
48893   jresult = (unsigned long)result;
48894   return jresult;
48895 }
48896
48897
48898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
48899   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48900   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
48901
48902   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48903   arg2 = (void (*)(Dali::Actor,bool))jarg2;
48904   {
48905     try {
48906       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
48907     } CALL_CATCH_EXCEPTION();
48908   }
48909
48910 }
48911
48912
48913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
48914   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48915   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
48916
48917   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48918   arg2 = (void (*)(Dali::Actor,bool))jarg2;
48919   {
48920     try {
48921       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
48922     } CALL_CATCH_EXCEPTION();
48923   }
48924
48925 }
48926
48927
48928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
48929   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48930   Dali::Actor arg2 ;
48931   bool arg3 ;
48932   Dali::Actor *argp2 ;
48933
48934   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48935   argp2 = (Dali::Actor *)jarg2;
48936   if (!argp2) {
48937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48938     return ;
48939   }
48940   arg2 = *argp2;
48941   arg3 = jarg3 ? true : false;
48942   {
48943     try {
48944       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
48945     } CALL_CATCH_EXCEPTION();
48946   }
48947
48948 }
48949
48950
48951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
48952   void * jresult ;
48953   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
48954
48955   {
48956     try {
48957       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
48958     } CALL_CATCH_EXCEPTION(0);
48959   }
48960
48961   jresult = (void *)result;
48962   return jresult;
48963 }
48964
48965
48966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
48967   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
48968
48969   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
48970   {
48971     try {
48972       delete arg1;
48973     } CALL_CATCH_EXCEPTION();
48974   }
48975
48976 }
48977
48978
48979 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
48980   bool jresult ;
48981   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
48982   bool result;
48983
48984   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
48985   {
48986     try {
48987       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);
48988     } CALL_CATCH_EXCEPTION(0);
48989   }
48990
48991   jresult = result;
48992   return jresult;
48993 }
48994
48995
48996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
48997   unsigned long jresult ;
48998   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
48999   std::size_t result;
49000
49001   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
49002   {
49003     try {
49004       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);
49005     } CALL_CATCH_EXCEPTION(0);
49006   }
49007
49008   jresult = (unsigned long)result;
49009   return jresult;
49010 }
49011
49012
49013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
49014   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
49015   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
49016
49017   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
49018   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
49019   {
49020     try {
49021       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
49022     } CALL_CATCH_EXCEPTION();
49023   }
49024
49025 }
49026
49027
49028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
49029   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
49030   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
49031
49032   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
49033   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
49034   {
49035     try {
49036       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
49037     } CALL_CATCH_EXCEPTION();
49038   }
49039
49040 }
49041
49042
49043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
49044   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
49045   Dali::Toolkit::StyleManager arg2 ;
49046   Dali::StyleChange::Type arg3 ;
49047   Dali::Toolkit::StyleManager *argp2 ;
49048
49049   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
49050   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
49051   if (!argp2) {
49052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
49053     return ;
49054   }
49055   arg2 = *argp2;
49056   arg3 = (Dali::StyleChange::Type)jarg3;
49057   {
49058     try {
49059       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
49060     } CALL_CATCH_EXCEPTION();
49061   }
49062
49063 }
49064
49065
49066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
49067   void * jresult ;
49068   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
49069
49070   {
49071     try {
49072       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
49073     } CALL_CATCH_EXCEPTION(0);
49074   }
49075
49076   jresult = (void *)result;
49077   return jresult;
49078 }
49079
49080
49081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
49082   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
49083
49084   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
49085   {
49086     try {
49087       delete arg1;
49088     } CALL_CATCH_EXCEPTION();
49089   }
49090
49091 }
49092
49093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
49094   bool jresult ;
49095   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49096   bool result;
49097
49098   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49099   {
49100     try {
49101       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
49102     } CALL_CATCH_EXCEPTION(0);
49103   }
49104
49105   jresult = result;
49106   return jresult;
49107 }
49108
49109
49110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
49111   unsigned long jresult ;
49112   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49113   std::size_t result;
49114
49115   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49116   {
49117     try {
49118       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
49119     } CALL_CATCH_EXCEPTION(0);
49120   }
49121
49122   jresult = (unsigned long)result;
49123   return jresult;
49124 }
49125
49126
49127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
49128   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49129   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
49130
49131   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49132   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
49133   {
49134     try {
49135       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
49136     } CALL_CATCH_EXCEPTION();
49137   }
49138
49139 }
49140
49141
49142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
49143   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49144   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
49145
49146   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49147   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
49148   {
49149     try {
49150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
49151     } CALL_CATCH_EXCEPTION();
49152   }
49153
49154 }
49155
49156
49157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
49158   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49159   Dali::Toolkit::GaussianBlurView arg2 ;
49160   Dali::Toolkit::GaussianBlurView *argp2 ;
49161
49162   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49163   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
49164   if (!argp2) {
49165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
49166     return ;
49167   }
49168   arg2 = *argp2;
49169   {
49170     try {
49171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
49172     } CALL_CATCH_EXCEPTION();
49173   }
49174
49175 }
49176
49177
49178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
49179   void * jresult ;
49180   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
49181
49182   {
49183     try {
49184       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
49185     } CALL_CATCH_EXCEPTION(0);
49186   }
49187
49188   jresult = (void *)result;
49189   return jresult;
49190 }
49191
49192
49193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
49194   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
49195
49196   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
49197   {
49198     try {
49199       delete arg1;
49200     } CALL_CATCH_EXCEPTION();
49201   }
49202
49203 }
49204
49205
49206 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
49207   bool jresult ;
49208   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49209   bool result;
49210
49211   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49212   {
49213     try {
49214       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);
49215     } CALL_CATCH_EXCEPTION(0);
49216   }
49217
49218   jresult = result;
49219   return jresult;
49220 }
49221
49222
49223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
49224   unsigned long jresult ;
49225   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49226   std::size_t result;
49227
49228   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49229   {
49230     try {
49231       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);
49232     } CALL_CATCH_EXCEPTION(0);
49233   }
49234
49235   jresult = (unsigned long)result;
49236   return jresult;
49237 }
49238
49239
49240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
49241   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49242   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
49243
49244   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49245   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
49246   {
49247     try {
49248       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
49249     } CALL_CATCH_EXCEPTION();
49250   }
49251
49252 }
49253
49254
49255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
49256   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49257   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
49258
49259   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49260   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
49261   {
49262     try {
49263       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
49264     } CALL_CATCH_EXCEPTION();
49265   }
49266
49267 }
49268
49269
49270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
49271   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49272   Dali::Toolkit::PageTurnView arg2 ;
49273   unsigned int arg3 ;
49274   bool arg4 ;
49275   Dali::Toolkit::PageTurnView *argp2 ;
49276
49277   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49278   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
49279   if (!argp2) {
49280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
49281     return ;
49282   }
49283   arg2 = *argp2;
49284   arg3 = (unsigned int)jarg3;
49285   arg4 = jarg4 ? true : false;
49286   {
49287     try {
49288       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
49289     } CALL_CATCH_EXCEPTION();
49290   }
49291
49292 }
49293
49294
49295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
49296   void * jresult ;
49297   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
49298
49299   {
49300     try {
49301       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
49302     } CALL_CATCH_EXCEPTION(0);
49303   }
49304
49305   jresult = (void *)result;
49306   return jresult;
49307 }
49308
49309
49310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
49311   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
49312
49313   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
49314   {
49315     try {
49316       delete arg1;
49317     } CALL_CATCH_EXCEPTION();
49318   }
49319
49320 }
49321
49322
49323 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
49324   bool jresult ;
49325   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49326   bool result;
49327
49328   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49329   {
49330     try {
49331       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
49332     } CALL_CATCH_EXCEPTION(0);
49333   }
49334
49335   jresult = result;
49336   return jresult;
49337 }
49338
49339
49340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
49341   unsigned long jresult ;
49342   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49343   std::size_t result;
49344
49345   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49346   {
49347     try {
49348       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
49349     } CALL_CATCH_EXCEPTION(0);
49350   }
49351
49352   jresult = (unsigned long)result;
49353   return jresult;
49354 }
49355
49356
49357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
49358   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49359   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
49360
49361   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49362   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
49363   {
49364     try {
49365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
49366     } CALL_CATCH_EXCEPTION();
49367   }
49368 }
49369
49370
49371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
49372   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49373   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
49374
49375   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49376   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
49377   {
49378     try {
49379       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
49380     } CALL_CATCH_EXCEPTION();
49381   }
49382 }
49383
49384
49385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
49386   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49387   Dali::Toolkit::PageTurnView arg2 ;
49388   Dali::Toolkit::PageTurnView *argp2 ;
49389
49390   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49391   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
49392   if (!argp2) {
49393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
49394     return ;
49395   }
49396   arg2 = *argp2;
49397   {
49398     try {
49399       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
49400     } CALL_CATCH_EXCEPTION();
49401   }
49402 }
49403
49404
49405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
49406   void * jresult ;
49407   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
49408
49409   {
49410     try {
49411       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
49412     } CALL_CATCH_EXCEPTION(0);
49413   }
49414
49415   jresult = (void *)result;
49416   return jresult;
49417 }
49418
49419
49420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
49421   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
49422
49423   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
49424   {
49425     try {
49426       delete arg1;
49427     } CALL_CATCH_EXCEPTION();
49428   }
49429
49430 }
49431
49432 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
49433   bool jresult ;
49434   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49435   bool result;
49436
49437   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49438   {
49439     try {
49440       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);
49441     } CALL_CATCH_EXCEPTION(0);
49442   }
49443
49444   jresult = result;
49445   return jresult;
49446 }
49447
49448
49449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
49450   unsigned long jresult ;
49451   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49452   std::size_t result;
49453
49454   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49455   {
49456     try {
49457       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);
49458     } CALL_CATCH_EXCEPTION(0);
49459   }
49460
49461   jresult = (unsigned long)result;
49462   return jresult;
49463 }
49464
49465
49466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
49467   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49468   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
49469
49470   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49471   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
49472   {
49473     try {
49474       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49475     } CALL_CATCH_EXCEPTION();
49476   }
49477
49478 }
49479
49480
49481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
49482   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49483   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
49484
49485   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49486   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
49487   {
49488     try {
49489       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49490     } CALL_CATCH_EXCEPTION();
49491   }
49492
49493 }
49494
49495
49496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
49497   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49498   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
49499
49500   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49501   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
49502   if (!arg2) {
49503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
49504     return ;
49505   }
49506   {
49507     try {
49508       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
49509     } CALL_CATCH_EXCEPTION();
49510   }
49511
49512 }
49513
49514
49515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
49516   void * jresult ;
49517   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
49518
49519   {
49520     try {
49521       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
49522     } CALL_CATCH_EXCEPTION(0);
49523   }
49524
49525   jresult = (void *)result;
49526   return jresult;
49527 }
49528
49529
49530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
49531   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
49532
49533   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
49534   {
49535     try {
49536       delete arg1;
49537     } CALL_CATCH_EXCEPTION();
49538   }
49539
49540 }
49541
49542
49543 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
49544   bool jresult ;
49545   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49546   bool result;
49547
49548   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49549   {
49550     try {
49551       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
49552     } CALL_CATCH_EXCEPTION(0);
49553   }
49554
49555   jresult = result;
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
49561   unsigned long jresult ;
49562   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49563   std::size_t result;
49564
49565   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49566   {
49567     try {
49568       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
49569     } CALL_CATCH_EXCEPTION(0);
49570   }
49571
49572   jresult = (unsigned long)result;
49573   return jresult;
49574 }
49575
49576
49577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
49578   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49579   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
49580
49581   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49582   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
49583   {
49584     try {
49585       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49586     } CALL_CATCH_EXCEPTION();
49587   }
49588
49589 }
49590
49591
49592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
49593   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49594   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
49595
49596   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49597   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
49598   {
49599     try {
49600       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49601     } CALL_CATCH_EXCEPTION();
49602   }
49603
49604 }
49605
49606
49607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
49608   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49609   Dali::Vector2 *arg2 = 0 ;
49610
49611   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49612   arg2 = (Dali::Vector2 *)jarg2;
49613   if (!arg2) {
49614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
49615     return ;
49616   }
49617   {
49618     try {
49619       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
49620     } CALL_CATCH_EXCEPTION();
49621   }
49622
49623 }
49624
49625
49626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
49627   void * jresult ;
49628   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
49629
49630   {
49631     try {
49632       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
49633     } CALL_CATCH_EXCEPTION(0);
49634   }
49635
49636   jresult = (void *)result;
49637   return jresult;
49638 }
49639
49640
49641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
49642   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
49643
49644   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
49645   {
49646     try {
49647       delete arg1;
49648     } CALL_CATCH_EXCEPTION();
49649   }
49650
49651 }
49652
49653 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
49654   bool jresult ;
49655   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49656   bool result;
49657
49658   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49659   {
49660     try {
49661       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
49662     } CALL_CATCH_EXCEPTION(0);
49663   }
49664
49665   jresult = result;
49666   return jresult;
49667 }
49668
49669
49670 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
49671   unsigned long jresult ;
49672   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49673   std::size_t result;
49674
49675   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49676   {
49677     try {
49678       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
49679     } CALL_CATCH_EXCEPTION(0);
49680   }
49681
49682   jresult = (unsigned long)result;
49683   return jresult;
49684 }
49685
49686
49687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
49688   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49689   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
49690
49691   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49692   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
49693   {
49694     try {
49695       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
49696     } CALL_CATCH_EXCEPTION();
49697   }
49698
49699 }
49700
49701
49702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
49703   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49704   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
49705
49706   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49707   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
49708   {
49709     try {
49710       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
49711     } CALL_CATCH_EXCEPTION();
49712   }
49713
49714 }
49715
49716
49717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
49718   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49719   Dali::Toolkit::VideoView *arg2 = 0 ;
49720
49721   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49722   arg2 = (Dali::Toolkit::VideoView *)jarg2;
49723   if (!arg2) {
49724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
49725     return ;
49726   }
49727   {
49728     try {
49729       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
49730     } CALL_CATCH_EXCEPTION();
49731   }
49732
49733 }
49734
49735
49736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
49737   void * jresult ;
49738   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
49739
49740   {
49741     try {
49742       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
49743     } CALL_CATCH_EXCEPTION(0);
49744   }
49745
49746   jresult = (void *)result;
49747   return jresult;
49748 }
49749
49750
49751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
49752   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
49753
49754   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
49755   {
49756     try {
49757       delete arg1;
49758     } CALL_CATCH_EXCEPTION();
49759   }
49760
49761 }
49762
49763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
49764   void * jresult ;
49765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
49766
49767   {
49768     try {
49769       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
49770     } CALL_CATCH_EXCEPTION(0);
49771   }
49772
49773   jresult = (void *)result;
49774   return jresult;
49775 }
49776
49777
49778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
49779   void * jresult ;
49780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
49781   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
49782
49783   arg1 = (Dali::Toolkit::Ruler *)jarg1;
49784   {
49785     try {
49786       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
49787     } CALL_CATCH_EXCEPTION(0);
49788   }
49789
49790   jresult = (void *)result;
49791   return jresult;
49792 }
49793
49794
49795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
49796   void * jresult ;
49797   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
49798   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
49799
49800   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49801   if (!arg1) {
49802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
49803     return 0;
49804   }
49805   {
49806     try {
49807       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
49808     } CALL_CATCH_EXCEPTION(0);
49809   }
49810
49811   jresult = (void *)result;
49812   return jresult;
49813 }
49814
49815
49816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
49817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49818
49819   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49820   {
49821     try {
49822       delete arg1;
49823     } CALL_CATCH_EXCEPTION();
49824   }
49825
49826 }
49827
49828
49829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
49830   void * jresult ;
49831   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49832   Dali::Toolkit::Ruler *result = 0 ;
49833
49834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49835   {
49836     try {
49837       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
49838     } CALL_CATCH_EXCEPTION(0);
49839   }
49840
49841   jresult = (void *)result;
49842   return jresult;
49843 }
49844
49845
49846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
49847   void * jresult ;
49848   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49849   Dali::Toolkit::Ruler *result = 0 ;
49850
49851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49852   {
49853     try {
49854       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
49855     } CALL_CATCH_EXCEPTION(0);
49856   }
49857
49858   jresult = (void *)result;
49859   return jresult;
49860 }
49861
49862
49863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
49864   void * jresult ;
49865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49866   Dali::Toolkit::Ruler *result = 0 ;
49867
49868   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49869   {
49870     try {
49871       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
49872     } CALL_CATCH_EXCEPTION(0);
49873   }
49874
49875   jresult = (void *)result;
49876   return jresult;
49877 }
49878
49879
49880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
49881   void * jresult ;
49882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49883   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
49884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
49885
49886   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49887   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
49888   if (!arg2) {
49889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
49890     return 0;
49891   }
49892   {
49893     try {
49894       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
49895     } CALL_CATCH_EXCEPTION(0);
49896   }
49897
49898   jresult = (void *)result;
49899   return jresult;
49900 }
49901
49902
49903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
49904   void * jresult ;
49905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49906   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
49907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
49908
49909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49910   arg2 = (Dali::Toolkit::Ruler *)jarg2;
49911   {
49912     try {
49913       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
49914     } CALL_CATCH_EXCEPTION(0);
49915   }
49916
49917   jresult = (void *)result;
49918   return jresult;
49919 }
49920
49921
49922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
49923   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49924
49925   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49926   {
49927     try {
49928       (arg1)->Reset();
49929     } CALL_CATCH_EXCEPTION();
49930   }
49931
49932 }
49933
49934
49935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
49936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49937   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
49938
49939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49940   arg2 = (Dali::Toolkit::Ruler *)jarg2;
49941   {
49942     try {
49943       (arg1)->Reset(arg2);
49944     } CALL_CATCH_EXCEPTION();
49945   }
49946
49947 }
49948
49949
49950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
49951   void * jresult ;
49952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49953   Dali::Toolkit::Ruler *result = 0 ;
49954
49955   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49956   {
49957     try {
49958       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
49959     } CALL_CATCH_EXCEPTION(0);
49960   }
49961
49962   jresult = (void *)result;
49963   return jresult;
49964 }
49965
49966
49967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
49968   float jresult ;
49969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49970   float arg2 ;
49971   float arg3 ;
49972   float result;
49973
49974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49975   arg2 = (float)jarg2;
49976   arg3 = (float)jarg3;
49977   {
49978     try {
49979       result = (float)(*arg1)->Snap(arg2,arg3);
49980     } CALL_CATCH_EXCEPTION(0);
49981   }
49982
49983   jresult = result;
49984   return jresult;
49985 }
49986
49987
49988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
49989   float jresult ;
49990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
49991   float arg2 ;
49992   float result;
49993
49994   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
49995   arg2 = (float)jarg2;
49996   {
49997     try {
49998       result = (float)(*arg1)->Snap(arg2);
49999     } CALL_CATCH_EXCEPTION(0);
50000   }
50001
50002   jresult = result;
50003   return jresult;
50004 }
50005
50006
50007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
50008   float jresult ;
50009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50010   unsigned int arg2 ;
50011   unsigned int *arg3 = 0 ;
50012   bool arg4 ;
50013   float result;
50014
50015   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50016   arg2 = (unsigned int)jarg2;
50017   arg3 = (unsigned int *)jarg3;
50018   arg4 = jarg4 ? true : false;
50019   {
50020     try {
50021       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
50022     } CALL_CATCH_EXCEPTION(0);
50023   }
50024
50025   jresult = result;
50026   return jresult;
50027 }
50028
50029
50030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
50031   unsigned int jresult ;
50032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50033   float arg2 ;
50034   bool arg3 ;
50035   unsigned int result;
50036
50037   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50038   arg2 = (float)jarg2;
50039   arg3 = jarg3 ? true : false;
50040   {
50041     try {
50042       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
50043     } CALL_CATCH_EXCEPTION(0);
50044   }
50045
50046   jresult = result;
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
50052   unsigned int jresult ;
50053   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50054   unsigned int result;
50055
50056   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50057   {
50058     try {
50059       result = (unsigned int)(*arg1)->GetTotalPages();
50060     } CALL_CATCH_EXCEPTION(0);
50061   }
50062
50063   jresult = result;
50064   return jresult;
50065 }
50066
50067
50068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
50069   int jresult ;
50070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50071   Dali::Toolkit::Ruler::RulerType result;
50072
50073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50074   {
50075     try {
50076       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
50077     } CALL_CATCH_EXCEPTION(0);
50078   }
50079
50080   jresult = (int)result;
50081   return jresult;
50082 }
50083
50084
50085 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
50086   bool jresult ;
50087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50088   bool result;
50089
50090   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50091   {
50092     try {
50093       result = (bool)(*arg1)->IsEnabled();
50094     } CALL_CATCH_EXCEPTION(0);
50095   }
50096
50097   jresult = result;
50098   return jresult;
50099 }
50100
50101
50102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
50103   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50104
50105   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50106   {
50107     try {
50108       (*arg1)->Enable();
50109     } CALL_CATCH_EXCEPTION();
50110   }
50111
50112 }
50113
50114
50115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
50116   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50117
50118   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50119   {
50120     try {
50121       (*arg1)->Disable();
50122     } CALL_CATCH_EXCEPTION();
50123   }
50124
50125 }
50126
50127
50128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
50129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50130   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
50131   Dali::Toolkit::RulerDomain *argp2 ;
50132
50133   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50134   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
50135   if (!argp2) {
50136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
50137     return ;
50138   }
50139   arg2 = *argp2;
50140   {
50141     try {
50142       (*arg1)->SetDomain(arg2);
50143     } CALL_CATCH_EXCEPTION();
50144   }
50145
50146 }
50147
50148
50149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
50150   void * jresult ;
50151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50152   Dali::Toolkit::RulerDomain *result = 0 ;
50153
50154   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50155   {
50156     try {
50157       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
50158     } CALL_CATCH_EXCEPTION(0);
50159   }
50160
50161   jresult = (void *)result;
50162   return jresult;
50163 }
50164
50165
50166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
50167   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50168
50169   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50170   {
50171     try {
50172       (*arg1)->DisableDomain();
50173     } CALL_CATCH_EXCEPTION();
50174   }
50175
50176 }
50177
50178
50179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
50180   float jresult ;
50181   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50182   float arg2 ;
50183   float arg3 ;
50184   float arg4 ;
50185   float result;
50186
50187   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50188   arg2 = (float)jarg2;
50189   arg3 = (float)jarg3;
50190   arg4 = (float)jarg4;
50191   {
50192     try {
50193       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
50194     } CALL_CATCH_EXCEPTION(0);
50195   }
50196
50197   jresult = result;
50198   return jresult;
50199 }
50200
50201
50202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
50203   float jresult ;
50204   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50205   float arg2 ;
50206   float arg3 ;
50207   float result;
50208
50209   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50210   arg2 = (float)jarg2;
50211   arg3 = (float)jarg3;
50212   {
50213     try {
50214       result = (float)(*arg1)->Clamp(arg2,arg3);
50215     } CALL_CATCH_EXCEPTION(0);
50216   }
50217
50218   jresult = result;
50219   return jresult;
50220 }
50221
50222
50223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
50224   float jresult ;
50225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50226   float arg2 ;
50227   float result;
50228
50229   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50230   arg2 = (float)jarg2;
50231   {
50232     try {
50233       result = (float)(*arg1)->Clamp(arg2);
50234     } CALL_CATCH_EXCEPTION(0);
50235   }
50236
50237   jresult = result;
50238   return jresult;
50239 }
50240
50241
50242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
50243   float jresult ;
50244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50245   float arg2 ;
50246   float arg3 ;
50247   float arg4 ;
50248   Dali::Toolkit::ClampState *arg5 = 0 ;
50249   float result;
50250
50251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50252   arg2 = (float)jarg2;
50253   arg3 = (float)jarg3;
50254   arg4 = (float)jarg4;
50255   arg5 = (Dali::Toolkit::ClampState *)jarg5;
50256   if (!arg5) {
50257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
50258     return 0;
50259   }
50260   {
50261     try {
50262       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
50263     } CALL_CATCH_EXCEPTION(0);
50264   }
50265
50266   jresult = result;
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50272   float jresult ;
50273   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50274   float arg2 ;
50275   float arg3 ;
50276   float arg4 ;
50277   float arg5 ;
50278   float result;
50279
50280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50281   arg2 = (float)jarg2;
50282   arg3 = (float)jarg3;
50283   arg4 = (float)jarg4;
50284   arg5 = (float)jarg5;
50285   {
50286     try {
50287       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
50288     } CALL_CATCH_EXCEPTION(0);
50289   }
50290
50291   jresult = result;
50292   return jresult;
50293 }
50294
50295
50296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
50297   float jresult ;
50298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50299   float arg2 ;
50300   float arg3 ;
50301   float arg4 ;
50302   float result;
50303
50304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50305   arg2 = (float)jarg2;
50306   arg3 = (float)jarg3;
50307   arg4 = (float)jarg4;
50308   {
50309     try {
50310       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
50311     } CALL_CATCH_EXCEPTION(0);
50312   }
50313
50314   jresult = result;
50315   return jresult;
50316 }
50317
50318
50319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
50320   float jresult ;
50321   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50322   float arg2 ;
50323   float arg3 ;
50324   float result;
50325
50326   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50327   arg2 = (float)jarg2;
50328   arg3 = (float)jarg3;
50329   {
50330     try {
50331       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
50332     } CALL_CATCH_EXCEPTION(0);
50333   }
50334
50335   jresult = result;
50336   return jresult;
50337 }
50338
50339
50340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
50341   float jresult ;
50342   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50343   float arg2 ;
50344   float result;
50345
50346   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50347   arg2 = (float)jarg2;
50348   {
50349     try {
50350       result = (float)(*arg1)->SnapAndClamp(arg2);
50351     } CALL_CATCH_EXCEPTION(0);
50352   }
50353
50354   jresult = result;
50355   return jresult;
50356 }
50357
50358
50359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
50360   float jresult ;
50361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50362   float arg2 ;
50363   float arg3 ;
50364   float arg4 ;
50365   float arg5 ;
50366   Dali::Toolkit::ClampState *arg6 = 0 ;
50367   float result;
50368
50369   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50370   arg2 = (float)jarg2;
50371   arg3 = (float)jarg3;
50372   arg4 = (float)jarg4;
50373   arg5 = (float)jarg5;
50374   arg6 = (Dali::Toolkit::ClampState *)jarg6;
50375   if (!arg6) {
50376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
50377     return 0;
50378   }
50379   {
50380     try {
50381       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
50382     } CALL_CATCH_EXCEPTION(0);
50383   }
50384
50385   jresult = result;
50386   return jresult;
50387 }
50388
50389
50390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
50391   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50392
50393   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50394   {
50395     try {
50396       (*arg1)->Reference();
50397     } CALL_CATCH_EXCEPTION();
50398   }
50399
50400 }
50401
50402
50403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
50404   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50405
50406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50407   {
50408     try {
50409       (*arg1)->Unreference();
50410     } CALL_CATCH_EXCEPTION();
50411   }
50412
50413 }
50414
50415
50416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
50417   int jresult ;
50418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
50419   int result;
50420
50421   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
50422   {
50423     try {
50424       result = (int)(*arg1)->ReferenceCount();
50425     } CALL_CATCH_EXCEPTION(0);
50426   }
50427
50428   jresult = result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
50434   bool jresult ;
50435   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50436   bool result;
50437
50438   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50439   {
50440     try {
50441       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
50442     } CALL_CATCH_EXCEPTION(0);
50443   }
50444
50445   jresult = result;
50446   return jresult;
50447 }
50448
50449
50450 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
50451   unsigned long jresult ;
50452   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50453   std::size_t result;
50454
50455   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50456   {
50457     try {
50458       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
50459     } CALL_CATCH_EXCEPTION(0);
50460   }
50461
50462   jresult = (unsigned long)result;
50463   return jresult;
50464 }
50465
50466
50467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
50468   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50469   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
50470
50471   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50472   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
50473   {
50474     try {
50475       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
50476     } CALL_CATCH_EXCEPTION();
50477   }
50478
50479 }
50480
50481
50482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
50483   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50484   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
50485
50486   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50487   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
50488   {
50489     try {
50490       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
50491     } CALL_CATCH_EXCEPTION();
50492   }
50493
50494 }
50495
50496
50497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
50498   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50499   Dali::Toolkit::Control arg2 ;
50500   Dali::Toolkit::Control *argp2 ;
50501
50502   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50503   argp2 = (Dali::Toolkit::Control *)jarg2;
50504   if (!argp2) {
50505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
50506     return ;
50507   }
50508   arg2 = *argp2;
50509   {
50510     try {
50511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
50512     } CALL_CATCH_EXCEPTION();
50513   }
50514
50515 }
50516
50517
50518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
50519   void * jresult ;
50520   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
50521
50522   {
50523     try {
50524       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
50525     } CALL_CATCH_EXCEPTION(0);
50526   }
50527
50528   jresult = (void *)result;
50529   return jresult;
50530 }
50531
50532
50533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
50534   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
50535
50536   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
50537   {
50538     try {
50539       delete arg1;
50540     } CALL_CATCH_EXCEPTION();
50541   }
50542
50543 }
50544
50545 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
50546   Dali::RefObject *result = NULL;
50547
50548   if (arg1)
50549   {
50550     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
50551   }
50552   return result;
50553 }
50554
50555 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
50556     return (Dali::RefObject *)jarg1;
50557 }
50558
50559 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
50560     return (Dali::SignalObserver *)jarg1;
50561 }
50562
50563 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
50564     return (Dali::ConnectionTrackerInterface *)jarg1;
50565 }
50566
50567 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
50568     return (Dali::BaseHandle *)jarg1;
50569 }
50570
50571 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
50572     return (Dali::BaseHandle *)jarg1;
50573 }
50574
50575 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
50576     return (Dali::BaseHandle *)jarg1;
50577 }
50578
50579 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
50580     return (Dali::BaseHandle *)jarg1;
50581 }
50582
50583 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
50584     return (Dali::BaseHandle *)jarg1;
50585 }
50586
50587 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
50588     return (Dali::BaseHandle *)jarg1;
50589 }
50590
50591 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
50592     return (Dali::BaseHandle *)jarg1;
50593 }
50594
50595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
50596     return (Dali::BaseHandle *)jarg1;
50597 }
50598
50599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
50600     return (Dali::BaseHandle *)jarg1;
50601 }
50602
50603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
50604     return (Dali::BaseHandle *)jarg1;
50605 }
50606
50607 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
50608     return (Dali::BaseHandle *)jarg1;
50609 }
50610
50611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
50612     return (Dali::BaseHandle *)jarg1;
50613 }
50614
50615 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
50616     return (Dali::Handle *)jarg1;
50617 }
50618
50619 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
50620     return (Dali::Handle *)jarg1;
50621 }
50622
50623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
50624     return (Dali::BaseHandle *)jarg1;
50625 }
50626
50627 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
50628     return (Dali::BaseHandle *)jarg1;
50629 }
50630
50631 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
50632     return (Dali::Handle *)jarg1;
50633 }
50634
50635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
50636     return (Dali::BaseHandle *)jarg1;
50637 }
50638
50639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
50640     return (Dali::BaseHandle *)jarg1;
50641 }
50642
50643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
50644     return (Dali::BaseHandle *)jarg1;
50645 }
50646
50647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
50648     return (Dali::BaseHandle *)jarg1;
50649 }
50650
50651 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
50652     return (Dali::BaseHandle *)jarg1;
50653 }
50654
50655 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
50656     return (Dali::Handle *)jarg1;
50657 }
50658
50659 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
50660     return (Dali::GestureDetector *)jarg1;
50661 }
50662
50663 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
50664     return (Dali::Gesture *)jarg1;
50665 }
50666
50667
50668 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
50669     return (Dali::RefObject *)jarg1;
50670 }
50671
50672 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
50673     return (Dali::Actor *)jarg1;
50674 }
50675
50676 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
50677     return (Dali::GestureDetector *)jarg1;
50678 }
50679
50680 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
50681     return (Dali::Gesture *)jarg1;
50682 }
50683
50684 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
50685     return (Dali::GestureDetector *)jarg1;
50686 }
50687
50688 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
50689     return (Dali::Gesture *)jarg1;
50690 }
50691
50692 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
50693     return (Dali::GestureDetector *)jarg1;
50694 }
50695
50696 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
50697     return (Dali::Gesture *)jarg1;
50698 }
50699
50700 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
50701     return (Dali::BaseHandle *)jarg1;
50702 }
50703
50704 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
50705     return (Dali::Handle *)jarg1;
50706 }
50707
50708 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
50709     return (Dali::Handle *)jarg1;
50710 }
50711
50712 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
50713     return (Dali::Handle *)jarg1;
50714 }
50715
50716 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
50717     return (Dali::RefObject *)jarg1;
50718 }
50719
50720 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
50721     return (Dali::Actor *)jarg1;
50722 }
50723
50724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
50725     return (Dali::BaseHandle *)jarg1;
50726 }
50727
50728 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
50729     return (Dali::BaseHandle *)jarg1;
50730 }
50731
50732 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
50733     return (Dali::BaseHandle *)jarg1;
50734 }
50735
50736 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
50737     return (Dali::CustomActorImpl *)jarg1;
50738 }
50739
50740 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
50741     return (Dali::CustomActor *)jarg1;
50742 }
50743
50744 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
50745     return (Dali::BaseHandle *)jarg1;
50746 }
50747
50748 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
50749     return (Dali::Toolkit::Control *)jarg1;
50750 }
50751
50752 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
50753     return (Dali::Toolkit::Control *)jarg1;
50754 }
50755
50756 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
50757     return (Dali::Toolkit::Control *)jarg1;
50758 }
50759
50760 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
50761     return (Dali::Toolkit::Control *)jarg1;
50762 }
50763
50764 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
50765     return (Dali::Toolkit::Control *)jarg1;
50766 }
50767
50768 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
50769     return (Dali::Toolkit::Control *)jarg1;
50770 }
50771
50772 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
50773     return (Dali::RefObject *)jarg1;
50774 }
50775
50776 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
50777     return (Dali::Toolkit::Scrollable *)jarg1;
50778 }
50779
50780 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
50781     return (Dali::BaseHandle *)jarg1;
50782 }
50783
50784 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
50785     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
50786 }
50787
50788 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
50789     return (Dali::RefObject *)jarg1;
50790 }
50791
50792 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
50793     return (Dali::Toolkit::Ruler *)jarg1;
50794 }
50795
50796 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
50797     return (Dali::Toolkit::Ruler *)jarg1;
50798 }
50799
50800 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
50801     return (Dali::Toolkit::Scrollable *)jarg1;
50802 }
50803
50804 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
50805     return (Dali::Toolkit::Control *)jarg1;
50806 }
50807
50808
50809 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
50810     return (Dali::Toolkit::Control *)jarg1;
50811 }
50812
50813 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
50814     return (Dali::BaseHandle *)jarg1;
50815 }
50816
50817 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
50818     return (Dali::BaseHandle *)jarg1;
50819 }
50820
50821 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
50822     return (Dali::Toolkit::Control *)jarg1;
50823 }
50824
50825 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
50826     return (Dali::Toolkit::Control *)jarg1;
50827 }
50828
50829 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
50830     return (Dali::Toolkit::Control *)jarg1;
50831 }
50832
50833 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
50834     return (Dali::Toolkit::Control *)jarg1;
50835 }
50836
50837 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
50838     return (Dali::Toolkit::PageTurnView *)jarg1;
50839 }
50840
50841 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
50842     return (Dali::Toolkit::PageTurnView *)jarg1;
50843 }
50844
50845 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
50846     return (Dali::BaseHandle *)jarg1;
50847 }
50848
50849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
50850     return (Dali::BaseHandle *)jarg1;
50851 }
50852
50853 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
50854     return (Dali::BaseHandle *)jarg1;
50855 }
50856
50857 /*
50858  * Widget binding
50859  */
50860 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
50861     return (Dali::BaseHandle *)jarg1;
50862 }
50863
50864 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
50865     return (Dali::BaseObject *)jarg1;
50866 }
50867
50868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
50869   void * jresult ;
50870   Dali::Widget result;
50871
50872   {
50873     try {
50874       result = Dali::Widget::New();
50875     } CALL_CATCH_EXCEPTION(0);
50876   }
50877
50878   jresult = new Dali::Widget((const Dali::Widget &)result);
50879   return jresult;
50880 }
50881
50882
50883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
50884   void * jresult ;
50885   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
50886   Dali::Widget result;
50887
50888   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
50889
50890   if (!arg1) {
50891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
50892     return 0;
50893   }
50894   {
50895     try {
50896       jresult = new Dali::Widget(arg1);
50897     } CALL_CATCH_EXCEPTION(0);
50898   }
50899   return jresult;
50900 }
50901
50902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
50903   void * jresult ;
50904   Dali::Widget *result = 0 ;
50905
50906   {
50907     try {
50908       result = (Dali::Widget *)new Dali::Widget();
50909     } CALL_CATCH_EXCEPTION(0);
50910   }
50911   jresult = (void *)result;
50912   return jresult;
50913 }
50914
50915
50916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
50917   void * jresult ;
50918   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
50919   Dali::Widget *arg2 = 0 ;
50920   Dali::Widget *result = 0 ;
50921
50922   arg1 = (Dali::Widget *)jarg1;
50923   arg2 = (Dali::Widget *)jarg2;
50924   if (!arg2) {
50925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
50926     return 0;
50927   }
50928   {
50929     try {
50930       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
50931     } CALL_CATCH_EXCEPTION(0);
50932   }
50933   jresult = (void *)result;
50934   return jresult;
50935 }
50936
50937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
50938   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
50939
50940   arg1 = (Dali::Widget *)jarg1;
50941   {
50942     try {
50943       delete arg1;
50944     } CALL_CATCH_EXCEPTION();
50945   }
50946 }
50947
50948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
50949   void * jresult ;
50950   SwigDirector_WidgetImpl* result;
50951   {
50952     try {
50953       result = new SwigDirector_WidgetImpl();
50954     } CALL_CATCH_EXCEPTION(0);
50955   }
50956   jresult = result;
50957   return jresult;
50958 }
50959
50960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
50961   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
50962   std::string *arg2 = 0 ;
50963   Dali::Window arg3 ;
50964   Dali::Window *argp3 ;
50965
50966   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
50967   if (!jarg2) {
50968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50969     return ;
50970   }
50971   std::string arg2_str(jarg2);
50972   arg2 = &arg2_str;
50973   argp3 = (Dali::Window *)jarg3;
50974   if (!argp3) {
50975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
50976     return ;
50977   }
50978   arg3 = *argp3;
50979   {
50980     try {
50981       (arg1)->OnCreate((std::string const &)*arg2,arg3);
50982     } CALL_CATCH_EXCEPTION();
50983   }
50984 }
50985
50986
50987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
50988   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
50989   std::string *arg2 = 0 ;
50990   Dali::Window arg3 ;
50991   Dali::Window *argp3 ;
50992
50993   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
50994   if (!jarg2) {
50995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
50996     return ;
50997   }
50998   std::string arg2_str(jarg2);
50999   arg2 = &arg2_str;
51000   argp3 = (Dali::Window *)jarg3;
51001   if (!argp3) {
51002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
51003     return ;
51004   }
51005   arg3 = *argp3;
51006   {
51007     try {
51008       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
51009     } CALL_CATCH_EXCEPTION();
51010   }
51011 }
51012
51013
51014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
51015   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51016   std::string *arg2 = 0 ;
51017   Dali::Widget::Termination arg3 ;
51018
51019   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51020   if (!jarg2) {
51021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51022     return ;
51023   }
51024   std::string arg2_str(jarg2);
51025   arg2 = &arg2_str;
51026   arg3 = (Dali::Widget::Termination)jarg3;
51027   {
51028     try {
51029       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
51030     } CALL_CATCH_EXCEPTION();
51031   }
51032 }
51033
51034
51035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
51036   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51037   std::string *arg2 = 0 ;
51038   Dali::Widget::Termination arg3 ;
51039
51040   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51041   if (!jarg2) {
51042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51043     return ;
51044   }
51045   std::string arg2_str(jarg2);
51046   arg2 = &arg2_str;
51047   arg3 = (Dali::Widget::Termination)jarg3;
51048   {
51049     try {
51050       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
51051     } CALL_CATCH_EXCEPTION();
51052   }
51053 }
51054
51055
51056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
51057   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51058
51059   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51060   {
51061     try {
51062       (arg1)->OnPause();
51063     } CALL_CATCH_EXCEPTION();
51064   }
51065 }
51066
51067
51068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
51069   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51070
51071   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51072   {
51073     try {
51074       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
51075     } CALL_CATCH_EXCEPTION();
51076   }
51077 }
51078
51079
51080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
51081   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51082
51083   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51084   {
51085     try {
51086       (arg1)->OnResume();
51087     } CALL_CATCH_EXCEPTION();
51088   }
51089 }
51090
51091
51092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
51093   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51094
51095   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51096   {
51097     try {
51098       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
51099     } CALL_CATCH_EXCEPTION();
51100   }
51101 }
51102
51103
51104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
51105   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51106   Dali::Window arg2 ;
51107   Dali::Window *argp2 ;
51108
51109   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51110   argp2 = (Dali::Window *)jarg2;
51111   if (!argp2) {
51112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
51113     return ;
51114   }
51115   arg2 = *argp2;
51116   {
51117     try {
51118       (arg1)->OnResize(arg2);
51119     } CALL_CATCH_EXCEPTION();
51120   }
51121 }
51122
51123
51124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
51125   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51126   Dali::Window arg2 ;
51127   Dali::Window *argp2 ;
51128
51129   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51130   argp2 = (Dali::Window *)jarg2;
51131   if (!argp2) {
51132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
51133     return ;
51134   }
51135   arg2 = *argp2;
51136   {
51137     try {
51138       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
51139     } CALL_CATCH_EXCEPTION();
51140   }
51141 }
51142
51143
51144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
51145   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51146   std::string *arg2 = 0 ;
51147   int arg3 ;
51148
51149   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51150   if (!jarg2) {
51151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51152     return ;
51153   }
51154   std::string arg2_str(jarg2);
51155   arg2 = &arg2_str;
51156   arg3 = (int)jarg3;
51157   {
51158     try {
51159       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
51160     } CALL_CATCH_EXCEPTION();
51161   }
51162 }
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
51165   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51166   std::string *arg2 = 0 ;
51167   int arg3 ;
51168
51169   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51170   if (!jarg2) {
51171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51172     return ;
51173   }
51174   std::string arg2_str(jarg2);
51175   arg2 = &arg2_str;
51176   arg3 = (int)jarg3;
51177   {
51178     try {
51179       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
51180     } CALL_CATCH_EXCEPTION();
51181   }
51182 }
51183
51184
51185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
51186   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51187   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
51188   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
51189
51190   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51191   arg2 = (Dali::SlotObserver *)jarg2;
51192   arg3 = (Dali::CallbackBase *)jarg3;
51193   {
51194     try {
51195       (arg1)->SignalConnected(arg2,arg3);
51196     } CALL_CATCH_EXCEPTION();
51197   }
51198 }
51199
51200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
51201   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51202   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
51203   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
51204
51205   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51206   arg2 = (Dali::SlotObserver *)jarg2;
51207   arg3 = (Dali::CallbackBase *)jarg3;
51208   {
51209     try {
51210       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
51211     } CALL_CATCH_EXCEPTION();
51212   }
51213 }
51214
51215
51216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
51217   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51218   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
51219   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
51220
51221   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51222   arg2 = (Dali::SlotObserver *)jarg2;
51223   arg3 = (Dali::CallbackBase *)jarg3;
51224   {
51225     try {
51226       (arg1)->SignalDisconnected(arg2,arg3);
51227     } CALL_CATCH_EXCEPTION();
51228   }
51229 }
51230
51231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
51232   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51233   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
51234   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
51235
51236   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51237   arg2 = (Dali::SlotObserver *)jarg2;
51238   arg3 = (Dali::CallbackBase *)jarg3;
51239   {
51240     try {
51241       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
51242     } CALL_CATCH_EXCEPTION();
51243   }
51244 }
51245
51246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
51247   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51248   std::string *arg2 = 0 ;
51249
51250   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51251   if (!jarg2) {
51252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51253     return ;
51254   }
51255   std::string arg2_str(jarg2);
51256   arg2 = &arg2_str;
51257   {
51258     try {
51259       (arg1)->SetContentInfo((std::string const &)*arg2);
51260     } CALL_CATCH_EXCEPTION();
51261   }
51262 }
51263
51264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
51265   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
51266   bool flag;
51267
51268   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
51269   flag = jflag ? true : false;
51270   {
51271     try {
51272       (widget)->SetUsingKeyEvent(flag);
51273     } CALL_CATCH_EXCEPTION();
51274   }
51275 }
51276
51277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
51278   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
51279   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
51280
51281   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
51282   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
51283   {
51284     try {
51285       (arg1)->SetImpl(arg2);
51286     } CALL_CATCH_EXCEPTION();
51287   }
51288 }
51289
51290
51291 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) {
51292   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
51293   if (director) {
51294     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
51295   }
51296 }
51297
51298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
51299   void * jresult ;
51300   Dali::Widget *arg1 = 0 ;
51301   SwigDirector_WidgetImpl *result = 0 ;
51302
51303   arg1 = (Dali::Widget *)jarg1;
51304   if (!arg1) {
51305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
51306     return 0;
51307   }
51308   {
51309     try {
51310       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
51311     } CALL_CATCH_EXCEPTION(0);
51312   }
51313   jresult = (void*) result;
51314   return jresult;
51315 }
51316
51317
51318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
51319   void * jresult ;
51320   int *arg1 = (int *) 0 ;
51321   char ***arg2 ;
51322   std::string *arg3 = 0 ;
51323   Dali::WidgetApplication result;
51324   {
51325     int index = 0;
51326     int length = 0;
51327     char *retPtr;
51328     char *nextPtr;
51329     argWidgetC = jarg1;
51330     argWidgetV = new char*[jarg1 + 1];
51331
51332     retPtr = strtok_r( jarg2, " ", &nextPtr);
51333     if( retPtr )
51334     {
51335       length = strlen(retPtr);
51336     }
51337     argWidgetV[index] = new char[length + 1];
51338     if( retPtr )
51339     {
51340       strncpy(argWidgetV[index], retPtr, length);
51341     }
51342     argWidgetV[index][length] = '\0';
51343     index++;
51344
51345     while (index < jarg1)
51346     {
51347       length = 0;
51348       retPtr = strtok_r(NULL, " ", &nextPtr);
51349       if( retPtr )
51350       {
51351         length = strlen(retPtr);
51352       }
51353       argWidgetV[index] = new char[length + 1];
51354       if( retPtr )
51355       {
51356         strncpy(argWidgetV[index], retPtr, length);
51357       }
51358       argWidgetV[index][length] = '\0';
51359       index++;
51360     }
51361
51362     argWidgetV[jarg1] = NULL;
51363     argWidgetC = jarg1;
51364
51365     arg1 = &argWidgetC;
51366     arg2 = &argWidgetV;
51367   }
51368
51369   if (!jarg3) {
51370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51371     return 0;
51372   }
51373   std::string arg3_str(jarg3);
51374   arg3 = &arg3_str;
51375   {
51376     try {
51377       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
51378     } CALL_CATCH_EXCEPTION(0);
51379   }
51380   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
51381   return jresult;
51382 }
51383
51384
51385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
51386   void * jresult ;
51387   Dali::WidgetApplication *result = 0 ;
51388
51389   {
51390     try {
51391       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
51392     } CALL_CATCH_EXCEPTION(0);
51393   }
51394   jresult = (void *)result;
51395   return jresult;
51396 }
51397
51398
51399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
51400   void * jresult ;
51401   Dali::WidgetApplication *arg1 = 0 ;
51402   Dali::WidgetApplication *result = 0 ;
51403
51404   arg1 = (Dali::WidgetApplication *)jarg1;
51405   if (!arg1) {
51406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
51407     return 0;
51408   }
51409   {
51410     try {
51411       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
51412     } CALL_CATCH_EXCEPTION(0);
51413   }
51414   jresult = (void *)result;
51415   return jresult;
51416 }
51417
51418
51419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
51420   void * jresult ;
51421   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
51422   Dali::WidgetApplication *arg2 = 0 ;
51423   Dali::WidgetApplication *result = 0 ;
51424
51425   arg1 = (Dali::WidgetApplication *)jarg1;
51426   arg2 = (Dali::WidgetApplication *)jarg2;
51427   if (!arg2) {
51428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
51429     return 0;
51430   }
51431   {
51432     try {
51433       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
51434     } CALL_CATCH_EXCEPTION(0);
51435   }
51436   jresult = (void *)result;
51437   return jresult;
51438 }
51439
51440
51441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
51442   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
51443
51444   arg1 = (Dali::WidgetApplication *)jarg1;
51445   {
51446     try {
51447       delete arg1;
51448       if( argWidgetV )
51449       {
51450         // free string data
51451         for( int i=0; i < argWidgetC+1; i++)
51452         {
51453           delete [] argWidgetV[i];
51454         }
51455         delete [] argWidgetV;
51456       }
51457     } CALL_CATCH_EXCEPTION();
51458   }
51459 }
51460
51461
51462 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
51463 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
51464
51465 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
51466 {
51467   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
51468   return *widget;
51469 }
51470
51471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
51472   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
51473   std::string *arg2 = 0 ;
51474
51475   arg1 = (Dali::WidgetApplication *)jarg1;
51476   if (!jarg2) {
51477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51478     return ;
51479   }
51480   std::string arg2_str(*jarg2);
51481   arg2 = &arg2_str;
51482
51483   if(!_CSharpCreateWidgetFunction)
51484   {
51485     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
51486   }
51487
51488   {
51489     try {
51490       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
51491     } CALL_CATCH_EXCEPTION();
51492   }
51493   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
51494 }
51495
51496
51497 //for PixelBuffer and ImageLoading
51498
51499 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
51500     return (Dali::BaseHandle *)jarg1;
51501 }
51502
51503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
51504   void * jresult ;
51505   unsigned int arg1 ;
51506   unsigned int arg2 ;
51507   Dali::Pixel::Format arg3 ;
51508   Dali::Devel::PixelBuffer result;
51509
51510   arg1 = (unsigned int)jarg1;
51511   arg2 = (unsigned int)jarg2;
51512   arg3 = (Dali::Pixel::Format)jarg3;
51513   {
51514     try {
51515       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
51516     } CALL_CATCH_EXCEPTION(0);
51517   }
51518   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51519   return jresult;
51520 }
51521
51522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
51523   void * jresult ;
51524   Dali::Devel::PixelBuffer *result = 0 ;
51525
51526   {
51527     try {
51528       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
51529     } CALL_CATCH_EXCEPTION(0);
51530   }
51531   jresult = (void *)result;
51532   return jresult;
51533 }
51534
51535
51536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
51537   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51538
51539   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51540   {
51541     try {
51542       delete arg1;
51543     } CALL_CATCH_EXCEPTION();
51544   }
51545 }
51546
51547
51548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
51549   void * jresult ;
51550   Dali::Devel::PixelBuffer *arg1 = 0 ;
51551   Dali::Devel::PixelBuffer *result = 0 ;
51552
51553   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51554   if (!arg1) {
51555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
51556     return 0;
51557   }
51558   {
51559     try {
51560       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
51561     } CALL_CATCH_EXCEPTION(0);
51562   }
51563   jresult = (void *)result;
51564   return jresult;
51565 }
51566
51567
51568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
51569   void * jresult ;
51570   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51571   Dali::Devel::PixelBuffer *arg2 = 0 ;
51572   Dali::Devel::PixelBuffer *result = 0 ;
51573
51574   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51575   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
51576   if (!arg2) {
51577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
51578     return 0;
51579   }
51580   {
51581     try {
51582       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
51583     } CALL_CATCH_EXCEPTION(0);
51584   }
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
51591   void * jresult ;
51592   Dali::Devel::PixelBuffer *arg1 = 0 ;
51593   Dali::PixelData result;
51594
51595   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51596   if (!arg1) {
51597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
51598     return 0;
51599   }
51600   {
51601     try {
51602       result = Dali::Devel::PixelBuffer::Convert(*arg1);
51603     } CALL_CATCH_EXCEPTION(0);
51604   }
51605   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51606   return jresult;
51607 }
51608
51609
51610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
51611   void * jresult ;
51612   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51613   Dali::PixelData result;
51614
51615   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51616   {
51617     try {
51618       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
51619     } CALL_CATCH_EXCEPTION(0);
51620   }
51621   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51622   return jresult;
51623 }
51624
51625
51626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
51627   void * jresult ;
51628   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51629   unsigned char *result = 0 ;
51630
51631   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51632   {
51633     try {
51634       result = (unsigned char *)(arg1)->GetBuffer();
51635     } CALL_CATCH_EXCEPTION(0);
51636   }
51637    jresult = (void *)result;
51638    return jresult;
51639 }
51640
51641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
51642   unsigned int jresult ;
51643   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51644   unsigned int result;
51645
51646   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51647   {
51648     try {
51649       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
51650     } CALL_CATCH_EXCEPTION(0);
51651   }
51652   jresult = result;
51653   return jresult;
51654 }
51655
51656
51657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
51658   unsigned int jresult ;
51659   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51660   unsigned int result;
51661
51662   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51663   {
51664     try {
51665       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
51666     } CALL_CATCH_EXCEPTION(0);
51667   }
51668   jresult = result;
51669   return jresult;
51670 }
51671
51672
51673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
51674   int jresult ;
51675   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51676   Dali::Pixel::Format result;
51677
51678   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51679   {
51680     try {
51681       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
51682     } CALL_CATCH_EXCEPTION(0);
51683   }
51684   jresult = (int)result;
51685   return jresult;
51686 }
51687
51688
51689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
51690   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51691   Dali::Devel::PixelBuffer arg2 ;
51692   float arg3 ;
51693   bool arg4 ;
51694   Dali::Devel::PixelBuffer *argp2 ;
51695
51696   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51697   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
51698   if (!argp2) {
51699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
51700     return ;
51701   }
51702   arg2 = *argp2;
51703   arg3 = (float)jarg3;
51704   arg4 = jarg4 ? true : false;
51705   {
51706     try {
51707       (arg1)->ApplyMask(arg2,arg3,arg4);
51708     } CALL_CATCH_EXCEPTION();
51709   }
51710 }
51711
51712
51713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
51714   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51715   Dali::Devel::PixelBuffer arg2 ;
51716   float arg3 ;
51717   Dali::Devel::PixelBuffer *argp2 ;
51718
51719   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51720   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
51721   if (!argp2) {
51722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
51723     return ;
51724   }
51725   arg2 = *argp2;
51726   arg3 = (float)jarg3;
51727   {
51728     try {
51729       (arg1)->ApplyMask(arg2,arg3);
51730     } CALL_CATCH_EXCEPTION();
51731   }
51732 }
51733
51734
51735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
51736   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51737   Dali::Devel::PixelBuffer arg2 ;
51738   Dali::Devel::PixelBuffer *argp2 ;
51739
51740   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51741   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
51742   if (!argp2) {
51743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
51744     return ;
51745   }
51746   arg2 = *argp2;
51747   {
51748     try {
51749       (arg1)->ApplyMask(arg2);
51750     } CALL_CATCH_EXCEPTION();
51751   }
51752 }
51753
51754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
51755   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51756   float arg2 ;
51757
51758   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51759   arg2 = (float)jarg2;
51760   {
51761     try {
51762       (arg1)->ApplyGaussianBlur(arg2);
51763     } CALL_CATCH_EXCEPTION();
51764   }
51765 }
51766
51767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
51768   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51769   uint16_t arg2 ;
51770   uint16_t arg3 ;
51771   uint16_t arg4 ;
51772   uint16_t arg5 ;
51773
51774   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51775   arg2 = (uint16_t)jarg2;
51776   arg3 = (uint16_t)jarg3;
51777   arg4 = (uint16_t)jarg4;
51778   arg5 = (uint16_t)jarg5;
51779   {
51780     try {
51781       (arg1)->Crop(arg2,arg3,arg4,arg5);
51782     } CALL_CATCH_EXCEPTION();
51783   }
51784 }
51785
51786
51787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
51788   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51789   uint16_t arg2 ;
51790   uint16_t arg3 ;
51791
51792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51793   arg2 = (uint16_t)jarg2;
51794   arg3 = (uint16_t)jarg3;
51795   {
51796     try {
51797       (arg1)->Resize(arg2,arg3);
51798     } CALL_CATCH_EXCEPTION();
51799   }
51800 }
51801
51802 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
51803   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51804   Dali::Degree * arg2 ;
51805
51806   bool result = false;
51807
51808   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51809   arg2 = (Dali::Degree *)jarg2;
51810   {
51811     try {
51812       result = (arg1)->Rotate(*arg2);
51813     } CALL_CATCH_EXCEPTION(false);
51814   }
51815   return result;
51816 }
51817
51818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
51819   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
51820   uint32_t result = 0;
51821
51822   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
51823   {
51824     try {
51825       result = (arg1)->GetBrightness();
51826     } CALL_CATCH_EXCEPTION(0);
51827   }
51828   return result;
51829 }
51830
51831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
51832   void * jresult ;
51833   std::string *arg1 = 0 ;
51834   Dali::ImageDimensions arg2 ;
51835   Dali::FittingMode::Type arg3 ;
51836   Dali::SamplingMode::Type arg4 ;
51837   bool arg5 ;
51838   Dali::ImageDimensions *argp2 ;
51839   Dali::Devel::PixelBuffer result;
51840
51841   if (!jarg1) {
51842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51843     return 0;
51844   }
51845   std::string arg1_str(jarg1);
51846   arg1 = &arg1_str;
51847   argp2 = (Dali::ImageDimensions *)jarg2;
51848   if (!argp2) {
51849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51850     return 0;
51851   }
51852   arg2 = *argp2;
51853   arg3 = (Dali::FittingMode::Type)jarg3;
51854   arg4 = (Dali::SamplingMode::Type)jarg4;
51855   arg5 = jarg5 ? true : false;
51856   {
51857     try {
51858       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51859     } CALL_CATCH_EXCEPTION(0);
51860   }
51861   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51862   return jresult;
51863 }
51864
51865
51866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
51867   void * jresult ;
51868   std::string *arg1 = 0 ;
51869   Dali::ImageDimensions arg2 ;
51870   Dali::FittingMode::Type arg3 ;
51871   Dali::SamplingMode::Type arg4 ;
51872   Dali::ImageDimensions *argp2 ;
51873   Dali::Devel::PixelBuffer result;
51874
51875   if (!jarg1) {
51876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51877     return 0;
51878   }
51879   std::string arg1_str(jarg1);
51880   arg1 = &arg1_str;
51881   argp2 = (Dali::ImageDimensions *)jarg2;
51882   if (!argp2) {
51883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51884     return 0;
51885   }
51886   arg2 = *argp2;
51887   arg3 = (Dali::FittingMode::Type)jarg3;
51888   arg4 = (Dali::SamplingMode::Type)jarg4;
51889   {
51890     try {
51891       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
51892     } CALL_CATCH_EXCEPTION(0);
51893   }
51894   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51895   return jresult;
51896 }
51897
51898
51899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
51900   void * jresult ;
51901   std::string *arg1 = 0 ;
51902   Dali::ImageDimensions arg2 ;
51903   Dali::FittingMode::Type arg3 ;
51904   Dali::ImageDimensions *argp2 ;
51905   Dali::Devel::PixelBuffer result;
51906
51907   if (!jarg1) {
51908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51909     return 0;
51910   }
51911   std::string arg1_str(jarg1);
51912   arg1 = &arg1_str;
51913   argp2 = (Dali::ImageDimensions *)jarg2;
51914   if (!argp2) {
51915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51916     return 0;
51917   }
51918   arg2 = *argp2;
51919   arg3 = (Dali::FittingMode::Type)jarg3;
51920   {
51921     try {
51922       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
51923     } CALL_CATCH_EXCEPTION(0);
51924   }
51925   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51926   return jresult;
51927 }
51928
51929
51930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
51931   void * jresult ;
51932   std::string *arg1 = 0 ;
51933   Dali::ImageDimensions arg2 ;
51934   Dali::ImageDimensions *argp2 ;
51935   Dali::Devel::PixelBuffer result;
51936
51937   if (!jarg1) {
51938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51939     return 0;
51940   }
51941   std::string arg1_str(jarg1);
51942   arg1 = &arg1_str;
51943   argp2 = (Dali::ImageDimensions *)jarg2;
51944   if (!argp2) {
51945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51946     return 0;
51947   }
51948   arg2 = *argp2;
51949   {
51950     try {
51951       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
51952     } CALL_CATCH_EXCEPTION(0);
51953   }
51954   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51955   return jresult;
51956 }
51957
51958
51959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
51960   void * jresult ;
51961   std::string *arg1 = 0 ;
51962   Dali::Devel::PixelBuffer result;
51963
51964   if (!jarg1) {
51965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51966     return 0;
51967   }
51968   std::string arg1_str(jarg1);
51969   arg1 = &arg1_str;
51970   {
51971     try {
51972       result = Dali::LoadImageFromFile((std::string const &)*arg1);
51973     } CALL_CATCH_EXCEPTION(0);
51974   }
51975   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
51976   return jresult;
51977 }
51978
51979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
51980   void * jresult ;
51981   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
51982   Dali::ImageDimensions arg2 ;
51983   Dali::FittingMode::Type arg3 ;
51984   Dali::SamplingMode::Type arg4 ;
51985   bool arg5 ;
51986   Dali::ImageDimensions *argp2 ;
51987   Dali::Devel::PixelBuffer result;
51988
51989   if (!jarg1) {
51990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
51991     return 0;
51992   }
51993   arg1 = (Dali::Vector<uint8_t> *)jarg1;
51994   argp2 = (Dali::ImageDimensions *)jarg2;
51995   if (!argp2) {
51996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51997     return 0;
51998   }
51999   arg2 = *argp2;
52000   arg3 = (Dali::FittingMode::Type)jarg3;
52001   arg4 = (Dali::SamplingMode::Type)jarg4;
52002   arg5 = jarg5 ? true : false;
52003   {
52004     try {
52005       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
52006     } CALL_CATCH_EXCEPTION(0);
52007   }
52008   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52009   return jresult;
52010 }
52011
52012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
52013   void * jresult ;
52014   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
52015   Dali::ImageDimensions arg2 ;
52016   Dali::FittingMode::Type arg3 ;
52017   Dali::SamplingMode::Type arg4 ;
52018   Dali::ImageDimensions *argp2 ;
52019   Dali::Devel::PixelBuffer result;
52020
52021   if (!jarg1) {
52022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
52023     return 0;
52024   }
52025   arg1 = (Dali::Vector<uint8_t> *)jarg1;
52026   argp2 = (Dali::ImageDimensions *)jarg2;
52027   if (!argp2) {
52028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52029     return 0;
52030   }
52031   arg2 = *argp2;
52032   arg3 = (Dali::FittingMode::Type)jarg3;
52033   arg4 = (Dali::SamplingMode::Type)jarg4;
52034   {
52035     try {
52036       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
52037     } CALL_CATCH_EXCEPTION(0);
52038   }
52039   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52040   return jresult;
52041 }
52042
52043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
52044   void * jresult ;
52045   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
52046   Dali::ImageDimensions arg2 ;
52047   Dali::FittingMode::Type arg3 ;
52048   Dali::ImageDimensions *argp2 ;
52049   Dali::Devel::PixelBuffer result;
52050
52051   if (!jarg1) {
52052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
52053     return 0;
52054   }
52055   arg1 = (Dali::Vector<uint8_t> *)jarg1;
52056   argp2 = (Dali::ImageDimensions *)jarg2;
52057   if (!argp2) {
52058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52059     return 0;
52060   }
52061   arg2 = *argp2;
52062   arg3 = (Dali::FittingMode::Type)jarg3;
52063   {
52064     try {
52065       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
52066     } CALL_CATCH_EXCEPTION(0);
52067   }
52068   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52069   return jresult;
52070 }
52071
52072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
52073   void * jresult ;
52074   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
52075   Dali::ImageDimensions arg2 ;
52076   Dali::ImageDimensions *argp2 ;
52077   Dali::Devel::PixelBuffer result;
52078
52079   if (!jarg1) {
52080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
52081     return 0;
52082   }
52083   arg1 = (Dali::Vector<uint8_t> *)jarg1;
52084   argp2 = (Dali::ImageDimensions *)jarg2;
52085   if (!argp2) {
52086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52087     return 0;
52088   }
52089   arg2 = *argp2;
52090   {
52091     try {
52092       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
52093     } CALL_CATCH_EXCEPTION(0);
52094   }
52095   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52096   return jresult;
52097 }
52098
52099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
52100   void * jresult ;
52101   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
52102   Dali::Devel::PixelBuffer result;
52103
52104   if (!jarg1) {
52105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
52106     return 0;
52107   }
52108   arg1 = (Dali::Vector<uint8_t> *)jarg1;
52109   {
52110     try {
52111       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
52112     } CALL_CATCH_EXCEPTION(0);
52113   }
52114   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52115   return jresult;
52116 }
52117
52118
52119
52120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
52121   void * jresult ;
52122   std::string *arg1 = 0 ;
52123   Dali::ImageDimensions arg2 ;
52124   Dali::FittingMode::Type arg3 ;
52125   Dali::SamplingMode::Type arg4 ;
52126   bool arg5 ;
52127   Dali::ImageDimensions *argp2 ;
52128   Dali::ImageDimensions result;
52129
52130   if (!jarg1) {
52131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52132     return 0;
52133   }
52134   std::string arg1_str(jarg1);
52135   arg1 = &arg1_str;
52136   argp2 = (Dali::ImageDimensions *)jarg2;
52137   if (!argp2) {
52138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52139     return 0;
52140   }
52141   arg2 = *argp2;
52142   arg3 = (Dali::FittingMode::Type)jarg3;
52143   arg4 = (Dali::SamplingMode::Type)jarg4;
52144   arg5 = jarg5 ? true : false;
52145   {
52146     try {
52147       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
52148     } CALL_CATCH_EXCEPTION(0);
52149   }
52150   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52151   return jresult;
52152 }
52153
52154
52155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
52156   void * jresult ;
52157   std::string *arg1 = 0 ;
52158   Dali::ImageDimensions arg2 ;
52159   Dali::FittingMode::Type arg3 ;
52160   Dali::SamplingMode::Type arg4 ;
52161   Dali::ImageDimensions *argp2 ;
52162   Dali::ImageDimensions result;
52163
52164   if (!jarg1) {
52165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52166     return 0;
52167   }
52168   std::string arg1_str(jarg1);
52169   arg1 = &arg1_str;
52170   argp2 = (Dali::ImageDimensions *)jarg2;
52171   if (!argp2) {
52172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52173     return 0;
52174   }
52175   arg2 = *argp2;
52176   arg3 = (Dali::FittingMode::Type)jarg3;
52177   arg4 = (Dali::SamplingMode::Type)jarg4;
52178   {
52179     try {
52180       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
52181     } CALL_CATCH_EXCEPTION(0);
52182   }
52183   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52184   return jresult;
52185 }
52186
52187
52188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
52189   void * jresult ;
52190   std::string *arg1 = 0 ;
52191   Dali::ImageDimensions arg2 ;
52192   Dali::FittingMode::Type arg3 ;
52193   Dali::ImageDimensions *argp2 ;
52194   Dali::ImageDimensions result;
52195
52196   if (!jarg1) {
52197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52198     return 0;
52199   }
52200   std::string arg1_str(jarg1);
52201   arg1 = &arg1_str;
52202   argp2 = (Dali::ImageDimensions *)jarg2;
52203   if (!argp2) {
52204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52205     return 0;
52206   }
52207   arg2 = *argp2;
52208   arg3 = (Dali::FittingMode::Type)jarg3;
52209   {
52210     try {
52211       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
52212     } CALL_CATCH_EXCEPTION(0);
52213   }
52214   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52215   return jresult;
52216 }
52217
52218
52219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
52220   void * jresult ;
52221   std::string *arg1 = 0 ;
52222   Dali::ImageDimensions arg2 ;
52223   Dali::ImageDimensions *argp2 ;
52224   Dali::ImageDimensions result;
52225
52226   if (!jarg1) {
52227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52228     return 0;
52229   }
52230   std::string arg1_str(jarg1);
52231   arg1 = &arg1_str;
52232   argp2 = (Dali::ImageDimensions *)jarg2;
52233   if (!argp2) {
52234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52235     return 0;
52236   }
52237   arg2 = *argp2;
52238   {
52239     try {
52240       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
52241     } CALL_CATCH_EXCEPTION(0);
52242   }
52243   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52244   return jresult;
52245 }
52246
52247
52248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
52249   void * jresult ;
52250   std::string *arg1 = 0 ;
52251   Dali::ImageDimensions result;
52252
52253   if (!jarg1) {
52254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52255     return 0;
52256   }
52257   std::string arg1_str(jarg1);
52258   arg1 = &arg1_str;
52259   {
52260     try {
52261       result = Dali::GetClosestImageSize((std::string const &)*arg1);
52262     } CALL_CATCH_EXCEPTION(0);
52263   }
52264   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52265   return jresult;
52266 }
52267
52268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
52269   void * jresult ;
52270   std::string *arg1 = 0 ;
52271   bool arg2 ;
52272   Dali::ImageDimensions result;
52273
52274   if (!jarg1) {
52275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52276     return 0;
52277   }
52278   std::string arg1_str(jarg1);
52279   arg1 = &arg1_str;
52280   arg2 = jarg2 ? true : false;
52281   {
52282     try {
52283       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
52284     } CALL_CATCH_EXCEPTION(0);
52285   }
52286   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
52287   return jresult;
52288 }
52289
52290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
52291   void * jresult ;
52292   std::string *arg1 = 0 ;
52293   Dali::ImageDimensions arg2 ;
52294   Dali::FittingMode::Type arg3 ;
52295   Dali::SamplingMode::Type arg4 ;
52296   bool arg5 ;
52297   Dali::ImageDimensions *argp2 ;
52298   Dali::Devel::PixelBuffer result;
52299
52300   if (!jarg1) {
52301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52302     return 0;
52303   }
52304   std::string arg1_str(jarg1);
52305   arg1 = &arg1_str;
52306   argp2 = (Dali::ImageDimensions *)jarg2;
52307   if (!argp2) {
52308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52309     return 0;
52310   }
52311   arg2 = *argp2;
52312   arg3 = (Dali::FittingMode::Type)jarg3;
52313   arg4 = (Dali::SamplingMode::Type)jarg4;
52314   arg5 = jarg5 ? true : false;
52315   {
52316     try {
52317       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
52318     } CALL_CATCH_EXCEPTION(0);
52319   }
52320   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52321   return jresult;
52322 }
52323
52324
52325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
52326   void * jresult ;
52327   std::string *arg1 = 0 ;
52328   Dali::ImageDimensions arg2 ;
52329   Dali::FittingMode::Type arg3 ;
52330   Dali::SamplingMode::Type arg4 ;
52331   Dali::ImageDimensions *argp2 ;
52332   Dali::Devel::PixelBuffer result;
52333
52334   if (!jarg1) {
52335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52336     return 0;
52337   }
52338   std::string arg1_str(jarg1);
52339   arg1 = &arg1_str;
52340   argp2 = (Dali::ImageDimensions *)jarg2;
52341   if (!argp2) {
52342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52343     return 0;
52344   }
52345   arg2 = *argp2;
52346   arg3 = (Dali::FittingMode::Type)jarg3;
52347   arg4 = (Dali::SamplingMode::Type)jarg4;
52348   {
52349     try {
52350       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
52351     } CALL_CATCH_EXCEPTION(0);
52352   }
52353   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52354   return jresult;
52355 }
52356
52357
52358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
52359   void * jresult ;
52360   std::string *arg1 = 0 ;
52361   Dali::ImageDimensions arg2 ;
52362   Dali::FittingMode::Type arg3 ;
52363   Dali::ImageDimensions *argp2 ;
52364   Dali::Devel::PixelBuffer result;
52365
52366   if (!jarg1) {
52367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52368     return 0;
52369   }
52370   std::string arg1_str(jarg1);
52371   arg1 = &arg1_str;
52372   argp2 = (Dali::ImageDimensions *)jarg2;
52373   if (!argp2) {
52374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52375     return 0;
52376   }
52377   arg2 = *argp2;
52378   arg3 = (Dali::FittingMode::Type)jarg3;
52379   {
52380     try {
52381       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
52382     } CALL_CATCH_EXCEPTION(0);
52383   }
52384   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52385   return jresult;
52386 }
52387
52388
52389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
52390   void * jresult ;
52391   std::string *arg1 = 0 ;
52392   Dali::ImageDimensions arg2 ;
52393   Dali::ImageDimensions *argp2 ;
52394   Dali::Devel::PixelBuffer result;
52395
52396   if (!jarg1) {
52397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52398     return 0;
52399   }
52400   std::string arg1_str(jarg1);
52401   arg1 = &arg1_str;
52402   argp2 = (Dali::ImageDimensions *)jarg2;
52403   if (!argp2) {
52404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52405     return 0;
52406   }
52407   arg2 = *argp2;
52408   {
52409     try {
52410       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
52411     } CALL_CATCH_EXCEPTION(0);
52412   }
52413   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52414   return jresult;
52415 }
52416
52417
52418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
52419   void * jresult ;
52420   std::string *arg1 = 0 ;
52421   Dali::Devel::PixelBuffer result;
52422
52423   if (!jarg1) {
52424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52425     return 0;
52426   }
52427   std::string arg1_str(jarg1);
52428   arg1 = &arg1_str;
52429   {
52430     try {
52431       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
52432     } CALL_CATCH_EXCEPTION(0);
52433   }
52434   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
52435   return jresult;
52436 }
52437
52438 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
52439   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
52440   char * jresult = SWIG_csharp_string_callback((const char *)result);
52441   return jresult;
52442 }
52443
52444 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
52445   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
52446   return result;
52447 }
52448
52449 struct NativeImageSourcePtrHandle
52450 {
52451   NativeImageSourcePtr Ptr;
52452 };
52453
52454 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
52455 {
52456   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
52457   return (NativeImageInterface*)(arg1);
52458 }
52459
52460 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
52461 {
52462   void* jresult;
52463   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
52464   {
52465     try {
52466       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
52467     }
52468     catch (std::out_of_range & e) {
52469       {
52470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52471       };
52472     }
52473     catch (std::exception & e) {
52474       {
52475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52476       };
52477     }
52478     catch (Dali::DaliException e) {
52479       {
52480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52481       };
52482     }
52483     catch (...) {
52484       {
52485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52486       };
52487     }
52488   }
52489   jresult = (void *)handle;
52490   return jresult;
52491 }
52492
52493 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
52494 {
52495   void* jresult;
52496   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
52497   jresult = (void*)( handle->Ptr.Get() );
52498   return jresult;
52499 }
52500
52501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
52502   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
52503   {
52504     try {
52505       delete arg1;
52506     }
52507     catch (std::out_of_range & e) {
52508       {
52509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
52510       };
52511     }
52512     catch (std::exception & e) {
52513       {
52514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
52515       };
52516     }
52517     catch (Dali::DaliException e) {
52518       {
52519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
52520       };
52521     }
52522     catch (...) {
52523       {
52524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
52525       };
52526     }
52527   }
52528 }
52529
52530 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
52531 {
52532   void* jresult;
52533   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
52534   uint16_t* arg2 = (uint16_t*)(jarg2);
52535   uint16_t* arg3 = (uint16_t*)(jarg3);
52536   uint16_t* arg4 = (uint16_t*)(jarg4);
52537   {
52538     try {
52539       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
52540     }
52541     catch (std::out_of_range & e) {
52542       {
52543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52544       };
52545     }
52546     catch (std::exception & e) {
52547       {
52548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52549       };
52550     }
52551     catch (Dali::DaliException e) {
52552       {
52553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52554       };
52555     }
52556     catch (...) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52559       };
52560     }
52561   }
52562   return jresult;
52563 }
52564
52565 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
52566 {
52567   bool jresult;
52568   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
52569
52570   {
52571     try {
52572       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
52573     }
52574     catch (std::out_of_range & e) {
52575       {
52576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52577       };
52578     }
52579     catch (std::exception & e) {
52580       {
52581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52582       };
52583     }
52584     catch (Dali::DaliException e) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52587       };
52588     }
52589     catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52592       };
52593     }
52594   }
52595   return jresult;
52596 }
52597
52598 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
52599 {
52600   Dali::Toolkit::ImageUrl result;
52601   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
52602   void *jresult;
52603
52604   if (!nativeImageSource)
52605   {
52606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
52607     return 0;
52608   }
52609   {
52610     try
52611     {
52612       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
52613     }
52614     catch (std::out_of_range& e)
52615     {
52616       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
52617       return 0;
52618     }
52619     catch (std::exception& e)
52620     {
52621       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
52622       return 0;
52623     }
52624     catch (Dali::DaliException e)
52625     {
52626       SWIG_CSharpException(SWIG_UnknownError, e.condition);
52627       return 0;
52628     }
52629     catch (...)
52630     {
52631       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
52632       return 0;
52633     }
52634   }
52635
52636   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
52637   return jresult;
52638 }
52639
52640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
52641 {
52642   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
52643
52644   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
52645   {
52646     try
52647     {
52648       delete imageUrl;
52649     }
52650     catch (std::out_of_range& e)
52651     {
52652       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
52653       return;
52654     }
52655     catch (std::exception& e)
52656     {
52657       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
52658       return;
52659     }
52660     catch (Dali::DaliException e)
52661     {
52662       SWIG_CSharpException(SWIG_UnknownError, e.condition);
52663       return;
52664     }
52665     catch (...)
52666     {
52667       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
52668       return;
52669     }
52670   }
52671 }
52672
52673 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
52674 {
52675   char *jresult;
52676   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
52677   std::string result;
52678
52679   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
52680   {
52681     try
52682     {
52683       result = imageUrl->GetUrl();
52684     }
52685     catch (std::out_of_range& e)
52686     {
52687       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
52688       return 0;
52689     }
52690     catch (std::exception& e)
52691     {
52692       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
52693       return 0;
52694     }
52695     catch (Dali::DaliException e)
52696     {
52697       SWIG_CSharpException(SWIG_UnknownError, e.condition);
52698       return 0;
52699     }
52700     catch (...)
52701     {
52702       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
52703       return 0;
52704     }
52705   }
52706
52707   jresult = SWIG_csharp_string_callback((&result)->c_str());
52708   return jresult;
52709 }
52710
52711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
52712   Dali::Actor *arg1 = (Dali::Actor *) 0;
52713   Dali::Vector2 maximumSize;
52714   Dali::Vector2 minimumSize;
52715   Dali::Vector3 naturalSize;
52716   bool widthForHeight;
52717   float result;
52718   {
52719     try {
52720       arg1 = (Dali::Actor *)jarg1;
52721       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
52722       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
52723       naturalSize = arg1->GetNaturalSize();
52724       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
52725
52726       float baseWidth;
52727       if (widthForHeight)
52728       {
52729         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
52730         baseWidth = arg1->GetWidthForHeight(baseHeight);
52731       }
52732       else
52733       {
52734         baseWidth = naturalSize.width;
52735       }
52736
52737       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
52738       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
52739     } CALL_CATCH_EXCEPTION(0);
52740   }
52741
52742   return result;
52743 }
52744
52745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
52746   Dali::Actor *arg1 = (Dali::Actor *) 0;
52747   Dali::Vector2 maximumSize;
52748   Dali::Vector2 minimumSize;
52749   Dali::Vector3 naturalSize;
52750   bool heightForWidth;
52751   float result;
52752   {
52753     try {
52754       arg1 = (Dali::Actor *)jarg1;
52755       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
52756       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
52757       naturalSize = arg1->GetNaturalSize();
52758       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
52759
52760       float baseHeight;
52761       if (heightForWidth)
52762       {
52763         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
52764         baseHeight = arg1->GetHeightForWidth(baseWidth);
52765       }
52766       else
52767       {
52768         baseHeight = naturalSize.height;
52769       }
52770
52771       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
52772       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
52773     } CALL_CATCH_EXCEPTION(0);
52774   }
52775
52776   return result;
52777 }
52778
52779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
52780   int jresult ;
52781   int result;
52782
52783   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
52784   jresult = (int)result;
52785   return jresult;
52786 }
52787
52788
52789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
52790   void * jresult ;
52791   Dali::Vector< Dali::Vector2 > *result = 0 ;
52792
52793   {
52794     try {
52795       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
52796     } CALL_CATCH_EXCEPTION(0);
52797   }
52798
52799   jresult = (void *)result;
52800   return jresult;
52801 }
52802
52803
52804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
52805   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52806
52807   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52808   {
52809     try {
52810       delete arg1;
52811     } CALL_CATCH_EXCEPTION();
52812   }
52813 }
52814
52815
52816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
52817   void * jresult ;
52818   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
52819   Dali::Vector< Dali::Vector2 > *result = 0 ;
52820
52821   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52822   if (!arg1) {
52823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
52824     return 0;
52825   }
52826   {
52827     try {
52828       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
52829     } CALL_CATCH_EXCEPTION(0);
52830   }
52831
52832   jresult = (void *)result;
52833   return jresult;
52834 }
52835
52836
52837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
52838   void * jresult ;
52839   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52840   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
52841   Dali::Vector< Dali::Vector2 > *result = 0 ;
52842
52843   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52844   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
52845   if (!arg2) {
52846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
52847     return 0;
52848   }
52849   {
52850     try {
52851       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
52852     } CALL_CATCH_EXCEPTION(0);
52853   }
52854
52855   jresult = (void *)result;
52856   return jresult;
52857 }
52858
52859
52860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
52861   void * jresult ;
52862   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52863   Dali::Vector< Dali::Vector2 >::Iterator result;
52864
52865   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52866   {
52867     try {
52868       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
52869     } CALL_CATCH_EXCEPTION(0);
52870   }
52871
52872   jresult = (void *)result;
52873   return jresult;
52874 }
52875
52876
52877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
52878   void * jresult ;
52879   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52880   Dali::Vector< Dali::Vector2 >::Iterator result;
52881
52882   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52883   {
52884     try {
52885       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
52886     } CALL_CATCH_EXCEPTION(0);
52887   }
52888
52889   jresult = (void *)result;
52890   return jresult;
52891 }
52892
52893
52894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52895   void * jresult ;
52896   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52897   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
52898   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
52899
52900   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52901   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
52902   {
52903     try {
52904       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
52905     } CALL_CATCH_EXCEPTION(0);
52906   }
52907
52908   jresult = (void *)result;
52909   return jresult;
52910 }
52911
52912
52913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
52914   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52915   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
52916
52917   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52918   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
52919   if (!arg2) {
52920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
52921     return ;
52922   }
52923   {
52924     try {
52925       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
52926     } CALL_CATCH_EXCEPTION();
52927   }
52928 }
52929
52930
52931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
52932   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52933   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
52934   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
52935
52936   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52937   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
52938   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
52939   if (!arg3) {
52940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
52941     return ;
52942   }
52943   {
52944     try {
52945       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
52946     } CALL_CATCH_EXCEPTION();
52947   }
52948 }
52949
52950
52951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52952   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52953   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
52954   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
52955   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
52956
52957   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52958   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
52959   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
52960   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
52961   {
52962     try {
52963       (arg1)->Insert(arg2,arg3,arg4);
52964     } CALL_CATCH_EXCEPTION();
52965   }
52966 }
52967
52968
52969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
52970   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52971   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
52972
52973   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52974   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
52975   {
52976     try {
52977       (arg1)->Reserve(arg2);
52978     } CALL_CATCH_EXCEPTION();
52979   }
52980 }
52981
52982
52983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52984   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52985   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
52986
52987   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
52988   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
52989   {
52990     try {
52991       (arg1)->Resize(arg2);
52992     } CALL_CATCH_EXCEPTION();
52993   }
52994 }
52995
52996
52997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
52998   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
52999   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
53000   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
53001
53002   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53003   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
53004   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
53005   if (!arg3) {
53006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53007     return ;
53008   }
53009   {
53010     try {
53011       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
53012     } CALL_CATCH_EXCEPTION();
53013   }
53014 }
53015
53016
53017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
53018   void * jresult ;
53019   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53020   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
53021   Dali::Vector< Dali::Vector2 >::Iterator result;
53022
53023   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53024   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
53025   {
53026     try {
53027       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
53028     } CALL_CATCH_EXCEPTION(0);
53029   }
53030
53031   jresult = (void *)result;
53032   return jresult;
53033 }
53034
53035
53036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53037   void * jresult ;
53038   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53039   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
53040   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
53041   Dali::Vector< Dali::Vector2 >::Iterator result;
53042
53043   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53044   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
53045   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
53046   {
53047     try {
53048       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
53049     } CALL_CATCH_EXCEPTION(0);
53050   }
53051
53052   jresult = (void *)result;
53053   return jresult;
53054 }
53055
53056
53057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
53058   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53059   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
53060
53061   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53062   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
53063   {
53064     try {
53065       (arg1)->Remove(arg2);
53066     } CALL_CATCH_EXCEPTION();
53067   }
53068 }
53069
53070
53071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
53072   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53073   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
53074
53075   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53076   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
53077   if (!arg2) {
53078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
53079     return ;
53080   }
53081   {
53082     try {
53083       (arg1)->Swap(*arg2);
53084     } CALL_CATCH_EXCEPTION();
53085   }
53086 }
53087
53088
53089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
53090   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53091
53092   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53093   {
53094     try {
53095       (arg1)->Clear();
53096     } CALL_CATCH_EXCEPTION();
53097   }
53098 }
53099
53100
53101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
53102   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53103
53104   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53105   {
53106     try {
53107       (arg1)->Release();
53108     } CALL_CATCH_EXCEPTION();
53109   }
53110 }
53111
53112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
53113   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
53114   int size;
53115
53116   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
53117   {
53118     try {
53119       size = (arg1)->Size();
53120     } CALL_CATCH_EXCEPTION(0);
53121   }
53122
53123   return size;
53124 }
53125
53126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_BaseType_get() {
53127   int jresult;
53128   int result;
53129
53130   result = (int)Dali::Vector<uint32_t>::BaseType;
53131   jresult = (int)result;
53132   return jresult;
53133 }
53134
53135 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_VectorUnsignedInteger__SWIG_0() {
53136   void *jresult;
53137   Dali::Vector<uint32_t> *result = 0;
53138
53139   {
53140     try {
53141       result = (Dali::Vector<uint32_t> *)new Dali::Vector<uint32_t>();
53142     }
53143     CALL_CATCH_EXCEPTION(0);
53144   }
53145
53146   jresult = (void *)result;
53147   return jresult;
53148 }
53149
53150 SWIGEXPORT void SWIGSTDCALL
53151 CSharp_Dali_delete_VectorUnsignedInteger(void *jarg1) {
53152   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53153
53154   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53155   {
53156     try {
53157       delete arg1;
53158     }
53159     CALL_CATCH_EXCEPTION();
53160   }
53161 }
53162
53163 SWIGEXPORT void *SWIGSTDCALL
53164 CSharp_Dali_new_VectorUnsignedInteger__SWIG_1(void *jarg1) {
53165   void *jresult;
53166   Dali::Vector<uint32_t> *arg1 = 0;
53167   Dali::Vector<uint32_t> *result = 0;
53168
53169   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53170   if (!arg1) {
53171     SWIG_CSharpSetPendingExceptionArgument(
53172         SWIG_CSharpArgumentNullException,
53173         "Dali::Vector< uint32_t > const & type is null", 0);
53174     return 0;
53175   }
53176   {
53177     try {
53178       result = (Dali::Vector<uint32_t> *)new Dali::Vector<uint32_t>(
53179           (Dali::Vector<uint32_t> const &)*arg1);
53180     }
53181     CALL_CATCH_EXCEPTION(0);
53182   }
53183
53184   jresult = (void *)result;
53185   return jresult;
53186 }
53187
53188 SWIGEXPORT void *SWIGSTDCALL
53189 CSharp_Dali_VectorUnsignedInteger_Assign(void *jarg1, void *jarg2) {
53190   void *jresult;
53191   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53192   Dali::Vector<uint32_t> *arg2 = 0;
53193   Dali::Vector<uint32_t> *result = 0;
53194
53195   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53196   arg2 = (Dali::Vector<uint32_t> *)jarg2;
53197   if (!arg2) {
53198     SWIG_CSharpSetPendingExceptionArgument(
53199         SWIG_CSharpArgumentNullException,
53200         "Dali::Vector< uint32_t > const & type is null", 0);
53201     return 0;
53202   }
53203   {
53204     try {
53205       result = (Dali::Vector<uint32_t> *)&(arg1)->operator=(
53206           (Dali::Vector<uint32_t> const &)*arg2);
53207     }
53208     CALL_CATCH_EXCEPTION(0);
53209   }
53210
53211   jresult = (void *)result;
53212   return jresult;
53213 }
53214
53215 SWIGEXPORT void *SWIGSTDCALL
53216 CSharp_Dali_VectorUnsignedInteger_Begin(void *jarg1) {
53217   void *jresult;
53218   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53219   Dali::Vector<uint32_t>::Iterator result;
53220
53221   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53222   {
53223     try {
53224       result = (Dali::Vector<uint32_t>::Iterator)(
53225                    (Dali::Vector<uint32_t> const *)arg1)
53226                    ->Begin();
53227     }
53228     CALL_CATCH_EXCEPTION(0);
53229   }
53230
53231   jresult = (void *)result;
53232   return jresult;
53233 }
53234
53235 SWIGEXPORT void *SWIGSTDCALL
53236 CSharp_Dali_VectorUnsignedInteger_End(void *jarg1) {
53237   void *jresult;
53238   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53239   Dali::Vector<uint32_t>::Iterator result;
53240
53241   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53242   {
53243     try {
53244       result = (Dali::Vector<uint32_t>::Iterator)(
53245                    (Dali::Vector<uint32_t> const *)arg1)
53246                    ->End();
53247     }
53248     CALL_CATCH_EXCEPTION(0);
53249   }
53250
53251   jresult = (void *)result;
53252   return jresult;
53253 }
53254
53255 SWIGEXPORT void *SWIGSTDCALL
53256 CSharp_Dali_VectorUnsignedInteger_ValueOfIndex__SWIG_0(void *jarg1,
53257                                                        unsigned long jarg2) {
53258   void *jresult;
53259   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53260   Dali::Vector<uint32_t>::SizeType arg2;
53261   Dali::Vector<uint32_t>::ItemType *result = 0;
53262
53263   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53264   arg2 = (Dali::Vector<uint32_t>::SizeType)jarg2;
53265   {
53266     try {
53267       result = (Dali::Vector<uint32_t>::ItemType *)&(arg1)->operator[](arg2);
53268     }
53269     CALL_CATCH_EXCEPTION(0);
53270   }
53271
53272   jresult = (void *)result;
53273   return jresult;
53274 }
53275
53276 SWIGEXPORT void SWIGSTDCALL
53277 CSharp_Dali_VectorUnsignedInteger_PushBack(void *jarg1, uint32_t jarg2) {
53278   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53279   Dali::Vector<uint32_t>::ItemType *arg2 = 0;
53280   Dali::Vector<uint32_t>::ItemType temp2;
53281
53282   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53283   temp2 = (Dali::Vector<uint32_t>::ItemType)jarg2;
53284   arg2 = &temp2;
53285   {
53286     try {
53287       (arg1)->PushBack((Dali::Vector<uint32_t>::ItemType const &)*arg2);
53288     }
53289     CALL_CATCH_EXCEPTION();
53290   }
53291 }
53292
53293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_0(
53294     void *jarg1, uint32_t *jarg2, uint32_t jarg3) {
53295   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53296   Dali::Vector<uint32_t>::Iterator arg2 = (Dali::Vector<uint32_t>::Iterator)0;
53297   Dali::Vector<uint32_t>::ItemType *arg3 = 0;
53298   Dali::Vector<uint32_t>::ItemType temp3;
53299
53300   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53301   arg2 = jarg2;
53302   temp3 = (Dali::Vector<uint32_t>::ItemType)jarg3;
53303   arg3 = &temp3;
53304   {
53305     try {
53306       (arg1)->Insert(arg2, (Dali::Vector<uint32_t>::ItemType const &)*arg3);
53307     }
53308     CALL_CATCH_EXCEPTION();
53309   }
53310 }
53311
53312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_1(
53313     void *jarg1, uint32_t *jarg2, void *jarg3, void *jarg4) {
53314   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53315   Dali::Vector<uint32_t>::Iterator arg2 = (Dali::Vector<uint32_t>::Iterator)0;
53316   Dali::Vector<uint32_t>::Iterator arg3 = (Dali::Vector<uint32_t>::Iterator)0;
53317   Dali::Vector<uint32_t>::Iterator arg4 = (Dali::Vector<uint32_t>::Iterator)0;
53318
53319   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53320   arg2 = jarg2;
53321   arg3 = (Dali::Vector<uint32_t>::Iterator)jarg3;
53322   arg4 = (Dali::Vector<uint32_t>::Iterator)jarg4;
53323   {
53324     try {
53325       (arg1)->Insert(arg2, arg3, arg4);
53326     }
53327     CALL_CATCH_EXCEPTION();
53328   }
53329 }
53330
53331 SWIGEXPORT void SWIGSTDCALL
53332 CSharp_Dali_VectorUnsignedInteger_Reserve(void *jarg1, unsigned long jarg2) {
53333   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53334   Dali::Vector<uint32_t>::SizeType arg2;
53335
53336   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53337   arg2 = (Dali::Vector<uint32_t>::SizeType)jarg2;
53338   {
53339     try {
53340       (arg1)->Reserve(arg2);
53341     }
53342     CALL_CATCH_EXCEPTION();
53343   }
53344 }
53345
53346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_0(
53347     void *jarg1, unsigned long jarg2) {
53348   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53349   Dali::Vector<uint32_t>::SizeType arg2;
53350
53351   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53352   arg2 = (Dali::Vector<uint32_t>::SizeType)jarg2;
53353   {
53354     try {
53355       (arg1)->Resize(arg2);
53356     }
53357     CALL_CATCH_EXCEPTION();
53358   }
53359 }
53360
53361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_1(
53362     void *jarg1, unsigned long jarg2, uint32_t jarg3) {
53363   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53364   Dali::Vector<uint32_t>::SizeType arg2;
53365   Dali::Vector<uint32_t>::ItemType *arg3 = 0;
53366   Dali::Vector<uint32_t>::ItemType temp3;
53367
53368   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53369   arg2 = (Dali::Vector<uint32_t>::SizeType)jarg2;
53370   temp3 = (Dali::Vector<uint32_t>::ItemType)jarg3;
53371   arg3 = &temp3;
53372   {
53373     try {
53374       (arg1)->Resize(arg2, (Dali::Vector<uint32_t>::ItemType const &)*arg3);
53375     }
53376     CALL_CATCH_EXCEPTION();
53377   }
53378 }
53379
53380 SWIGEXPORT void *SWIGSTDCALL
53381 CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_0(void *jarg1, uint32_t *jarg2) {
53382   void *jresult;
53383   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53384   Dali::Vector<uint32_t>::Iterator arg2 = (Dali::Vector<uint32_t>::Iterator)0;
53385   Dali::Vector<uint32_t>::Iterator result;
53386
53387   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53388   arg2 = jarg2;
53389   {
53390     try {
53391       result = (Dali::Vector<uint32_t>::Iterator)(arg1)->Erase(arg2);
53392     }
53393     CALL_CATCH_EXCEPTION(0);
53394   }
53395
53396   jresult = (void *)result;
53397
53398   return jresult;
53399 }
53400
53401 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_1(
53402     void *jarg1, uint32_t *jarg2, void *jarg3) {
53403   void *jresult;
53404   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53405   Dali::Vector<uint32_t>::Iterator arg2 = (Dali::Vector<uint32_t>::Iterator)0;
53406   Dali::Vector<uint32_t>::Iterator arg3 = (Dali::Vector<uint32_t>::Iterator)0;
53407   Dali::Vector<uint32_t>::Iterator result;
53408
53409   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53410   arg2 = jarg2;
53411   arg3 = (Dali::Vector<uint32_t>::Iterator)jarg3;
53412   {
53413     try {
53414       result = (Dali::Vector<uint32_t>::Iterator)(arg1)->Erase(arg2, arg3);
53415     }
53416     CALL_CATCH_EXCEPTION(0);
53417   }
53418
53419   jresult = (void *)result;
53420
53421   return jresult;
53422 }
53423
53424 SWIGEXPORT void SWIGSTDCALL
53425 CSharp_Dali_VectorUnsignedInteger_Remove(void *jarg1, uint32_t *jarg2) {
53426   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53427   Dali::Vector<uint32_t>::Iterator arg2 = (Dali::Vector<uint32_t>::Iterator)0;
53428
53429   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53430   arg2 = jarg2;
53431   {
53432     try {
53433       (arg1)->Remove(arg2);
53434     }
53435     CALL_CATCH_EXCEPTION();
53436   }
53437 }
53438
53439 SWIGEXPORT void SWIGSTDCALL
53440 CSharp_Dali_VectorUnsignedInteger_Swap(void *jarg1, void *jarg2) {
53441   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53442   Dali::Vector<uint32_t> *arg2 = 0;
53443
53444   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53445   arg2 = (Dali::Vector<uint32_t> *)jarg2;
53446   if (!arg2) {
53447     SWIG_CSharpSetPendingExceptionArgument(
53448         SWIG_CSharpArgumentNullException,
53449         "Dali::Vector< uint32_t > & type is null", 0);
53450     return;
53451   }
53452   {
53453     try {
53454       (arg1)->Swap(*arg2);
53455     }
53456     CALL_CATCH_EXCEPTION();
53457   }
53458 }
53459
53460 SWIGEXPORT void SWIGSTDCALL
53461 CSharp_Dali_VectorUnsignedInteger_Clear(void *jarg1) {
53462   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53463
53464   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53465   {
53466     try {
53467       (arg1)->Clear();
53468     }
53469     CALL_CATCH_EXCEPTION();
53470   }
53471 }
53472
53473 SWIGEXPORT void SWIGSTDCALL
53474 CSharp_Dali_VectorUnsignedInteger_Release(void *jarg1) {
53475   Dali::Vector<uint32_t> *arg1 = (Dali::Vector<uint32_t> *)0;
53476
53477   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53478   {
53479     try {
53480       (arg1)->Release();
53481     }
53482     CALL_CATCH_EXCEPTION();
53483   }
53484 }
53485
53486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Size(void *jarg1) {
53487   Dali::Vector< uint32_t > *arg1 = (Dali::Vector< uint32_t > *) 0 ;
53488   int size;
53489
53490   arg1 = (Dali::Vector<uint32_t> *)jarg1;
53491   {
53492     try {
53493       size = (arg1)->Size();
53494     } CALL_CATCH_EXCEPTION(0);
53495   }
53496
53497   return size;
53498 }
53499
53500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() {
53501   void * jresult ;
53502   int width, height;
53503
53504   try {
53505     Dali::DevelWindowSystem::GetScreenSize(width, height);
53506   } CALL_CATCH_EXCEPTION(0);
53507
53508   jresult = new Dali::Size(width, height);
53509   return jresult;
53510 }
53511
53512 #ifdef __cplusplus
53513 }
53514 #endif
53515