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
 150 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 151   { SWIG_CSharpApplicationException, NULL },
 152   { SWIG_CSharpArithmeticException, NULL },
 153   { SWIG_CSharpDivideByZeroException, NULL },
 154   { SWIG_CSharpIndexOutOfRangeException, NULL },
 155   { SWIG_CSharpInvalidCastException, NULL },
 156   { SWIG_CSharpInvalidOperationException, NULL },
 157   { SWIG_CSharpIOException, NULL },
 158   { SWIG_CSharpNullReferenceException, NULL },
 159   { SWIG_CSharpOutOfMemoryException, NULL },
 160   { SWIG_CSharpOverflowException, NULL },
 161   { SWIG_CSharpSystemException, NULL }
 162 };
 163
 164 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 165   { SWIG_CSharpArgumentException, NULL },
 166   { SWIG_CSharpArgumentNullException, NULL },
 167   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 168 };
 169
 170 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 171   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 172   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 173     callback = SWIG_csharp_exceptions[code].callback;
 174   }
 175   callback(msg);
 176 }
 177
 178 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 179   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 180   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 181     callback = SWIG_csharp_exceptions_argument[code].callback;
 182   }
 183   callback(msg, param_name);
 184 }
 185
 186
 187 #ifdef __cplusplus
 188 extern "C"
 189 #endif
 190 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 191                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 192                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 193                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 194                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 195                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 196                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 197                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 198                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 199                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 200                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 201                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 202   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 203   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 204   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 205   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 206   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 207   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 208   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 209   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 210   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 211   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 212   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 213 }
 214
 215 #ifdef __cplusplus
 216 extern "C"
 217 #endif
 218 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 219                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 220                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 221                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 222   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 223   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 224   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 225 }
 226
 227
 228 /* Callback for returning strings to C# without leaking memory */
 229 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 230 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 231
 232 // keep argWidgetCs and argWidgetV so they're always available to DALi
 233 int argWidgetC = 1;
 234 char **argWidgetV = NULL;
 235
 236 #ifdef __cplusplus
 237 extern "C"
 238 #endif
 239 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 240   SWIG_csharp_string_callback = callback;
 241 }
 242
 243
 244 /* Contract support */
 245 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 246
 247
 248 /* -----------------------------------------------------------------------------
 249  * director_common.swg
 250  *
 251  * This file contains support for director classes which is common between
 252  * languages.
 253  * ----------------------------------------------------------------------------- */
 254
 255 /*
 256   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 257   'Swig' namespace. This could be useful for multi-modules projects.
 258 */
 259 #ifdef SWIG_DIRECTOR_STATIC
 260 /* Force anonymous (static) namespace */
 261 #define Swig
 262 #endif
 263 /* -----------------------------------------------------------------------------
 264  * director.swg
 265  *
 266  * This file contains support for director classes so that C# proxy
 267  * methods can be called from C++.
 268  * ----------------------------------------------------------------------------- */
 269
 270 #if defined(DEBUG_DIRECTOR_OWNED)
 271 #include <iostream>
 272 #endif
 273 #include <string>
 274 #include <exception>
 275
 276 namespace Swig {
 277   /* Director base class - not currently used in C# directors */
 278   class Director {
 279   };
 280
 281   /* Base class for director exceptions */
 282   class DirectorException : public std::exception {
 283   protected:
 284     std::string swig_msg;
 285
 286   public:
 287     DirectorException(const char *msg) : swig_msg(msg) {
 288     }
 289
 290     DirectorException(const std::string &msg) : swig_msg(msg) {
 291     }
 292
 293     virtual ~DirectorException() throw() {
 294     }
 295
 296     const char *what() const throw() {
 297       return swig_msg.c_str();
 298     }
 299   };
 300
 301   /* Pure virtual method exception */
 302   class DirectorPureVirtualException : public DirectorException {
 303   public:
 304     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 305     }
 306   };
 307 }
 308
 309
 310 void SWIG_CSharpException(int code, const char *msg) {
 311   if (code == SWIG_ValueError) {
 312     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 313     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 314   } else {
 315     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 316     switch(code) {
 317     case SWIG_MemoryError:
 318       exception_code = SWIG_CSharpOutOfMemoryException;
 319       break;
 320     case SWIG_IndexError:
 321       exception_code = SWIG_CSharpIndexOutOfRangeException;
 322       break;
 323     case SWIG_DivisionByZero:
 324       exception_code = SWIG_CSharpDivideByZeroException;
 325       break;
 326     case SWIG_IOError:
 327       exception_code = SWIG_CSharpIOException;
 328       break;
 329     case SWIG_OverflowError:
 330       exception_code = SWIG_CSharpOverflowException;
 331       break;
 332     case SWIG_RuntimeError:
 333     case SWIG_TypeError:
 334     case SWIG_SyntaxError:
 335     case SWIG_SystemError:
 336     case SWIG_UnknownError:
 337     default:
 338       exception_code = SWIG_CSharpApplicationException;
 339       break;
 340     }
 341     SWIG_CSharpSetPendingException(exception_code, msg);
 342   }
 343 }
 344
 345
 346 #include <stdexcept>
 347
 348
 349 #define SWIGSTDCALL
 350
 351 #include <time.h>
 352
 353 #include <dali/dali.h>
 354 #include <dali-toolkit/dali-toolkit.h>
 355
 356 #include <dali/devel-api/actors/actor-devel.h>
 357 #include <dali/devel-api/animation/key-frames-devel.h>
 358 #include <dali/devel-api/common/stage-devel.h>
 359 #include <dali/devel-api/events/key-event-devel.h>
 360 #include <dali/devel-api/events/wheel-event-devel.h>
 361 #include <dali/devel-api/events/hover-event-devel.h>
 362 #include <dali/devel-api/events/touch-point.h>
 363 #include <dali/devel-api/events/pan-gesture-devel.h>
 364 #include <dali/devel-api/events/pinch-gesture-devel.h>
 365 #include <dali/devel-api/events/long-press-gesture-devel.h>
 366 #include <dali/devel-api/events/tap-gesture-devel.h>
 367
 368 #include <dali/public-api/math/matrix.h>
 369 #include <dali/public-api/math/matrix3.h>
 370 #include <dali/public-api/math/viewport.h>
 371 #include <dali/public-api/object/property-key.h>
 372 #include <dali/devel-api/object/csharp-type-info.h>
 373 #include <dali/devel-api/object/csharp-type-registry.h>
 374
 375 #include <dali/public-api/adaptor-framework/timer.h>
 376 #include <dali/public-api/adaptor-framework/style-change.h>
 377 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 378
 379 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 380
 381 #include <dali-toolkit/devel-api/builder/builder.h>
 382
 383 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 384 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 385
 386 #include <dali-toolkit/devel-api/controls/control-devel.h>
 387 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 388 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 389 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 390 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 391 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 392 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 393 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.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
 423 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 424
 425 #include <dali/devel-api/update/frame-callback-interface.h>
 426 #include <dali/devel-api/update/update-proxy.h>
 427
 428 #include <dali-toolkit/public-api/image-loader/image.h>
 429 #include <dali-toolkit/public-api/image-loader/image-url.h>
 430
 431
 432 // add here SWIG version check
 433
 434 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 435 // disable Swig-dependent warnings
 436
 437 // 'identifier1' has C-linkage specified,
 438 // but returns UDT 'identifier2' which is incompatible with C
 439 #pragma warning(disable: 4190)
 440
 441 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 442 #pragma warning(disable: 4800)
 443
 444 // debug info too long etc etc
 445 #pragma warning(disable: 4786)
 446 #endif
 447
 448
 449 #include <stdexcept>
 450
 451
 452 #include <string>
 453
 454
 455 #include <vector>
 456 #include <algorithm>
 457 #include <stdexcept>
 458
 459
 460 #include <map>
 461 #include <algorithm>
 462 #include <stdexcept>
 463
 464
 465 #include <utility>
 466
 467
 468 typedef float floatp;
 469
 470 SWIGINTERN floatp *new_floatp(){
 471   return new float();
 472 }
 473 SWIGINTERN void delete_floatp(floatp *self){
 474   if (self) delete self;
 475 }
 476 SWIGINTERN void floatp_assign(floatp *self,float value){
 477   *self = value;
 478 }
 479 SWIGINTERN float floatp_value(floatp *self){
 480   return *self;
 481 }
 482 SWIGINTERN float *floatp_cast(floatp *self){
 483   return self;
 484 }
 485 SWIGINTERN floatp *floatp_frompointer(float *t){
 486   return (floatp *) t;
 487 }
 488
 489 typedef int intp;
 490
 491 SWIGINTERN intp *new_intp(){
 492   return new int();
 493 }
 494 SWIGINTERN void delete_intp(intp *self){
 495   if (self) delete self;
 496 }
 497 SWIGINTERN void intp_assign(intp *self,int value){
 498   *self = value;
 499 }
 500 SWIGINTERN int intp_value(intp *self){
 501   return *self;
 502 }
 503 SWIGINTERN int *intp_cast(intp *self){
 504   return self;
 505 }
 506 SWIGINTERN intp *intp_frompointer(int *t){
 507   return (intp *) t;
 508 }
 509
 510 typedef double doublep;
 511
 512 SWIGINTERN doublep *new_doublep(){
 513   return new double();
 514 }
 515 SWIGINTERN void delete_doublep(doublep *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void doublep_assign(doublep *self,double value){
 519   *self = value;
 520 }
 521 SWIGINTERN double doublep_value(doublep *self){
 522   return *self;
 523 }
 524 SWIGINTERN double *doublep_cast(doublep *self){
 525   return self;
 526 }
 527 SWIGINTERN doublep *doublep_frompointer(double *t){
 528   return (doublep *) t;
 529 }
 530
 531 typedef unsigned int uintp;
 532
 533 SWIGINTERN uintp *new_uintp(){
 534   return new unsigned int();
 535 }
 536 SWIGINTERN void delete_uintp(uintp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 540   *self = value;
 541 }
 542 SWIGINTERN unsigned int uintp_value(uintp *self){
 543   return *self;
 544 }
 545 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 546   return self;
 547 }
 548 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 549   return (uintp *) t;
 550 }
 551
 552 typedef unsigned short ushortp;
 553
 554 SWIGINTERN ushortp *new_ushortp(){
 555   return new unsigned short();
 556 }
 557 SWIGINTERN void delete_ushortp(ushortp *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 561   *self = value;
 562 }
 563 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 564   return *self;
 565 }
 566 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 567   return self;
 568 }
 569 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 570   return (ushortp *) t;
 571 }
 572
 573 unsigned int int_to_uint(int x) {
 574    return (unsigned int) x;
 575 }
 576
 577
 578 using namespace Dali;
 579 using namespace Dali::Toolkit;
 580
 581 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 582 {
 583   bool result = false;
 584   try
 585   {
 586     // C++ code. DALi uses Handle <-> Body design pattern.
 587     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 588     // Handles in DALi can be converted into a boolean type
 589     // to check if the handle has a valid body attached to it.
 590     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 591     if( *self )
 592     {
 593       result = true;
 594     }
 595     else
 596     {
 597       result = false;
 598     }
 599   }
 600   CALL_CATCH_EXCEPTION(false);
 601   return result;
 602 }
 603
 604 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 605 {
 606   bool result = false;
 607   try
 608   {
 609     // C++ code. Check if two handles reference the same implemtion
 610     if( *self == rhs)
 611     {
 612       result = true;
 613     }
 614     else
 615     {
 616       result = false;
 617     }
 618   }
 619   CALL_CATCH_EXCEPTION(false);
 620   return result;
 621 }
 622
 623
 624 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 625      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 626    }
 627 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){
 628      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 629    }
 630 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 631         std::vector< Dali::TouchPoint >* pv = 0;
 632         if (capacity >= 0) {
 633           pv = new std::vector< Dali::TouchPoint >();
 634           pv->reserve(capacity);
 635        } else {
 636           throw std::out_of_range("capacity");
 637        }
 638        return pv;
 639       }
 640 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 641         if (index>=0 && index<(int)self->size())
 642           return (*self)[index];
 643         else
 644           throw std::out_of_range("index");
 645       }
 646 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 647         if (index>=0 && index<(int)self->size())
 648           return (*self)[index];
 649         else
 650           throw std::out_of_range("index");
 651       }
 652 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 653         if (index>=0 && index<(int)self->size())
 654           (*self)[index] = val;
 655         else
 656           throw std::out_of_range("index");
 657       }
 658 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 659         self->insert(self->end(), values.begin(), values.end());
 660       }
 661 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 662         if (index < 0)
 663           throw std::out_of_range("index");
 664         if (count < 0)
 665           throw std::out_of_range("count");
 666         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 667           throw std::invalid_argument("invalid range");
 668         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 669       }
 670 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 671         if (index>=0 && index<(int)self->size()+1)
 672           self->insert(self->begin()+index, x);
 673         else
 674           throw std::out_of_range("index");
 675       }
 676 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 677         if (index>=0 && index<(int)self->size()+1)
 678           self->insert(self->begin()+index, values.begin(), values.end());
 679         else
 680           throw std::out_of_range("index");
 681       }
 682 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 683         if (index>=0 && index<(int)self->size())
 684           self->erase(self->begin() + index);
 685         else
 686           throw std::out_of_range("index");
 687       }
 688 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 689         if (index < 0)
 690           throw std::out_of_range("index");
 691         if (count < 0)
 692           throw std::out_of_range("count");
 693         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 694           throw std::invalid_argument("invalid range");
 695         self->erase(self->begin()+index, self->begin()+index+count);
 696       }
 697 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 698         if (count < 0)
 699           throw std::out_of_range("count");
 700         return new std::vector< Dali::TouchPoint >(count, value);
 701       }
 702 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 703         std::reverse(self->begin(), self->end());
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 706         if (index < 0)
 707           throw std::out_of_range("index");
 708         if (count < 0)
 709           throw std::out_of_range("count");
 710         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 711           throw std::invalid_argument("invalid range");
 712         std::reverse(self->begin()+index, self->begin()+index+count);
 713       }
 714 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 715         if (index < 0)
 716           throw std::out_of_range("index");
 717         if (index+values.size() > self->size())
 718           throw std::out_of_range("index");
 719         std::copy(values.begin(), values.end(), self->begin()+index);
 720       }
 721 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 722          return self->Empty();
 723       }
 724 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 725         return self->GetConnectionCount();
 726       }
 727 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 728           self->Connect( func );
 729       }
 730 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 731           self->Disconnect( func );
 732       }
 733 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 734           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 735 /*@SWIG@*/ self->Emit( arg );
 736       }
 737 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 738          return self->Empty();
 739       }
 740 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 741         return self->GetConnectionCount();
 742       }
 743 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 744           self->Connect( func );
 745       }
 746 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 747           self->Disconnect( func );
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 750           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 751 /*@SWIG@*/ self->Emit( arg );
 752       }
 753 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 754          return self->Empty();
 755       }
 756 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){
 757         return self->GetConnectionCount();
 758       }
 759 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 *)){
 760           self->Connect( func );
 761       }
 762 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 *)){
 763           self->Disconnect( func );
 764       }
 765 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){
 766           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 767 /*@SWIG@*/ self->Emit( arg );
 768       }
 769 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 770          return self->Empty();
 771       }
 772 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 773         return self->GetConnectionCount();
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 776           self->Connect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 779           self->Disconnect( func );
 780       }
 781 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 782           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 783 /*@SWIG@*/ self->Emit( arg );
 784       }
 785 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 786          return self->Empty();
 787       }
 788 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 789         return self->GetConnectionCount();
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 792         self->Connect( func );
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 795         self->Disconnect( func );
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 798         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 799 /*@SWIG@*/ self->Emit( arg1, arg2 );
 800       }
 801 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 802          return self->Empty();
 803       }
 804 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 805         return self->GetConnectionCount();
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 808         self->Connect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 811         self->Disconnect( func );
 812       }
 813 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 814         return self->Emit( arg1, arg2 );
 815       }
 816 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 817          return self->Empty();
 818       }
 819 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 820         return self->GetConnectionCount();
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 823         self->Connect( func );
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 826         self->Disconnect( func );
 827       }
 828 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 829         return self->Emit( arg1, arg2 );
 830       }
 831 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 832          return self->Empty();
 833       }
 834 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 835         return self->GetConnectionCount();
 836       }
 837 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 838         self->Connect( func );
 839       }
 840 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 841         self->Disconnect( func );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 844         return self->Emit( arg1, arg2 );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 847          return self->Empty();
 848       }
 849 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 850         return self->GetConnectionCount();
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 853           self->Connect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 856           self->Disconnect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 859           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 860 /*@SWIG@*/ self->Emit( arg );
 861       }
 862 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 863          return self->Empty();
 864       }
 865 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){
 866         return self->GetConnectionCount();
 867       }
 868 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 &)){
 869           self->Connect( func );
 870       }
 871 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 &)){
 872           self->Disconnect( func );
 873       }
 874 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){
 875           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 876 /*@SWIG@*/ self->Emit( arg );
 877       }
 878 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 879          return self->Empty();
 880       }
 881 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){
 882         return self->GetConnectionCount();
 883       }
 884 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 &)){
 885           self->Connect( func );
 886       }
 887 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 &)){
 888           self->Disconnect( func );
 889       }
 890 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){
 891           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 892 /*@SWIG@*/ self->Emit( arg );
 893       }
 894 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 895          return self->Empty();
 896       }
 897 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){
 898         return self->GetConnectionCount();
 899       }
 900 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 &)){
 901           self->Connect( func );
 902       }
 903 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 &)){
 904           self->Disconnect( func );
 905       }
 906 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){
 907           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 908 /*@SWIG@*/ self->Emit( arg );
 909       }
 910 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){
 911          return self->Empty();
 912       }
 913 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){
 914         return self->GetConnectionCount();
 915       }
 916 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 &)){
 917         self->Connect( func );
 918       }
 919 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 &)){
 920         self->Disconnect( func );
 921       }
 922 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){
 923         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 924 /*@SWIG@*/ self->Emit( arg1, arg2 );
 925       }
 926 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){
 927          return self->Empty();
 928       }
 929 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){
 930         return self->GetConnectionCount();
 931       }
 932 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 &)){
 933         self->Connect( func );
 934       }
 935 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 &)){
 936         self->Disconnect( func );
 937       }
 938 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){
 939         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 940 /*@SWIG@*/ self->Emit( arg1, arg2 );
 941       }
 942 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){
 943          return self->Empty();
 944       }
 945 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){
 946         return self->GetConnectionCount();
 947       }
 948 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 &)){
 949         self->Connect( func );
 950       }
 951 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 &)){
 952         self->Disconnect( func );
 953       }
 954 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){
 955         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 956 /*@SWIG@*/ self->Emit( arg1, arg2 );
 957       }
 958 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){
 959          return self->Empty();
 960       }
 961 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){
 962         return self->GetConnectionCount();
 963       }
 964 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)){
 965           return self->Connect( func );
 966       }
 967 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)){
 968           self->Disconnect( func );
 969       }
 970 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){
 971           self->Emit( arg1, arg3 );
 972       }
 973 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){
 974          return self->Empty();
 975       }
 976 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){
 977         return self->GetConnectionCount();
 978       }
 979 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)){
 980           return self->Connect( func );
 981       }
 982 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)){
 983           self->Disconnect( func );
 984       }
 985 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){
 986           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 987 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
 988       }
 989
 990 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
 991          return self->Empty();
 992       }
 993 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
 994         return self->GetConnectionCount();
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
 997           self->Connect( func );
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1000           self->Disconnect( func );
1001       }
1002 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1003           return self->Emit();
1004       }
1005
1006 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1007         std::vector< unsigned int >* pv = 0;
1008         if (capacity >= 0) {
1009           pv = new std::vector< unsigned int >();
1010           pv->reserve(capacity);
1011        } else {
1012           throw std::out_of_range("capacity");
1013        }
1014        return pv;
1015       }
1016 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1017         if (index>=0 && index<(int)self->size())
1018           return (*self)[index];
1019         else
1020           throw std::out_of_range("index");
1021       }
1022 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1023         if (index>=0 && index<(int)self->size())
1024           return (*self)[index];
1025         else
1026           throw std::out_of_range("index");
1027       }
1028 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1029         if (index>=0 && index<(int)self->size())
1030           (*self)[index] = val;
1031         else
1032           throw std::out_of_range("index");
1033       }
1034 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1035         self->insert(self->end(), values.begin(), values.end());
1036       }
1037 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1038         if (index < 0)
1039           throw std::out_of_range("index");
1040         if (count < 0)
1041           throw std::out_of_range("count");
1042         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1043           throw std::invalid_argument("invalid range");
1044         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1045       }
1046 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1047         if (index>=0 && index<(int)self->size()+1)
1048           self->insert(self->begin()+index, x);
1049         else
1050           throw std::out_of_range("index");
1051       }
1052 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1053         if (index>=0 && index<(int)self->size()+1)
1054           self->insert(self->begin()+index, values.begin(), values.end());
1055         else
1056           throw std::out_of_range("index");
1057       }
1058 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1059         if (index>=0 && index<(int)self->size())
1060           self->erase(self->begin() + index);
1061         else
1062           throw std::out_of_range("index");
1063       }
1064 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1065         if (index < 0)
1066           throw std::out_of_range("index");
1067         if (count < 0)
1068           throw std::out_of_range("count");
1069         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1070           throw std::invalid_argument("invalid range");
1071         self->erase(self->begin()+index, self->begin()+index+count);
1072       }
1073 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1074         if (count < 0)
1075           throw std::out_of_range("count");
1076         return new std::vector< unsigned int >(count, value);
1077       }
1078 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1079         std::reverse(self->begin(), self->end());
1080       }
1081 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1082         if (index < 0)
1083           throw std::out_of_range("index");
1084         if (count < 0)
1085           throw std::out_of_range("count");
1086         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1087           throw std::invalid_argument("invalid range");
1088         std::reverse(self->begin()+index, self->begin()+index+count);
1089       }
1090 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1091         if (index < 0)
1092           throw std::out_of_range("index");
1093         if (index+values.size() > self->size())
1094           throw std::out_of_range("index");
1095         std::copy(values.begin(), values.end(), self->begin()+index);
1096       }
1097 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1098         return std::find(self->begin(), self->end(), value) != self->end();
1099       }
1100 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1101         int index = -1;
1102         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1103         if (it != self->end())
1104           index = (int)(it - self->begin());
1105         return index;
1106       }
1107 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1108         int index = -1;
1109         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1110         if (rit != self->rend())
1111           index = (int)(self->rend() - 1 - rit);
1112         return index;
1113       }
1114 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1115         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1116         if (it != self->end()) {
1117           self->erase(it);
1118           return true;
1119         }
1120         return false;
1121       }
1122 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){
1123         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1124         if (capacity >= 0) {
1125           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1126           pv->reserve(capacity);
1127        } else {
1128           throw std::out_of_range("capacity");
1129        }
1130        return pv;
1131       }
1132 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){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 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){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 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){
1145         if (index>=0 && index<(int)self->size())
1146           (*self)[index] = val;
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 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){
1151         self->insert(self->end(), values.begin(), values.end());
1152       }
1153 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){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1161       }
1162 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){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, x);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 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){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, values.begin(), values.end());
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 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){
1175         if (index>=0 && index<(int)self->size())
1176           self->erase(self->begin() + index);
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 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){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1186           throw std::invalid_argument("invalid range");
1187         self->erase(self->begin()+index, self->begin()+index+count);
1188       }
1189 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){
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1193       }
1194 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){
1195         std::reverse(self->begin(), self->end());
1196       }
1197 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){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         std::reverse(self->begin()+index, self->begin()+index+count);
1205       }
1206 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){
1207         if (index < 0)
1208           throw std::out_of_range("index");
1209         if (index+values.size() > self->size())
1210           throw std::out_of_range("index");
1211         std::copy(values.begin(), values.end(), self->begin()+index);
1212       }
1213 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1214         std::vector< Dali::Actor >* pv = 0;
1215         if (capacity >= 0) {
1216           pv = new std::vector< Dali::Actor >();
1217           pv->reserve(capacity);
1218        } else {
1219           throw std::out_of_range("capacity");
1220        }
1221        return pv;
1222       }
1223 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1224         if (index>=0 && index<(int)self->size())
1225           return (*self)[index];
1226         else
1227           throw std::out_of_range("index");
1228       }
1229 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1230         if (index>=0 && index<(int)self->size())
1231           return (*self)[index];
1232         else
1233           throw std::out_of_range("index");
1234       }
1235 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1236         if (index>=0 && index<(int)self->size())
1237           (*self)[index] = val;
1238         else
1239           throw std::out_of_range("index");
1240       }
1241 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1242         self->insert(self->end(), values.begin(), values.end());
1243       }
1244 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1245         if (index < 0)
1246           throw std::out_of_range("index");
1247         if (count < 0)
1248           throw std::out_of_range("count");
1249         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1250           throw std::invalid_argument("invalid range");
1251         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1252       }
1253 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1254         if (index>=0 && index<(int)self->size()+1)
1255           self->insert(self->begin()+index, x);
1256         else
1257           throw std::out_of_range("index");
1258       }
1259 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1260         if (index>=0 && index<(int)self->size()+1)
1261           self->insert(self->begin()+index, values.begin(), values.end());
1262         else
1263           throw std::out_of_range("index");
1264       }
1265 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1266         if (index>=0 && index<(int)self->size())
1267           self->erase(self->begin() + index);
1268         else
1269           throw std::out_of_range("index");
1270       }
1271 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1272         if (index < 0)
1273           throw std::out_of_range("index");
1274         if (count < 0)
1275           throw std::out_of_range("count");
1276         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1277           throw std::invalid_argument("invalid range");
1278         self->erase(self->begin()+index, self->begin()+index+count);
1279       }
1280 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1281         if (count < 0)
1282           throw std::out_of_range("count");
1283         return new std::vector< Dali::Actor >(count, value);
1284       }
1285 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1286         std::reverse(self->begin(), self->end());
1287       }
1288 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1289         if (index < 0)
1290           throw std::out_of_range("index");
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1294           throw std::invalid_argument("invalid range");
1295         std::reverse(self->begin()+index, self->begin()+index+count);
1296       }
1297 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1298         if (index < 0)
1299           throw std::out_of_range("index");
1300         if (index+values.size() > self->size())
1301           throw std::out_of_range("index");
1302         std::copy(values.begin(), values.end(), self->begin()+index);
1303       }
1304 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1305          return self->Empty();
1306       }
1307 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1308         return self->GetConnectionCount();
1309       }
1310 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 &)){
1311           self->Connect( func );
1312       }
1313 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 &)){
1314           self->Disconnect( func );
1315       }
1316 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){
1317           return self->Emit( arg );
1318       }
1319 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){
1320          return self->Empty();
1321       }
1322 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){
1323         return self->GetConnectionCount();
1324       }
1325 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)){
1326         self->Connect( func );
1327       }
1328 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)){
1329         self->Disconnect( func );
1330       }
1331 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){
1332         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1333 /*@SWIG@*/ self->Emit( arg1, arg2 );
1334       }
1335 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1336          return self->Empty();
1337       }
1338 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){
1339         return self->GetConnectionCount();
1340       }
1341 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)){
1342         self->Connect( func );
1343       }
1344 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)){
1345         self->Disconnect( func );
1346       }
1347 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){
1348         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1349 /*@SWIG@*/ self->Emit( arg1, arg2 );
1350       }
1351 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1352          return self->Empty();
1353       }
1354 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1355         return self->GetConnectionCount();
1356       }
1357 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)){
1358         self->Connect( func );
1359       }
1360 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)){
1361         self->Disconnect( func );
1362       }
1363 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){
1364         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1365 /*@SWIG@*/ self->Emit( arg1, arg2 );
1366       }
1367 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){
1368          return self->Empty();
1369       }
1370 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){
1371         return self->GetConnectionCount();
1372       }
1373 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)){
1374         self->Connect( func );
1375       }
1376 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)){
1377         self->Disconnect( func );
1378       }
1379 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){
1380         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1381 /*@SWIG@*/ self->Emit( arg1, arg2 );
1382       }
1383 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1384          return self->Empty();
1385       }
1386 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1387         return self->GetConnectionCount();
1388       }
1389 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1390           self->Connect( func );
1391       }
1392 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1393           self->Disconnect( func );
1394       }
1395 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1396           return self->Emit( arg );
1397       }
1398 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1399          return self->Empty();
1400       }
1401 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1402         return self->GetConnectionCount();
1403       }
1404 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)){
1405           self->Connect( func );
1406       }
1407 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)){
1408           self->Disconnect( func );
1409       }
1410 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1411           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1412 /*@SWIG@*/ self->Emit( arg );
1413       }
1414 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){
1415          return self->Empty();
1416       }
1417 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){
1418         return self->GetConnectionCount();
1419       }
1420 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)){
1421           return self->Connect( func );
1422       }
1423 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)){
1424           self->Disconnect( func );
1425       }
1426 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){
1427           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1428 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1429       }
1430 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1431          return self->Empty();
1432       }
1433 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1434         return self->GetConnectionCount();
1435       }
1436 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)){
1437           self->Connect( func );
1438       }
1439 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)){
1440           self->Disconnect( func );
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1443           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1444 /*@SWIG@*/ self->Emit( arg );
1445       }
1446 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1447          return self->Empty();
1448       }
1449 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1450         return self->GetConnectionCount();
1451       }
1452 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1453           return self->Connect( func );
1454       }
1455 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1456           self->Disconnect( func );
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1459           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1460 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1461       }
1462 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){
1463          return self->Empty();
1464       }
1465 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){
1466         return self->GetConnectionCount();
1467       }
1468 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 &)){
1469           self->Connect( func );
1470       }
1471 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 &)){
1472           self->Disconnect( func );
1473       }
1474 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){
1475           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1476 /*@SWIG@*/ self->Emit( arg );
1477       }
1478 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1479          return self->Empty();
1480       }
1481 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){
1482         return self->GetConnectionCount();
1483       }
1484 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 &)){
1485           self->Connect( func );
1486       }
1487 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 &)){
1488           self->Disconnect( func );
1489       }
1490 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){
1491           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1492 /*@SWIG@*/ self->Emit( arg );
1493       }
1494
1495
1496 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){
1497          return self->Empty();
1498       }
1499 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){
1500         return self->GetConnectionCount();
1501       }
1502 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 &)){
1503         self->Connect( func );
1504       }
1505 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 &)){
1506         self->Disconnect( func );
1507       }
1508 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){
1509         return self->Emit( arg1, arg2 );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 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)){
1518           self->Connect( func );
1519       }
1520 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)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 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 &)){
1534           self->Connect( func );
1535       }
1536 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 &)){
1537           self->Disconnect( func );
1538       }
1539 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){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1550         self->Connect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1553         self->Disconnect( func );
1554       }
1555 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1556         return self->Emit( arg1, arg2 );
1557       }
1558 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1559          return self->Empty();
1560       }
1561 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1562         return self->GetConnectionCount();
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1565         self->Connect( func );
1566       }
1567 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1568         self->Disconnect( func );
1569       }
1570 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1571         return self->Emit( arg1, arg2 );
1572       }
1573
1574 /* ---------------------------------------------------
1575  * C++ director class methods
1576  * --------------------------------------------------- */
1577
1578 #include "dali-wrap.h"
1579
1580 /*
1581  *  Widget director
1582  */
1583 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1584   swig_init_callbacks();
1585 }
1586
1587 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1588 }
1589
1590 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1591   char * jcontentInfo = 0 ;
1592   void * jwindow  ;
1593
1594   if (!swig_callbackOnCreate) {
1595     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1596     return;
1597   } else {
1598     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1599     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1600     swig_callbackOnCreate(jcontentInfo, jwindow);
1601   }
1602 }
1603
1604 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1605   char * jcontentInfo = 0 ;
1606   int jtype  ;
1607
1608   if (!swig_callbackOnTerminate) {
1609     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1610     return;
1611   } else {
1612     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1613     jtype = (int)type;
1614     swig_callbackOnTerminate(jcontentInfo, jtype);
1615   }
1616 }
1617
1618 void SwigDirector_WidgetImpl::OnPause() {
1619   if (!swig_callbackOnPause) {
1620     Dali::Internal::Adaptor::Widget::OnPause();
1621     return;
1622   } else {
1623     swig_callbackOnPause();
1624   }
1625 }
1626
1627 void SwigDirector_WidgetImpl::OnResume() {
1628   if (!swig_callbackOnResume) {
1629     Dali::Internal::Adaptor::Widget::OnResume();
1630     return;
1631   } else {
1632     swig_callbackOnResume();
1633   }
1634 }
1635
1636 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1637   void * jwindow  ;
1638
1639   if (!swig_callbackOnResize) {
1640     Dali::Internal::Adaptor::Widget::OnResize(window);
1641     return;
1642   } else {
1643     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1644     swig_callbackOnResize(jwindow);
1645   }
1646 }
1647
1648 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1649   char * jcontentInfo = 0 ;
1650   int jforce  ;
1651
1652   if (!swig_callbackOnUpdate) {
1653     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1654     return;
1655   } else {
1656     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1657     jforce = force;
1658     swig_callbackOnUpdate(jcontentInfo, jforce);
1659   }
1660 }
1661
1662 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1663   void * jslotObserver = 0 ;
1664   void * jcallback = 0 ;
1665
1666   if (!swig_callbackSignalConnected) {
1667     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1668     return;
1669   } else {
1670     jslotObserver = (void *) slotObserver;
1671     jcallback = (void *) callback;
1672     swig_callbackSignalConnected(jslotObserver, jcallback);
1673   }
1674 }
1675
1676 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1677   void * jslotObserver = 0 ;
1678   void * jcallback = 0 ;
1679
1680   if (!swig_callbackSignalDisconnected) {
1681     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1682     return;
1683   } else {
1684     jslotObserver = (void *) slotObserver;
1685     jcallback = (void *) callback;
1686     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1687   }
1688 }
1689
1690 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) {
1691
1692   swig_callbackOnCreate = callbackOnCreate;
1693   swig_callbackOnTerminate = callbackOnTerminate;
1694   swig_callbackOnPause = callbackOnPause;
1695   swig_callbackOnResume = callbackOnResume;
1696   swig_callbackOnResize = callbackOnResize;
1697   swig_callbackOnUpdate = callbackOnUpdate;
1698   swig_callbackSignalConnected = callbackSignalConnected;
1699   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1700 }
1701
1702 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1703   swig_callbackOnCreate = 0;
1704   swig_callbackOnTerminate = 0;
1705   swig_callbackOnPause = 0;
1706   swig_callbackOnResume = 0;
1707   swig_callbackOnResize = 0;
1708   swig_callbackOnUpdate = 0;
1709   swig_callbackSignalConnected = 0;
1710   swig_callbackSignalDisconnected = 0;
1711 }
1712
1713
1714 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1715   swig_init_callbacks();
1716 }
1717
1718 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1719
1720 }
1721
1722
1723 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1724   int jdepth  ;
1725
1726   if (!swig_callbackOnSceneConnection) {
1727     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1728     return;
1729   } else {
1730     jdepth = depth;
1731     swig_callbackOnSceneConnection(jdepth);
1732   }
1733 }
1734
1735 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1736   if (!swig_callbackOnSceneDisconnection) {
1737     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1738     return;
1739   } else {
1740     swig_callbackOnSceneDisconnection();
1741   }
1742 }
1743
1744 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1745   void * jchild = 0 ;
1746
1747   if (!swig_callbackOnChildAdd) {
1748     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1749     return;
1750   } else {
1751     jchild = (Dali::Actor *) &child;
1752     swig_callbackOnChildAdd(jchild);
1753   }
1754 }
1755
1756 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1757   void * jchild = 0 ;
1758
1759   if (!swig_callbackOnChildRemove) {
1760     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1761     return;
1762   } else {
1763     jchild = (Dali::Actor *) &child;
1764     swig_callbackOnChildRemove(jchild);
1765   }
1766 }
1767
1768 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1769   int jindex  ;
1770   void * jpropertyValue  ;
1771
1772   if (!swig_callbackOnPropertySet) {
1773     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1774     return;
1775   } else {
1776     jindex = index;
1777     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1778     swig_callbackOnPropertySet(jindex, jpropertyValue);
1779   }
1780 }
1781
1782 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1783   void * jtargetSize = 0 ;
1784
1785   if (!swig_callbackOnSizeSet) {
1786     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1787     return;
1788   } else {
1789     jtargetSize = (Dali::Vector3 *) &targetSize;
1790     swig_callbackOnSizeSet(jtargetSize);
1791   }
1792 }
1793
1794 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1795   void * janimation = 0 ;
1796   void * jtargetSize = 0 ;
1797
1798   if (!swig_callbackOnSizeAnimation) {
1799     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1800     return;
1801   } else {
1802     janimation = (Dali::Animation *) &animation;
1803     jtargetSize = (Dali::Vector3 *) &targetSize;
1804     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1805   }
1806 }
1807
1808 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1809   bool c_result = SwigValueInit< bool >() ;
1810   unsigned int jresult = 0 ;
1811   void * jarg0 = 0 ;
1812
1813   if (!swig_callbackOnKeyEvent) {
1814     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1815   } else {
1816     jarg0 = (Dali::KeyEvent *) &event;
1817     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1818     c_result = jresult ? true : false;
1819   }
1820   return c_result;
1821 }
1822
1823 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1824   void * jsize = 0 ;
1825   void * jcontainer = 0 ;
1826
1827   if (!swig_callbackOnRelayout) {
1828     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1829     return;
1830   } else {
1831     jsize = (Dali::Vector2 *) &size;
1832     jcontainer = (Dali::RelayoutContainer *) &container;
1833     swig_callbackOnRelayout(jsize, jcontainer);
1834   }
1835 }
1836
1837 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1838   int jpolicy  ;
1839   int jdimension  ;
1840
1841   if (!swig_callbackOnSetResizePolicy) {
1842     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1843     return;
1844   } else {
1845     jpolicy = (int)policy;
1846     jdimension = (int)dimension;
1847     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1848   }
1849 }
1850
1851 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1852   Dali::Vector3 c_result ;
1853   void * jresult = 0 ;
1854
1855   if (!swig_callbackGetNaturalSize) {
1856     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1857   } else {
1858     jresult = (void *) swig_callbackGetNaturalSize();
1859     if (!jresult) {
1860       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1861       return c_result;
1862     }
1863     c_result = *(Dali::Vector3 *)jresult;
1864   }
1865   return c_result;
1866 }
1867
1868 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1869   float c_result = SwigValueInit< float >() ;
1870   float jresult = 0 ;
1871   void * jchild = 0 ;
1872   int jdimension  ;
1873
1874   if (!swig_callbackCalculateChildSize) {
1875     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1876   } else {
1877     jchild = (Dali::Actor *) &child;
1878     jdimension = (int)dimension;
1879     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1880     c_result = (float)jresult;
1881   }
1882   return c_result;
1883 }
1884
1885 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1886   float c_result = SwigValueInit< float >() ;
1887   float jresult = 0 ;
1888   float jwidth  ;
1889
1890   if (!swig_callbackGetHeightForWidth) {
1891     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1892   } else {
1893     jwidth = width;
1894     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1895     c_result = (float)jresult;
1896   }
1897   return c_result;
1898 }
1899
1900 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1901   float c_result = SwigValueInit< float >() ;
1902   float jresult = 0 ;
1903   float jheight  ;
1904
1905   if (!swig_callbackGetWidthForHeight) {
1906     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1907   } else {
1908     jheight = height;
1909     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1910     c_result = (float)jresult;
1911   }
1912   return c_result;
1913 }
1914
1915 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1916   bool c_result = SwigValueInit< bool >() ;
1917   unsigned int jresult = 0 ;
1918   int jdimension  ;
1919
1920   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1921     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1922   } else {
1923     jdimension = (int)dimension;
1924     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1925     c_result = jresult ? true : false;
1926   }
1927   return c_result;
1928 }
1929
1930 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1931   int jdimension  ;
1932
1933   if (!swig_callbackOnCalculateRelayoutSize) {
1934     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1935     return;
1936   } else {
1937     jdimension = (int)dimension;
1938     swig_callbackOnCalculateRelayoutSize(jdimension);
1939   }
1940 }
1941
1942 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1943   float jsize  ;
1944   int jdimension  ;
1945
1946   if (!swig_callbackOnLayoutNegotiated) {
1947     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1948     return;
1949   } else {
1950     jsize = size;
1951     jdimension = (int)dimension;
1952     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1953   }
1954 }
1955
1956 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1957   return Dali::CustomActorImpl::GetExtension();
1958 }
1959
1960 void SwigDirector_ViewImpl::OnInitialize() {
1961   if (!swig_callbackOnInitialize) {
1962     Dali::Toolkit::Internal::Control::OnInitialize();
1963     return;
1964   } else {
1965     swig_callbackOnInitialize();
1966   }
1967 }
1968
1969 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1970   void * jstyleManager  ;
1971   int jchange  ;
1972
1973   if (!swig_callbackOnStyleChange) {
1974     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1975     return;
1976   } else {
1977     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1978     jchange = (int)change;
1979     swig_callbackOnStyleChange(jstyleManager, jchange);
1980   }
1981 }
1982
1983 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1984   bool c_result = SwigValueInit< bool >() ;
1985   unsigned int jresult = 0 ;
1986
1987   if (!swig_callbackOnAccessibilityActivated) {
1988     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1989   } else {
1990     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1991     c_result = jresult ? true : false;
1992   }
1993   return c_result;
1994 }
1995
1996 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1997   bool c_result = SwigValueInit< bool >() ;
1998   unsigned int jresult = 0 ;
1999   void * jgesture  ;
2000
2001   if (!swig_callbackOnAccessibilityPan) {
2002     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2003   } else {
2004     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2005     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2006     c_result = jresult ? true : false;
2007   }
2008   return c_result;
2009 }
2010
2011 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2012   bool c_result = SwigValueInit< bool >() ;
2013   unsigned int jresult = 0 ;
2014   unsigned int jisIncrease  ;
2015
2016   if (!swig_callbackOnAccessibilityValueChange) {
2017     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2018   } else {
2019     jisIncrease = isIncrease;
2020     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2021     c_result = jresult ? true : false;
2022   }
2023   return c_result;
2024 }
2025
2026 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2027   bool c_result = SwigValueInit< bool >() ;
2028   unsigned int jresult = 0 ;
2029
2030   if (!swig_callbackOnAccessibilityZoom) {
2031     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2032   } else {
2033     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2034     c_result = jresult ? true : false;
2035   }
2036   return c_result;
2037 }
2038
2039 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2040   if (!swig_callbackOnKeyInputFocusGained) {
2041     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2042     return;
2043   } else {
2044     swig_callbackOnKeyInputFocusGained();
2045   }
2046 }
2047
2048 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2049   if (!swig_callbackOnKeyInputFocusLost) {
2050     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2051     return;
2052   } else {
2053     swig_callbackOnKeyInputFocusLost();
2054   }
2055 }
2056
2057 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2058   Dali::Actor c_result ;
2059   void * jresult = 0 ;
2060   void * jcurrentFocusedActor  ;
2061   int jdirection  ;
2062   unsigned int jloopEnabled  ;
2063
2064   if (!swig_callbackGetNextKeyboardFocusableActor) {
2065     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2066   } else {
2067     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2068     jdirection = (int)direction;
2069     jloopEnabled = loopEnabled;
2070     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2071     if (!jresult) {
2072       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2073       return c_result;
2074     }
2075     c_result = *(Dali::Actor *)jresult;
2076   }
2077   return c_result;
2078 }
2079
2080 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2081   void * jcommitedFocusableActor  ;
2082
2083   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2084     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2085     return;
2086   } else {
2087     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2088     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2089   }
2090 }
2091
2092 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2093   bool c_result = SwigValueInit< bool >() ;
2094   unsigned int jresult = 0 ;
2095
2096   if (!swig_callbackOnKeyboardEnter) {
2097     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2098   } else {
2099     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2100     c_result = jresult ? true : false;
2101   }
2102   return c_result;
2103 }
2104
2105 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2106   void * jpinch = 0 ;
2107
2108   if (!swig_callbackOnPinch) {
2109     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2110     return;
2111   } else {
2112     jpinch = (Dali::PinchGesture *) &pinch;
2113     swig_callbackOnPinch(jpinch);
2114   }
2115 }
2116
2117 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2118   void * jpan = 0 ;
2119
2120   if (!swig_callbackOnPan) {
2121     Dali::Toolkit::Internal::Control::OnPan(pan);
2122     return;
2123   } else {
2124     jpan = (Dali::PanGesture *) &pan;
2125     swig_callbackOnPan(jpan);
2126   }
2127 }
2128
2129 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2130   void * jtap = 0 ;
2131
2132   if (!swig_callbackOnTap) {
2133     Dali::Toolkit::Internal::Control::OnTap(tap);
2134     return;
2135   } else {
2136     jtap = (Dali::TapGesture *) &tap;
2137     swig_callbackOnTap(jtap);
2138   }
2139 }
2140
2141 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2142   void * jlongPress = 0 ;
2143
2144   if (!swig_callbackOnLongPress) {
2145     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2146     return;
2147   } else {
2148     jlongPress = (Dali::LongPressGesture *) &longPress;
2149     swig_callbackOnLongPress(jlongPress);
2150   }
2151 }
2152
2153 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2154   void * jslotObserver = 0 ;
2155   void * jcallback = 0 ;
2156
2157   if (!swig_callbackSignalConnected) {
2158     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2159     return;
2160   } else {
2161     jslotObserver = (void *) slotObserver;
2162     jcallback = (void *) callback;
2163     swig_callbackSignalConnected(jslotObserver, jcallback);
2164   }
2165 }
2166
2167 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2168   void * jslotObserver = 0 ;
2169   void * jcallback = 0 ;
2170
2171   if (!swig_callbackSignalDisconnected) {
2172     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2173     return;
2174   } else {
2175     jslotObserver = (void *) slotObserver;
2176     jcallback = (void *) callback;
2177     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2178   }
2179 }
2180
2181 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2182   return Dali::Toolkit::Internal::Control::GetControlExtension();
2183 }
2184
2185 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) {
2186   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2187   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2188   swig_callbackOnChildAdd = callbackOnChildAdd;
2189   swig_callbackOnChildRemove = callbackOnChildRemove;
2190   swig_callbackOnPropertySet = callbackOnPropertySet;
2191   swig_callbackOnSizeSet = callbackOnSizeSet;
2192   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2193   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2194   swig_callbackOnRelayout = callbackOnRelayout;
2195   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2196   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2197   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2198   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2199   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2200   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2201   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2202   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2203   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2204   swig_callbackOnInitialize = callbackOnInitialize;
2205   swig_callbackOnStyleChange = callbackOnStyleChange;
2206   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2207   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2208   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2209   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2210   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2211   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2212   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2213   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2214   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2215   swig_callbackOnPinch = callbackOnPinch;
2216   swig_callbackOnPan = callbackOnPan;
2217   swig_callbackOnTap = callbackOnTap;
2218   swig_callbackOnLongPress = callbackOnLongPress;
2219   swig_callbackSignalConnected = callbackSignalConnected;
2220   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2221 }
2222
2223 void SwigDirector_ViewImpl::swig_init_callbacks() {
2224   swig_callbackOnSceneConnection = 0;
2225   swig_callbackOnSceneDisconnection = 0;
2226   swig_callbackOnChildAdd = 0;
2227   swig_callbackOnChildRemove = 0;
2228   swig_callbackOnPropertySet = 0;
2229   swig_callbackOnSizeSet = 0;
2230   swig_callbackOnSizeAnimation = 0;
2231   swig_callbackOnKeyEvent = 0;
2232   swig_callbackOnRelayout = 0;
2233   swig_callbackOnSetResizePolicy = 0;
2234   swig_callbackGetNaturalSize = 0;
2235   swig_callbackCalculateChildSize = 0;
2236   swig_callbackGetHeightForWidth = 0;
2237   swig_callbackGetWidthForHeight = 0;
2238   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2239   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2240   swig_callbackOnCalculateRelayoutSize = 0;
2241   swig_callbackOnLayoutNegotiated = 0;
2242   swig_callbackOnInitialize = 0;
2243   swig_callbackOnStyleChange = 0;
2244   swig_callbackOnAccessibilityActivated = 0;
2245   swig_callbackOnAccessibilityPan = 0;
2246   swig_callbackOnAccessibilityValueChange = 0;
2247   swig_callbackOnAccessibilityZoom = 0;
2248   swig_callbackOnKeyInputFocusGained = 0;
2249   swig_callbackOnKeyInputFocusLost = 0;
2250   swig_callbackGetNextKeyboardFocusableActor = 0;
2251   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2252   swig_callbackOnKeyboardEnter = 0;
2253   swig_callbackOnPinch = 0;
2254   swig_callbackOnPan = 0;
2255   swig_callbackOnTap = 0;
2256   swig_callbackOnLongPress = 0;
2257   swig_callbackSignalConnected = 0;
2258   swig_callbackSignalDisconnected = 0;
2259 }
2260
2261 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2262   swig_init_callbacks();
2263 }
2264
2265 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2266
2267 }
2268
2269
2270 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2271   unsigned int c_result = SwigValueInit< unsigned int >() ;
2272   unsigned int jresult = 0 ;
2273
2274   if (!swig_callbackGetNumberOfItems) {
2275     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2276   } else {
2277     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2278     c_result = (unsigned int)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2284   Dali::Actor c_result ;
2285   void * jresult = 0 ;
2286   unsigned int jitemId  ;
2287
2288   if (!swig_callbackNewItem) {
2289     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2290   } else {
2291     jitemId = itemId;
2292     jresult = (void *) swig_callbackNewItem(jitemId);
2293     if (!jresult) {
2294       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2295       return c_result;
2296     }
2297     c_result = *(Dali::Actor *)jresult;
2298   }
2299   return c_result;
2300 }
2301
2302 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2303   unsigned int jitemId  ;
2304   void * jactor  ;
2305
2306   if (!swig_callbackItemReleased) {
2307     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2308     return;
2309   } else {
2310     jitemId = itemId;
2311     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2312     swig_callbackItemReleased(jitemId, jactor);
2313   }
2314 }
2315
2316 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2317   return Dali::Toolkit::ItemFactory::GetExtension();
2318 }
2319
2320 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2321   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2322   swig_callbackNewItem = callbackNewItem;
2323   swig_callbackItemReleased = callbackItemReleased;
2324 }
2325
2326 void SwigDirector_ItemFactory::swig_init_callbacks() {
2327   swig_callbackGetNumberOfItems = 0;
2328   swig_callbackNewItem = 0;
2329   swig_callbackItemReleased = 0;
2330 }
2331
2332 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2333   swig_init_callbacks();
2334 }
2335
2336 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2337
2338 }
2339
2340
2341 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName) {
2342   Dali::Actor c_result ;
2343   void * jresult = 0 ;
2344   void * jcurrent  ;
2345   void * jproposed  ;
2346   int jdirection  ;
2347
2348   if (!swig_callbackGetNextFocusableActor) {
2349     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2350   } else {
2351     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2352     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2353     jdirection = (int)direction;
2354     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection, deviceName.c_str());
2355     if (!jresult) {
2356       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__);
2357       return c_result;
2358     }
2359     c_result = *(Dali::Actor *)jresult;
2360   }
2361   return c_result;
2362 }
2363
2364 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2365   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2366 }
2367
2368 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2369   swig_callbackGetNextFocusableActor = 0;
2370 }
2371
2372 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2373   swig_callbackOnUpdate = 0;
2374 }
2375
2376 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2377
2378 }
2379
2380 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2381   swig_callbackOnUpdate = callbackUpdate;
2382 }
2383
2384
2385 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2386   void * jcurrent  ;
2387
2388   if (!swig_callbackOnUpdate) {
2389     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2390   } else {
2391     Dali::UpdateProxy* proxy = &updateProxy;
2392     jcurrent = (void *)proxy;
2393     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2394     if (!jcurrent) {
2395       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2396       return;
2397     }
2398   }
2399   return;
2400 }
2401
2402
2403 #ifdef __cplusplus
2404 extern "C" {
2405 #endif
2406
2407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2408   void * jresult ;
2409   floatp *result = 0 ;
2410
2411   {
2412     try {
2413       result = (floatp *)new_floatp();
2414     } CALL_CATCH_EXCEPTION(0);
2415   }
2416   jresult = (void *)result;
2417   return jresult;
2418 }
2419
2420
2421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2422   floatp *arg1 = (floatp *) 0 ;
2423
2424   arg1 = (floatp *)jarg1;
2425   {
2426     try {
2427       delete_floatp(arg1);
2428     } CALL_CATCH_EXCEPTION();
2429   }
2430
2431 }
2432
2433
2434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2435   floatp *arg1 = (floatp *) 0 ;
2436   float arg2 ;
2437
2438   arg1 = (floatp *)jarg1;
2439   arg2 = (float)jarg2;
2440   {
2441     try {
2442       floatp_assign(arg1,arg2);
2443     } CALL_CATCH_EXCEPTION();
2444   }
2445
2446 }
2447
2448
2449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2450   float jresult ;
2451   floatp *arg1 = (floatp *) 0 ;
2452   float result;
2453
2454   arg1 = (floatp *)jarg1;
2455   {
2456     try {
2457       result = (float)floatp_value(arg1);
2458     } CALL_CATCH_EXCEPTION(0);
2459   }
2460   jresult = result;
2461   return jresult;
2462 }
2463
2464
2465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2466   void * jresult ;
2467   floatp *arg1 = (floatp *) 0 ;
2468   float *result = 0 ;
2469
2470   arg1 = (floatp *)jarg1;
2471   {
2472     try {
2473       result = (float *)floatp_cast(arg1);
2474     } CALL_CATCH_EXCEPTION(0);
2475   }
2476
2477   jresult = (void *)result;
2478   return jresult;
2479 }
2480
2481
2482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2483   void * jresult ;
2484   float *arg1 = (float *) 0 ;
2485   floatp *result = 0 ;
2486
2487   arg1 = (float *)jarg1;
2488   {
2489     try {
2490       result = (floatp *)floatp_frompointer(arg1);
2491     } CALL_CATCH_EXCEPTION(0);
2492   }
2493
2494   jresult = (void *)result;
2495   return jresult;
2496 }
2497
2498
2499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2500   void * jresult ;
2501   intp *result = 0 ;
2502
2503   {
2504     try {
2505       result = (intp *)new_intp();
2506     } CALL_CATCH_EXCEPTION(0);
2507   }
2508
2509   jresult = (void *)result;
2510   return jresult;
2511 }
2512
2513
2514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2515   intp *arg1 = (intp *) 0 ;
2516
2517   arg1 = (intp *)jarg1;
2518   {
2519     try {
2520       delete_intp(arg1);
2521     } CALL_CATCH_EXCEPTION();
2522   }
2523
2524 }
2525
2526
2527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2528   intp *arg1 = (intp *) 0 ;
2529   int arg2 ;
2530
2531   arg1 = (intp *)jarg1;
2532   arg2 = (int)jarg2;
2533   {
2534     try {
2535       intp_assign(arg1,arg2);
2536     } CALL_CATCH_EXCEPTION();
2537   }
2538
2539 }
2540
2541
2542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2543   int jresult ;
2544   intp *arg1 = (intp *) 0 ;
2545   int result;
2546
2547   arg1 = (intp *)jarg1;
2548   {
2549     try {
2550       result = (int)intp_value(arg1);
2551     } CALL_CATCH_EXCEPTION(0);
2552   }
2553
2554   jresult = result;
2555   return jresult;
2556 }
2557
2558
2559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2560   void * jresult ;
2561   intp *arg1 = (intp *) 0 ;
2562   int *result = 0 ;
2563
2564   arg1 = (intp *)jarg1;
2565   {
2566     try {
2567       result = (int *)intp_cast(arg1);
2568     } CALL_CATCH_EXCEPTION(0);
2569   }
2570
2571   jresult = (void *)result;
2572   return jresult;
2573 }
2574
2575
2576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2577   void * jresult ;
2578   int *arg1 = (int *) 0 ;
2579   intp *result = 0 ;
2580
2581   arg1 = (int *)jarg1;
2582   {
2583     try {
2584       result = (intp *)intp_frompointer(arg1);
2585     } CALL_CATCH_EXCEPTION(0);
2586   }
2587
2588   jresult = (void *)result;
2589   return jresult;
2590 }
2591
2592
2593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2594   void * jresult ;
2595   doublep *result = 0 ;
2596
2597   {
2598     try {
2599       result = (doublep *)new_doublep();
2600     } CALL_CATCH_EXCEPTION(0);
2601   }
2602
2603   jresult = (void *)result;
2604   return jresult;
2605 }
2606
2607
2608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2609   doublep *arg1 = (doublep *) 0 ;
2610
2611   arg1 = (doublep *)jarg1;
2612   {
2613     try {
2614       delete_doublep(arg1);
2615     } CALL_CATCH_EXCEPTION();
2616   }
2617
2618 }
2619
2620
2621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2622   doublep *arg1 = (doublep *) 0 ;
2623   double arg2 ;
2624
2625   arg1 = (doublep *)jarg1;
2626   arg2 = (double)jarg2;
2627   {
2628     try {
2629       doublep_assign(arg1,arg2);
2630     } CALL_CATCH_EXCEPTION();
2631   }
2632
2633 }
2634
2635
2636 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2637   double jresult ;
2638   doublep *arg1 = (doublep *) 0 ;
2639   double result;
2640
2641   arg1 = (doublep *)jarg1;
2642   {
2643     try {
2644       result = (double)doublep_value(arg1);
2645     } CALL_CATCH_EXCEPTION(0);
2646   }
2647
2648   jresult = result;
2649   return jresult;
2650 }
2651
2652
2653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2654   void * jresult ;
2655   doublep *arg1 = (doublep *) 0 ;
2656   double *result = 0 ;
2657
2658   arg1 = (doublep *)jarg1;
2659   {
2660     try {
2661       result = (double *)doublep_cast(arg1);
2662     } CALL_CATCH_EXCEPTION(0);
2663   }
2664
2665   jresult = (void *)result;
2666   return jresult;
2667 }
2668
2669
2670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2671   void * jresult ;
2672   double *arg1 = (double *) 0 ;
2673   doublep *result = 0 ;
2674
2675   arg1 = (double *)jarg1;
2676   {
2677     try {
2678       result = (doublep *)doublep_frompointer(arg1);
2679     } CALL_CATCH_EXCEPTION(0);
2680   }
2681
2682   jresult = (void *)result;
2683   return jresult;
2684 }
2685
2686
2687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2688   void * jresult ;
2689   uintp *result = 0 ;
2690
2691   {
2692     try {
2693       result = (uintp *)new_uintp();
2694     } CALL_CATCH_EXCEPTION(0);
2695   }
2696
2697   jresult = (void *)result;
2698   return jresult;
2699 }
2700
2701
2702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2703   uintp *arg1 = (uintp *) 0 ;
2704
2705   arg1 = (uintp *)jarg1;
2706   {
2707     try {
2708       delete_uintp(arg1);
2709     } CALL_CATCH_EXCEPTION();
2710   }
2711
2712 }
2713
2714
2715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2716   uintp *arg1 = (uintp *) 0 ;
2717   unsigned int arg2 ;
2718
2719   arg1 = (uintp *)jarg1;
2720   arg2 = (unsigned int)jarg2;
2721   {
2722     try {
2723       uintp_assign(arg1,arg2);
2724     } CALL_CATCH_EXCEPTION();
2725   }
2726
2727 }
2728
2729
2730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2731   unsigned int jresult ;
2732   uintp *arg1 = (uintp *) 0 ;
2733   unsigned int result;
2734
2735   arg1 = (uintp *)jarg1;
2736   {
2737     try {
2738       result = (unsigned int)uintp_value(arg1);
2739     } CALL_CATCH_EXCEPTION(0);
2740   }
2741
2742   jresult = result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2748   void * jresult ;
2749   uintp *arg1 = (uintp *) 0 ;
2750   unsigned int *result = 0 ;
2751
2752   arg1 = (uintp *)jarg1;
2753   {
2754     try {
2755       result = (unsigned int *)uintp_cast(arg1);
2756     } CALL_CATCH_EXCEPTION(0);
2757   }
2758
2759   jresult = (void *)result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2765   void * jresult ;
2766   unsigned int *arg1 = (unsigned int *) 0 ;
2767   uintp *result = 0 ;
2768
2769   arg1 = (unsigned int *)jarg1;
2770   {
2771     try {
2772       result = (uintp *)uintp_frompointer(arg1);
2773     } CALL_CATCH_EXCEPTION(0);
2774   }
2775
2776   jresult = (void *)result;
2777   return jresult;
2778 }
2779
2780
2781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2782   void * jresult ;
2783   ushortp *result = 0 ;
2784
2785   {
2786     try {
2787       result = (ushortp *)new_ushortp();
2788     } CALL_CATCH_EXCEPTION(0);
2789   }
2790
2791   jresult = (void *)result;
2792   return jresult;
2793 }
2794
2795
2796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2797   ushortp *arg1 = (ushortp *) 0 ;
2798
2799   arg1 = (ushortp *)jarg1;
2800   {
2801     try {
2802       delete_ushortp(arg1);
2803     } CALL_CATCH_EXCEPTION();
2804   }
2805
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2810   ushortp *arg1 = (ushortp *) 0 ;
2811   unsigned short arg2 ;
2812
2813   arg1 = (ushortp *)jarg1;
2814   arg2 = (unsigned short)jarg2;
2815   {
2816     try {
2817       ushortp_assign(arg1,arg2);
2818     } CALL_CATCH_EXCEPTION();
2819   }
2820
2821 }
2822
2823
2824 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2825   unsigned short jresult ;
2826   ushortp *arg1 = (ushortp *) 0 ;
2827   unsigned short result;
2828
2829   arg1 = (ushortp *)jarg1;
2830   {
2831     try {
2832       result = (unsigned short)ushortp_value(arg1);
2833     } CALL_CATCH_EXCEPTION(0);
2834   }
2835
2836   jresult = result;
2837   return jresult;
2838 }
2839
2840
2841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2842   void * jresult ;
2843   ushortp *arg1 = (ushortp *) 0 ;
2844   unsigned short *result = 0 ;
2845
2846   arg1 = (ushortp *)jarg1;
2847   {
2848     try {
2849       result = (unsigned short *)ushortp_cast(arg1);
2850     } CALL_CATCH_EXCEPTION(0);
2851   }
2852
2853   jresult = (void *)result;
2854   return jresult;
2855 }
2856
2857
2858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2859   void * jresult ;
2860   unsigned short *arg1 = (unsigned short *) 0 ;
2861   ushortp *result = 0 ;
2862
2863   arg1 = (unsigned short *)jarg1;
2864   {
2865     try {
2866       result = (ushortp *)ushortp_frompointer(arg1);
2867     } CALL_CATCH_EXCEPTION(0);
2868   }
2869
2870   jresult = (void *)result;
2871   return jresult;
2872 }
2873
2874
2875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2876   unsigned int jresult ;
2877   int arg1 ;
2878   unsigned int result;
2879
2880   arg1 = (int)jarg1;
2881   {
2882     try {
2883       result = (unsigned int)int_to_uint(arg1);
2884     } CALL_CATCH_EXCEPTION(0);
2885   }
2886
2887   jresult = result;
2888   return jresult;
2889 }
2890
2891
2892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2893   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2894
2895   arg1 = (Dali::RefObject *)jarg1;
2896   {
2897     try {
2898       (arg1)->Reference();
2899     } CALL_CATCH_EXCEPTION();
2900   }
2901
2902 }
2903
2904
2905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2906   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2907
2908   arg1 = (Dali::RefObject *)jarg1;
2909   {
2910     try {
2911       (arg1)->Unreference();
2912     } CALL_CATCH_EXCEPTION();
2913   }
2914
2915 }
2916
2917
2918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2919   int jresult ;
2920   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2921   int result;
2922
2923   arg1 = (Dali::RefObject *)jarg1;
2924   {
2925     try {
2926       result = (int)(arg1)->ReferenceCount();
2927     } CALL_CATCH_EXCEPTION(0);
2928   }
2929
2930   jresult = result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2936   void * jresult ;
2937   Dali::Any *result = 0 ;
2938
2939   {
2940     try {
2941       result = (Dali::Any *)new Dali::Any();
2942     } CALL_CATCH_EXCEPTION(0);
2943   }
2944
2945   jresult = (void *)result;
2946   return jresult;
2947 }
2948
2949
2950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2951   Dali::Any *arg1 = (Dali::Any *) 0 ;
2952
2953   arg1 = (Dali::Any *)jarg1;
2954   {
2955     try {
2956       delete arg1;
2957     } CALL_CATCH_EXCEPTION();
2958   }
2959
2960 }
2961
2962
2963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2964   char *arg1 = (char *) 0 ;
2965
2966   arg1 = (char *)jarg1;
2967   {
2968     try {
2969       Dali::Any::AssertAlways((char const *)arg1);
2970     } CALL_CATCH_EXCEPTION();
2971   }
2972
2973 }
2974
2975
2976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2977   void * jresult ;
2978   Dali::Any *arg1 = 0 ;
2979   Dali::Any *result = 0 ;
2980
2981   arg1 = (Dali::Any *)jarg1;
2982   if (!arg1) {
2983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2984     return 0;
2985   }
2986   {
2987     try {
2988       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2989     } CALL_CATCH_EXCEPTION(0);
2990   }
2991
2992   jresult = (void *)result;
2993   return jresult;
2994 }
2995
2996
2997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
2998   void * jresult ;
2999   Dali::Any *arg1 = (Dali::Any *) 0 ;
3000   Dali::Any *arg2 = 0 ;
3001   Dali::Any *result = 0 ;
3002
3003   arg1 = (Dali::Any *)jarg1;
3004   arg2 = (Dali::Any *)jarg2;
3005   if (!arg2) {
3006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3007     return 0;
3008   }
3009   {
3010     try {
3011       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3012     } CALL_CATCH_EXCEPTION(0);
3013   }
3014
3015   jresult = (void *)result;
3016   return jresult;
3017 }
3018
3019
3020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3021   void * jresult ;
3022   Dali::Any *arg1 = (Dali::Any *) 0 ;
3023   std::type_info *result = 0 ;
3024
3025   arg1 = (Dali::Any *)jarg1;
3026   {
3027     try {
3028       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3029     } CALL_CATCH_EXCEPTION(0);
3030   }
3031
3032   jresult = (void *)result;
3033   return jresult;
3034 }
3035
3036
3037 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3038   bool jresult ;
3039   Dali::Any *arg1 = (Dali::Any *) 0 ;
3040   bool result;
3041
3042   arg1 = (Dali::Any *)jarg1;
3043   {
3044     try {
3045       result = (bool)((Dali::Any const *)arg1)->Empty();
3046     } CALL_CATCH_EXCEPTION(0);
3047   }
3048
3049   jresult = result;
3050   return jresult;
3051 }
3052
3053
3054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3055   void * jresult ;
3056   std::type_info *arg1 = 0 ;
3057   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3058   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3059   Dali::Any::AnyContainerBase *result = 0 ;
3060
3061   arg1 = (std::type_info *)jarg1;
3062   if (!arg1) {
3063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3064     return 0;
3065   }
3066   arg2 = (Dali::Any::CloneFunc)jarg2;
3067   arg3 = (Dali::Any::DeleteFunc)jarg3;
3068   {
3069     try {
3070       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3071     } CALL_CATCH_EXCEPTION(0);
3072   }
3073
3074   jresult = (void *)result;
3075   return jresult;
3076 }
3077
3078
3079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3080   void * jresult ;
3081   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3082   std::type_info *result = 0 ;
3083
3084   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3085   {
3086     try {
3087       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3088     } CALL_CATCH_EXCEPTION(0);
3089   }
3090
3091   jresult = (void *)result;
3092   return jresult;
3093 }
3094
3095
3096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3097   void * jresult ;
3098   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3099   ::std::type_info *result = 0 ;
3100
3101   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3102   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3103   jresult = (void *)result;
3104   return jresult;
3105 }
3106
3107
3108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3109   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3110   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3111
3112   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3113   arg2 = (Dali::Any::CloneFunc)jarg2;
3114   if (arg1) (arg1)->mCloneFunc = arg2;
3115 }
3116
3117
3118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3119   void * jresult ;
3120   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3121   Dali::Any::CloneFunc result;
3122
3123   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3124   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3125   jresult = (void *)result;
3126   return jresult;
3127 }
3128
3129
3130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3131   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3132   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3133
3134   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3135   arg2 = (Dali::Any::DeleteFunc)jarg2;
3136   if (arg1) (arg1)->mDeleteFunc = arg2;
3137 }
3138
3139
3140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3141   void * jresult ;
3142   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3143   Dali::Any::DeleteFunc result;
3144
3145   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3146   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3147   jresult = (void *)result;
3148   return jresult;
3149 }
3150
3151
3152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3153   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3154
3155   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3156   {
3157     try {
3158       delete arg1;
3159     } CALL_CATCH_EXCEPTION();
3160   }
3161
3162 }
3163
3164
3165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3166   Dali::Any *arg1 = (Dali::Any *) 0 ;
3167   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3168
3169   arg1 = (Dali::Any *)jarg1;
3170   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3171   if (arg1) (arg1)->mContainer = arg2;
3172 }
3173
3174
3175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3176   void * jresult ;
3177   Dali::Any *arg1 = (Dali::Any *) 0 ;
3178   Dali::Any::AnyContainerBase *result = 0 ;
3179
3180   arg1 = (Dali::Any *)jarg1;
3181   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3182   jresult = (void *)result;
3183   return jresult;
3184 }
3185
3186
3187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3188   char *arg1 = (char *) 0 ;
3189   char *arg2 = (char *) 0 ;
3190
3191   arg1 = (char *)jarg1;
3192   arg2 = (char *)jarg2;
3193   {
3194     try {
3195       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3196     } CALL_CATCH_EXCEPTION();
3197   }
3198
3199 }
3200
3201
3202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3203   void * jresult ;
3204   char *arg1 = (char *) 0 ;
3205   char *arg2 = (char *) 0 ;
3206   Dali::DaliException *result = 0 ;
3207
3208   arg1 = (char *)jarg1;
3209   arg2 = (char *)jarg2;
3210   {
3211     try {
3212       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3213     } CALL_CATCH_EXCEPTION(0);
3214   }
3215
3216   jresult = (void *)result;
3217   return jresult;
3218 }
3219
3220
3221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3222   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3223   std::string arg2 = std::string(jarg2);
3224
3225   arg1 = (Dali::DaliException *)jarg1;
3226   {
3227     if (!arg2.empty()) {
3228       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3229     } else {
3230       arg1->location = 0;
3231     }
3232   }
3233 }
3234
3235 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3236   char * jresult ;
3237   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3238   char *result = 0 ;
3239
3240   arg1 = (Dali::DaliException *)jarg1;
3241   result = (char *) ((arg1)->location);
3242   jresult = SWIG_csharp_string_callback((const char *)result);
3243   return jresult;
3244 }
3245
3246
3247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3248   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3249   std::string arg2 = std::string(jarg2);
3250
3251   arg1 = (Dali::DaliException *)jarg1;
3252   {
3253     if (!arg2.empty()) {
3254       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3255     } else {
3256       arg1->condition = 0;
3257     }
3258   }
3259 }
3260
3261
3262 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3263   char * jresult ;
3264   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3265   char *result = 0 ;
3266
3267   arg1 = (Dali::DaliException *)jarg1;
3268   result = (char *) ((arg1)->condition);
3269   jresult = SWIG_csharp_string_callback((const char *)result);
3270   return jresult;
3271 }
3272
3273
3274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3275   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3276
3277   arg1 = (Dali::DaliException *)jarg1;
3278   {
3279     try {
3280       delete arg1;
3281     } CALL_CATCH_EXCEPTION();
3282   }
3283
3284 }
3285
3286
3287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3288   void * jresult ;
3289   Dali::Vector2 *result = 0 ;
3290
3291   {
3292     try {
3293       result = (Dali::Vector2 *)new Dali::Vector2();
3294     } CALL_CATCH_EXCEPTION(0);
3295   }
3296
3297   jresult = (void *)result;
3298   return jresult;
3299 }
3300
3301
3302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3303   void * jresult ;
3304   float arg1 ;
3305   float arg2 ;
3306   Dali::Vector2 *result = 0 ;
3307
3308   arg1 = (float)jarg1;
3309   arg2 = (float)jarg2;
3310   {
3311     try {
3312       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3313     } CALL_CATCH_EXCEPTION(0);
3314   }
3315
3316   jresult = (void *)result;
3317   return jresult;
3318 }
3319
3320
3321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3322   void * jresult ;
3323   float *arg1 = (float *) 0 ;
3324   Dali::Vector2 *result = 0 ;
3325
3326   arg1 = jarg1;
3327   {
3328     try {
3329       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3330     } CALL_CATCH_EXCEPTION(0);
3331   }
3332
3333   jresult = (void *)result;
3334
3335
3336   return jresult;
3337 }
3338
3339
3340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3341   void * jresult ;
3342   Dali::Vector3 *arg1 = 0 ;
3343   Dali::Vector2 *result = 0 ;
3344
3345   arg1 = (Dali::Vector3 *)jarg1;
3346   if (!arg1) {
3347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3348     return 0;
3349   }
3350   {
3351     try {
3352       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3353     } CALL_CATCH_EXCEPTION(0);
3354   }
3355
3356   jresult = (void *)result;
3357   return jresult;
3358 }
3359
3360
3361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3362   void * jresult ;
3363   Dali::Vector4 *arg1 = 0 ;
3364   Dali::Vector2 *result = 0 ;
3365
3366   arg1 = (Dali::Vector4 *)jarg1;
3367   if (!arg1) {
3368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3369     return 0;
3370   }
3371   {
3372     try {
3373       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3374     } CALL_CATCH_EXCEPTION(0);
3375   }
3376
3377   jresult = (void *)result;
3378   return jresult;
3379 }
3380
3381
3382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3383   void * jresult ;
3384   Dali::Vector2 *result = 0 ;
3385
3386   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3387   jresult = (void *)result;
3388   return jresult;
3389 }
3390
3391
3392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3393   void * jresult ;
3394   Dali::Vector2 *result = 0 ;
3395
3396   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3397   jresult = (void *)result;
3398   return jresult;
3399 }
3400
3401
3402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3403   void * jresult ;
3404   Dali::Vector2 *result = 0 ;
3405
3406   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3407   jresult = (void *)result;
3408   return jresult;
3409 }
3410
3411
3412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3413   void * jresult ;
3414   Dali::Vector2 *result = 0 ;
3415
3416   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3417   jresult = (void *)result;
3418   return jresult;
3419 }
3420
3421
3422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3423   void * jresult ;
3424   Dali::Vector2 *result = 0 ;
3425
3426   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3427   jresult = (void *)result;
3428   return jresult;
3429 }
3430
3431
3432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3433   void * jresult ;
3434   Dali::Vector2 *result = 0 ;
3435
3436   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3437   jresult = (void *)result;
3438   return jresult;
3439 }
3440
3441
3442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3443   void * jresult ;
3444   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3445   float *arg2 = (float *) 0 ;
3446   Dali::Vector2 *result = 0 ;
3447
3448   arg1 = (Dali::Vector2 *)jarg1;
3449   arg2 = jarg2;
3450   {
3451     try {
3452       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3453     } CALL_CATCH_EXCEPTION(0);
3454   }
3455
3456   jresult = (void *)result;
3457
3458
3459   return jresult;
3460 }
3461
3462
3463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3464   void * jresult ;
3465   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3466   Dali::Vector3 *arg2 = 0 ;
3467   Dali::Vector2 *result = 0 ;
3468
3469   arg1 = (Dali::Vector2 *)jarg1;
3470   arg2 = (Dali::Vector3 *)jarg2;
3471   if (!arg2) {
3472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3473     return 0;
3474   }
3475   {
3476     try {
3477       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3478     } CALL_CATCH_EXCEPTION(0);
3479   }
3480
3481   jresult = (void *)result;
3482   return jresult;
3483 }
3484
3485
3486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3487   void * jresult ;
3488   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3489   Dali::Vector4 *arg2 = 0 ;
3490   Dali::Vector2 *result = 0 ;
3491
3492   arg1 = (Dali::Vector2 *)jarg1;
3493   arg2 = (Dali::Vector4 *)jarg2;
3494   if (!arg2) {
3495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3496     return 0;
3497   }
3498   {
3499     try {
3500       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3501     } CALL_CATCH_EXCEPTION(0);
3502   }
3503
3504   jresult = (void *)result;
3505   return jresult;
3506 }
3507
3508
3509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3510   void * jresult ;
3511   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3512   Dali::Vector2 *arg2 = 0 ;
3513   Dali::Vector2 result;
3514
3515   arg1 = (Dali::Vector2 *)jarg1;
3516   arg2 = (Dali::Vector2 *)jarg2;
3517   if (!arg2) {
3518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3519     return 0;
3520   }
3521   {
3522     try {
3523       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3524     } CALL_CATCH_EXCEPTION(0);
3525   }
3526
3527   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3533   void * jresult ;
3534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3535   Dali::Vector2 *arg2 = 0 ;
3536   Dali::Vector2 *result = 0 ;
3537
3538   arg1 = (Dali::Vector2 *)jarg1;
3539   arg2 = (Dali::Vector2 *)jarg2;
3540   if (!arg2) {
3541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3542     return 0;
3543   }
3544   {
3545     try {
3546       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3547     } CALL_CATCH_EXCEPTION(0);
3548   }
3549
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3556   void * jresult ;
3557   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3558   Dali::Vector2 *arg2 = 0 ;
3559   Dali::Vector2 result;
3560
3561   arg1 = (Dali::Vector2 *)jarg1;
3562   arg2 = (Dali::Vector2 *)jarg2;
3563   if (!arg2) {
3564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3565     return 0;
3566   }
3567   {
3568     try {
3569       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3570     } CALL_CATCH_EXCEPTION(0);
3571   }
3572
3573   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3574   return jresult;
3575 }
3576
3577
3578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3579   void * jresult ;
3580   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3581   Dali::Vector2 *arg2 = 0 ;
3582   Dali::Vector2 *result = 0 ;
3583
3584   arg1 = (Dali::Vector2 *)jarg1;
3585   arg2 = (Dali::Vector2 *)jarg2;
3586   if (!arg2) {
3587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3588     return 0;
3589   }
3590   {
3591     try {
3592       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3593     } CALL_CATCH_EXCEPTION(0);
3594   }
3595
3596   jresult = (void *)result;
3597   return jresult;
3598 }
3599
3600
3601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3602   void * jresult ;
3603   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3604   Dali::Vector2 *arg2 = 0 ;
3605   Dali::Vector2 result;
3606
3607   arg1 = (Dali::Vector2 *)jarg1;
3608   arg2 = (Dali::Vector2 *)jarg2;
3609   if (!arg2) {
3610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3611     return 0;
3612   }
3613   {
3614     try {
3615       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3616     } CALL_CATCH_EXCEPTION(0);
3617   }
3618
3619   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3620   return jresult;
3621 }
3622
3623
3624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3625   void * jresult ;
3626   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3627   float arg2 ;
3628   Dali::Vector2 result;
3629
3630   arg1 = (Dali::Vector2 *)jarg1;
3631   arg2 = (float)jarg2;
3632   {
3633     try {
3634       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3635     } CALL_CATCH_EXCEPTION(0);
3636   }
3637
3638   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3639   return jresult;
3640 }
3641
3642
3643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3644   void * jresult ;
3645   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3646   Dali::Vector2 *arg2 = 0 ;
3647   Dali::Vector2 *result = 0 ;
3648
3649   arg1 = (Dali::Vector2 *)jarg1;
3650   arg2 = (Dali::Vector2 *)jarg2;
3651   if (!arg2) {
3652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3653     return 0;
3654   }
3655   {
3656     try {
3657       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3658     } CALL_CATCH_EXCEPTION(0);
3659   }
3660
3661   jresult = (void *)result;
3662   return jresult;
3663 }
3664
3665
3666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3667   void * jresult ;
3668   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3669   float arg2 ;
3670   Dali::Vector2 *result = 0 ;
3671
3672   arg1 = (Dali::Vector2 *)jarg1;
3673   arg2 = (float)jarg2;
3674   {
3675     try {
3676       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3677     } CALL_CATCH_EXCEPTION(0);
3678   }
3679
3680   jresult = (void *)result;
3681   return jresult;
3682 }
3683
3684
3685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3686   void * jresult ;
3687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3688   Dali::Vector2 *arg2 = 0 ;
3689   Dali::Vector2 result;
3690
3691   arg1 = (Dali::Vector2 *)jarg1;
3692   arg2 = (Dali::Vector2 *)jarg2;
3693   if (!arg2) {
3694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3695     return 0;
3696   }
3697   {
3698     try {
3699       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3700     } CALL_CATCH_EXCEPTION(0);
3701   }
3702
3703   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3704   return jresult;
3705 }
3706
3707
3708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3709   void * jresult ;
3710   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3711   float arg2 ;
3712   Dali::Vector2 result;
3713
3714   arg1 = (Dali::Vector2 *)jarg1;
3715   arg2 = (float)jarg2;
3716   {
3717     try {
3718       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3719     } CALL_CATCH_EXCEPTION(0);
3720   }
3721
3722   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3723   return jresult;
3724 }
3725
3726
3727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3728   void * jresult ;
3729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3730   Dali::Vector2 *arg2 = 0 ;
3731   Dali::Vector2 *result = 0 ;
3732
3733   arg1 = (Dali::Vector2 *)jarg1;
3734   arg2 = (Dali::Vector2 *)jarg2;
3735   if (!arg2) {
3736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3737     return 0;
3738   }
3739   {
3740     try {
3741       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3742     } CALL_CATCH_EXCEPTION(0);
3743   }
3744
3745   jresult = (void *)result;
3746   return jresult;
3747 }
3748
3749
3750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3751   void * jresult ;
3752   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3753   float arg2 ;
3754   Dali::Vector2 *result = 0 ;
3755
3756   arg1 = (Dali::Vector2 *)jarg1;
3757   arg2 = (float)jarg2;
3758   {
3759     try {
3760       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3761     } CALL_CATCH_EXCEPTION(0);
3762   }
3763
3764   jresult = (void *)result;
3765   return jresult;
3766 }
3767
3768
3769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3770   void * jresult ;
3771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3772   Dali::Vector2 result;
3773
3774   arg1 = (Dali::Vector2 *)jarg1;
3775   {
3776     try {
3777       result = ((Dali::Vector2 const *)arg1)->operator -();
3778     } CALL_CATCH_EXCEPTION(0);
3779   }
3780
3781   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3782   return jresult;
3783 }
3784
3785
3786 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3787   bool jresult ;
3788   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3789   Dali::Vector2 *arg2 = 0 ;
3790   bool result;
3791
3792   arg1 = (Dali::Vector2 *)jarg1;
3793   arg2 = (Dali::Vector2 *)jarg2;
3794   if (!arg2) {
3795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3796     return 0;
3797   }
3798   {
3799     try {
3800       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3801     } CALL_CATCH_EXCEPTION(0);
3802   }
3803
3804   jresult = result;
3805   return jresult;
3806 }
3807
3808
3809 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3810   bool jresult ;
3811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3812   Dali::Vector2 *arg2 = 0 ;
3813   bool result;
3814
3815   arg1 = (Dali::Vector2 *)jarg1;
3816   arg2 = (Dali::Vector2 *)jarg2;
3817   if (!arg2) {
3818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3819     return 0;
3820   }
3821   {
3822     try {
3823       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3824     } CALL_CATCH_EXCEPTION(0);
3825   }
3826
3827   jresult = result;
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3833   float jresult ;
3834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3835   unsigned int arg2 ;
3836   float *result = 0 ;
3837
3838   arg1 = (Dali::Vector2 *)jarg1;
3839   arg2 = (unsigned int)jarg2;
3840   {
3841     try {
3842       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3843     } CALL_CATCH_EXCEPTION(0);
3844   }
3845
3846   jresult = *result;
3847   return jresult;
3848 }
3849
3850
3851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3852   float jresult ;
3853   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3854   float result;
3855
3856   arg1 = (Dali::Vector2 *)jarg1;
3857   {
3858     try {
3859       result = (float)((Dali::Vector2 const *)arg1)->Length();
3860     } CALL_CATCH_EXCEPTION(0);
3861   }
3862
3863   jresult = result;
3864   return jresult;
3865 }
3866
3867
3868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3869   float jresult ;
3870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3871   float result;
3872
3873   arg1 = (Dali::Vector2 *)jarg1;
3874   {
3875     try {
3876       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3877     } CALL_CATCH_EXCEPTION(0);
3878   }
3879
3880   jresult = result;
3881   return jresult;
3882 }
3883
3884
3885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3886   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3887
3888   arg1 = (Dali::Vector2 *)jarg1;
3889   {
3890     try {
3891       (arg1)->Normalize();
3892     } CALL_CATCH_EXCEPTION();
3893   }
3894
3895 }
3896
3897
3898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3899   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3900   Dali::Vector2 *arg2 = 0 ;
3901   Dali::Vector2 *arg3 = 0 ;
3902
3903   arg1 = (Dali::Vector2 *)jarg1;
3904   arg2 = (Dali::Vector2 *)jarg2;
3905   if (!arg2) {
3906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3907     return ;
3908   }
3909   arg3 = (Dali::Vector2 *)jarg3;
3910   if (!arg3) {
3911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3912     return ;
3913   }
3914   {
3915     try {
3916       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3917     } CALL_CATCH_EXCEPTION();
3918   }
3919
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3924   void * jresult ;
3925   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3926   float *result = 0 ;
3927
3928   arg1 = (Dali::Vector2 *)jarg1;
3929   {
3930     try {
3931       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3932     } CALL_CATCH_EXCEPTION(0);
3933   }
3934
3935   jresult = (void *)result;
3936   return jresult;
3937 }
3938
3939
3940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
3941   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3942   float arg2 ;
3943
3944   arg1 = (Dali::Vector2 *)jarg1;
3945   arg2 = (float)jarg2;
3946   if (arg1) (arg1)->x = arg2;
3947 }
3948
3949
3950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
3951   float jresult ;
3952   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3953   float result;
3954
3955   arg1 = (Dali::Vector2 *)jarg1;
3956   result = (float) ((arg1)->x);
3957   jresult = result;
3958   return jresult;
3959 }
3960
3961
3962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
3963   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3964   float arg2 ;
3965
3966   arg1 = (Dali::Vector2 *)jarg1;
3967   arg2 = (float)jarg2;
3968   if (arg1) (arg1)->width = arg2;
3969 }
3970
3971
3972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
3973   float jresult ;
3974   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3975   float result;
3976
3977   arg1 = (Dali::Vector2 *)jarg1;
3978   result = (float) ((arg1)->width);
3979   jresult = result;
3980   return jresult;
3981 }
3982
3983
3984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
3985   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3986   float arg2 ;
3987
3988   arg1 = (Dali::Vector2 *)jarg1;
3989   arg2 = (float)jarg2;
3990   if (arg1) (arg1)->y = arg2;
3991 }
3992
3993
3994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
3995   float jresult ;
3996   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3997   float result;
3998
3999   arg1 = (Dali::Vector2 *)jarg1;
4000   result = (float) ((arg1)->y);
4001   jresult = result;
4002   return jresult;
4003 }
4004
4005
4006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4007   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4008   float arg2 ;
4009
4010   arg1 = (Dali::Vector2 *)jarg1;
4011   arg2 = (float)jarg2;
4012   if (arg1) (arg1)->height = arg2;
4013 }
4014
4015
4016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4017   float jresult ;
4018   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4019   float result;
4020
4021   arg1 = (Dali::Vector2 *)jarg1;
4022   result = (float) ((arg1)->height);
4023   jresult = result;
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4029   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4030
4031   arg1 = (Dali::Vector2 *)jarg1;
4032   {
4033     try {
4034       delete arg1;
4035     } CALL_CATCH_EXCEPTION();
4036   }
4037
4038 }
4039
4040
4041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4042   void * jresult ;
4043   Dali::Vector2 *arg1 = 0 ;
4044   Dali::Vector2 *arg2 = 0 ;
4045   Dali::Vector2 result;
4046
4047   arg1 = (Dali::Vector2 *)jarg1;
4048   if (!arg1) {
4049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4050     return 0;
4051   }
4052   arg2 = (Dali::Vector2 *)jarg2;
4053   if (!arg2) {
4054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4055     return 0;
4056   }
4057   {
4058     try {
4059       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4060     } CALL_CATCH_EXCEPTION(0);
4061   }
4062
4063   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4064   return jresult;
4065 }
4066
4067
4068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4069   void * jresult ;
4070   Dali::Vector2 *arg1 = 0 ;
4071   Dali::Vector2 *arg2 = 0 ;
4072   Dali::Vector2 result;
4073
4074   arg1 = (Dali::Vector2 *)jarg1;
4075   if (!arg1) {
4076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4077     return 0;
4078   }
4079   arg2 = (Dali::Vector2 *)jarg2;
4080   if (!arg2) {
4081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4082     return 0;
4083   }
4084   {
4085     try {
4086       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4087     } CALL_CATCH_EXCEPTION(0);
4088   }
4089
4090   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4091   return jresult;
4092 }
4093
4094
4095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4096   void * jresult ;
4097   Dali::Vector2 *arg1 = 0 ;
4098   float *arg2 = 0 ;
4099   float *arg3 = 0 ;
4100   float temp2 ;
4101   float temp3 ;
4102   Dali::Vector2 result;
4103
4104   arg1 = (Dali::Vector2 *)jarg1;
4105   if (!arg1) {
4106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4107     return 0;
4108   }
4109   temp2 = (float)jarg2;
4110   arg2 = &temp2;
4111   temp3 = (float)jarg3;
4112   arg3 = &temp3;
4113   {
4114     try {
4115       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4116     } CALL_CATCH_EXCEPTION(0);
4117   }
4118
4119   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4120   return jresult;
4121 }
4122
4123
4124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4125   void * jresult ;
4126   Dali::Vector3 *result = 0 ;
4127
4128   {
4129     try {
4130       result = (Dali::Vector3 *)new Dali::Vector3();
4131     } CALL_CATCH_EXCEPTION(0);
4132   }
4133
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4140   void * jresult ;
4141   float arg1 ;
4142   float arg2 ;
4143   float arg3 ;
4144   Dali::Vector3 *result = 0 ;
4145
4146   arg1 = (float)jarg1;
4147   arg2 = (float)jarg2;
4148   arg3 = (float)jarg3;
4149   {
4150     try {
4151       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4152     } CALL_CATCH_EXCEPTION(0);
4153   }
4154
4155   jresult = (void *)result;
4156   return jresult;
4157 }
4158
4159
4160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4161   void * jresult ;
4162   float *arg1 = (float *) 0 ;
4163   Dali::Vector3 *result = 0 ;
4164
4165   arg1 = jarg1;
4166   {
4167     try {
4168       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4169     } CALL_CATCH_EXCEPTION(0);
4170   }
4171
4172   jresult = (void *)result;
4173
4174
4175   return jresult;
4176 }
4177
4178
4179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4180   void * jresult ;
4181   Dali::Vector2 *arg1 = 0 ;
4182   Dali::Vector3 *result = 0 ;
4183
4184   arg1 = (Dali::Vector2 *)jarg1;
4185   if (!arg1) {
4186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4187     return 0;
4188   }
4189   {
4190     try {
4191       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4192     } CALL_CATCH_EXCEPTION(0);
4193   }
4194
4195   jresult = (void *)result;
4196   return jresult;
4197 }
4198
4199
4200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4201   void * jresult ;
4202   Dali::Vector4 *arg1 = 0 ;
4203   Dali::Vector3 *result = 0 ;
4204
4205   arg1 = (Dali::Vector4 *)jarg1;
4206   if (!arg1) {
4207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4208     return 0;
4209   }
4210   {
4211     try {
4212       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4213     } CALL_CATCH_EXCEPTION(0);
4214   }
4215
4216   jresult = (void *)result;
4217   return jresult;
4218 }
4219
4220
4221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4222   void * jresult ;
4223   Dali::Vector3 *result = 0 ;
4224
4225   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4226   jresult = (void *)result;
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4232   void * jresult ;
4233   Dali::Vector3 *result = 0 ;
4234
4235   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4236   jresult = (void *)result;
4237   return jresult;
4238 }
4239
4240
4241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4242   void * jresult ;
4243   Dali::Vector3 *result = 0 ;
4244
4245   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4246   jresult = (void *)result;
4247   return jresult;
4248 }
4249
4250
4251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4252   void * jresult ;
4253   Dali::Vector3 *result = 0 ;
4254
4255   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4256   jresult = (void *)result;
4257   return jresult;
4258 }
4259
4260
4261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4262   void * jresult ;
4263   Dali::Vector3 *result = 0 ;
4264
4265   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4266   jresult = (void *)result;
4267   return jresult;
4268 }
4269
4270
4271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4272   void * jresult ;
4273   Dali::Vector3 *result = 0 ;
4274
4275   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4276   jresult = (void *)result;
4277   return jresult;
4278 }
4279
4280
4281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4282   void * jresult ;
4283   Dali::Vector3 *result = 0 ;
4284
4285   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4286   jresult = (void *)result;
4287   return jresult;
4288 }
4289
4290
4291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4292   void * jresult ;
4293   Dali::Vector3 *result = 0 ;
4294
4295   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4296   jresult = (void *)result;
4297   return jresult;
4298 }
4299
4300
4301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4302   void * jresult ;
4303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4304   float *arg2 = (float *) 0 ;
4305   Dali::Vector3 *result = 0 ;
4306
4307   arg1 = (Dali::Vector3 *)jarg1;
4308   arg2 = jarg2;
4309   {
4310     try {
4311       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4312     } CALL_CATCH_EXCEPTION(0);
4313   }
4314
4315   jresult = (void *)result;
4316
4317
4318   return jresult;
4319 }
4320
4321
4322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4323   void * jresult ;
4324   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4325   Dali::Vector2 *arg2 = 0 ;
4326   Dali::Vector3 *result = 0 ;
4327
4328   arg1 = (Dali::Vector3 *)jarg1;
4329   arg2 = (Dali::Vector2 *)jarg2;
4330   if (!arg2) {
4331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4332     return 0;
4333   }
4334   {
4335     try {
4336       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4337     } CALL_CATCH_EXCEPTION(0);
4338   }
4339
4340   jresult = (void *)result;
4341   return jresult;
4342 }
4343
4344
4345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4346   void * jresult ;
4347   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4348   Dali::Vector4 *arg2 = 0 ;
4349   Dali::Vector3 *result = 0 ;
4350
4351   arg1 = (Dali::Vector3 *)jarg1;
4352   arg2 = (Dali::Vector4 *)jarg2;
4353   if (!arg2) {
4354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4355     return 0;
4356   }
4357   {
4358     try {
4359       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4360     } CALL_CATCH_EXCEPTION(0);
4361   }
4362
4363   jresult = (void *)result;
4364   return jresult;
4365 }
4366
4367
4368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4369   void * jresult ;
4370   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4371   Dali::Vector3 *arg2 = 0 ;
4372   Dali::Vector3 result;
4373
4374   arg1 = (Dali::Vector3 *)jarg1;
4375   arg2 = (Dali::Vector3 *)jarg2;
4376   if (!arg2) {
4377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4378     return 0;
4379   }
4380   {
4381     try {
4382       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4383     } CALL_CATCH_EXCEPTION(0);
4384   }
4385
4386   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4387   return jresult;
4388 }
4389
4390
4391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4392   void * jresult ;
4393   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4394   Dali::Vector3 *arg2 = 0 ;
4395   Dali::Vector3 *result = 0 ;
4396
4397   arg1 = (Dali::Vector3 *)jarg1;
4398   arg2 = (Dali::Vector3 *)jarg2;
4399   if (!arg2) {
4400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4401     return 0;
4402   }
4403   {
4404     try {
4405       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4406     } CALL_CATCH_EXCEPTION(0);
4407   }
4408
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4415   void * jresult ;
4416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4417   Dali::Vector3 *arg2 = 0 ;
4418   Dali::Vector3 result;
4419
4420   arg1 = (Dali::Vector3 *)jarg1;
4421   arg2 = (Dali::Vector3 *)jarg2;
4422   if (!arg2) {
4423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4424     return 0;
4425   }
4426   {
4427     try {
4428       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4429     } CALL_CATCH_EXCEPTION(0);
4430   }
4431
4432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4438   void * jresult ;
4439   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4440   Dali::Vector3 *arg2 = 0 ;
4441   Dali::Vector3 *result = 0 ;
4442
4443   arg1 = (Dali::Vector3 *)jarg1;
4444   arg2 = (Dali::Vector3 *)jarg2;
4445   if (!arg2) {
4446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4447     return 0;
4448   }
4449   {
4450     try {
4451       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4452     } CALL_CATCH_EXCEPTION(0);
4453   }
4454
4455   jresult = (void *)result;
4456   return jresult;
4457 }
4458
4459
4460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4461   void * jresult ;
4462   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4463   Dali::Vector3 *arg2 = 0 ;
4464   Dali::Vector3 result;
4465
4466   arg1 = (Dali::Vector3 *)jarg1;
4467   arg2 = (Dali::Vector3 *)jarg2;
4468   if (!arg2) {
4469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4470     return 0;
4471   }
4472   {
4473     try {
4474       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4475     } CALL_CATCH_EXCEPTION(0);
4476   }
4477
4478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4479   return jresult;
4480 }
4481
4482
4483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4484   void * jresult ;
4485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4486   float arg2 ;
4487   Dali::Vector3 result;
4488
4489   arg1 = (Dali::Vector3 *)jarg1;
4490   arg2 = (float)jarg2;
4491   {
4492     try {
4493       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4494     } CALL_CATCH_EXCEPTION(0);
4495   }
4496
4497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4503   void * jresult ;
4504   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4505   Dali::Vector3 *arg2 = 0 ;
4506   Dali::Vector3 *result = 0 ;
4507
4508   arg1 = (Dali::Vector3 *)jarg1;
4509   arg2 = (Dali::Vector3 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4517     } CALL_CATCH_EXCEPTION(0);
4518   }
4519
4520   jresult = (void *)result;
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4526   void * jresult ;
4527   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4528   float arg2 ;
4529   Dali::Vector3 *result = 0 ;
4530
4531   arg1 = (Dali::Vector3 *)jarg1;
4532   arg2 = (float)jarg2;
4533   {
4534     try {
4535       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4536     } CALL_CATCH_EXCEPTION(0);
4537   }
4538
4539   jresult = (void *)result;
4540   return jresult;
4541 }
4542
4543
4544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4545   void * jresult ;
4546   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4547   Dali::Quaternion *arg2 = 0 ;
4548   Dali::Vector3 *result = 0 ;
4549
4550   arg1 = (Dali::Vector3 *)jarg1;
4551   arg2 = (Dali::Quaternion *)jarg2;
4552   if (!arg2) {
4553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4554     return 0;
4555   }
4556   {
4557     try {
4558       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4559     } CALL_CATCH_EXCEPTION(0);
4560   }
4561
4562   jresult = (void *)result;
4563   return jresult;
4564 }
4565
4566
4567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4568   void * jresult ;
4569   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4570   Dali::Vector3 *arg2 = 0 ;
4571   Dali::Vector3 result;
4572
4573   arg1 = (Dali::Vector3 *)jarg1;
4574   arg2 = (Dali::Vector3 *)jarg2;
4575   if (!arg2) {
4576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4577     return 0;
4578   }
4579   {
4580     try {
4581       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4582     } CALL_CATCH_EXCEPTION(0);
4583   }
4584
4585   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4586   return jresult;
4587 }
4588
4589
4590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4591   void * jresult ;
4592   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4593   float arg2 ;
4594   Dali::Vector3 result;
4595
4596   arg1 = (Dali::Vector3 *)jarg1;
4597   arg2 = (float)jarg2;
4598   {
4599     try {
4600       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4601     } CALL_CATCH_EXCEPTION(0);
4602   }
4603
4604   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4605   return jresult;
4606 }
4607
4608
4609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4610   void * jresult ;
4611   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4612   Dali::Vector3 *arg2 = 0 ;
4613   Dali::Vector3 *result = 0 ;
4614
4615   arg1 = (Dali::Vector3 *)jarg1;
4616   arg2 = (Dali::Vector3 *)jarg2;
4617   if (!arg2) {
4618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4619     return 0;
4620   }
4621   {
4622     try {
4623       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4624     } CALL_CATCH_EXCEPTION(0);
4625   }
4626
4627   jresult = (void *)result;
4628   return jresult;
4629 }
4630
4631
4632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4633   void * jresult ;
4634   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4635   float arg2 ;
4636   Dali::Vector3 *result = 0 ;
4637
4638   arg1 = (Dali::Vector3 *)jarg1;
4639   arg2 = (float)jarg2;
4640   {
4641     try {
4642       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4643     } CALL_CATCH_EXCEPTION(0);
4644   }
4645
4646   jresult = (void *)result;
4647   return jresult;
4648 }
4649
4650
4651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4652   void * jresult ;
4653   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4654   Dali::Vector3 result;
4655
4656   arg1 = (Dali::Vector3 *)jarg1;
4657   {
4658     try {
4659       result = ((Dali::Vector3 const *)arg1)->operator -();
4660     } CALL_CATCH_EXCEPTION(0);
4661   }
4662
4663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4664   return jresult;
4665 }
4666
4667
4668 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4669   bool jresult ;
4670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4671   Dali::Vector3 *arg2 = 0 ;
4672   bool result;
4673
4674   arg1 = (Dali::Vector3 *)jarg1;
4675   arg2 = (Dali::Vector3 *)jarg2;
4676   if (!arg2) {
4677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4678     return 0;
4679   }
4680   {
4681     try {
4682       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4683     } CALL_CATCH_EXCEPTION(0);
4684   }
4685
4686   jresult = result;
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4692   bool jresult ;
4693   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4694   Dali::Vector3 *arg2 = 0 ;
4695   bool result;
4696
4697   arg1 = (Dali::Vector3 *)jarg1;
4698   arg2 = (Dali::Vector3 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4706     } CALL_CATCH_EXCEPTION(0);
4707   }
4708
4709   jresult = result;
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4715   float jresult ;
4716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4717   unsigned int arg2 ;
4718   float *result = 0 ;
4719
4720   arg1 = (Dali::Vector3 *)jarg1;
4721   arg2 = (unsigned int)jarg2;
4722   {
4723     try {
4724       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4725     } CALL_CATCH_EXCEPTION(0);
4726   }
4727
4728   jresult = *result;
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4734   float jresult ;
4735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4736   Dali::Vector3 *arg2 = 0 ;
4737   float result;
4738
4739   arg1 = (Dali::Vector3 *)jarg1;
4740   arg2 = (Dali::Vector3 *)jarg2;
4741   if (!arg2) {
4742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4743     return 0;
4744   }
4745   {
4746     try {
4747       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4748     } CALL_CATCH_EXCEPTION(0);
4749   }
4750
4751   jresult = result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4757   void * jresult ;
4758   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4759   Dali::Vector3 *arg2 = 0 ;
4760   Dali::Vector3 result;
4761
4762   arg1 = (Dali::Vector3 *)jarg1;
4763   arg2 = (Dali::Vector3 *)jarg2;
4764   if (!arg2) {
4765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4766     return 0;
4767   }
4768   {
4769     try {
4770       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4771     } CALL_CATCH_EXCEPTION(0);
4772   }
4773
4774   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4775   return jresult;
4776 }
4777
4778
4779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4780   float jresult ;
4781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4782   float result;
4783
4784   arg1 = (Dali::Vector3 *)jarg1;
4785   {
4786     try {
4787       result = (float)((Dali::Vector3 const *)arg1)->Length();
4788     } CALL_CATCH_EXCEPTION(0);
4789   }
4790
4791   jresult = result;
4792   return jresult;
4793 }
4794
4795
4796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4797   float jresult ;
4798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4799   float result;
4800
4801   arg1 = (Dali::Vector3 *)jarg1;
4802   {
4803     try {
4804       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4805     } CALL_CATCH_EXCEPTION(0);
4806   }
4807
4808   jresult = result;
4809   return jresult;
4810 }
4811
4812
4813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4815
4816   arg1 = (Dali::Vector3 *)jarg1;
4817   {
4818     try {
4819       (arg1)->Normalize();
4820     } CALL_CATCH_EXCEPTION();
4821   }
4822
4823 }
4824
4825
4826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4827   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4828   Dali::Vector3 *arg2 = 0 ;
4829   Dali::Vector3 *arg3 = 0 ;
4830
4831   arg1 = (Dali::Vector3 *)jarg1;
4832   arg2 = (Dali::Vector3 *)jarg2;
4833   if (!arg2) {
4834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4835     return ;
4836   }
4837   arg3 = (Dali::Vector3 *)jarg3;
4838   if (!arg3) {
4839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4840     return ;
4841   }
4842   {
4843     try {
4844       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4845     } CALL_CATCH_EXCEPTION();
4846   }
4847
4848 }
4849
4850
4851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4852   void * jresult ;
4853   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4854   float *result = 0 ;
4855
4856   arg1 = (Dali::Vector3 *)jarg1;
4857   {
4858     try {
4859       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4860     } CALL_CATCH_EXCEPTION(0);
4861   }
4862
4863   jresult = (void *)result;
4864   return jresult;
4865 }
4866
4867
4868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4869   void * jresult ;
4870   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4871   Dali::Vector2 *result = 0 ;
4872
4873   arg1 = (Dali::Vector3 *)jarg1;
4874   {
4875     try {
4876       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
4877     } CALL_CATCH_EXCEPTION(0);
4878   }
4879
4880   jresult = (void *)result;
4881   return jresult;
4882 }
4883
4884
4885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
4886   void * jresult ;
4887   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4888   Dali::Vector2 *result = 0 ;
4889
4890   arg1 = (Dali::Vector3 *)jarg1;
4891   {
4892     try {
4893       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
4894     } CALL_CATCH_EXCEPTION(0);
4895   }
4896
4897   jresult = (void *)result;
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
4903   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4904   float arg2 ;
4905
4906   arg1 = (Dali::Vector3 *)jarg1;
4907   arg2 = (float)jarg2;
4908   if (arg1) (arg1)->x = arg2;
4909 }
4910
4911
4912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
4913   float jresult ;
4914   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4915   float result;
4916
4917   arg1 = (Dali::Vector3 *)jarg1;
4918   result = (float) ((arg1)->x);
4919   jresult = result;
4920   return jresult;
4921 }
4922
4923
4924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
4925   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4926   float arg2 ;
4927
4928   arg1 = (Dali::Vector3 *)jarg1;
4929   arg2 = (float)jarg2;
4930   if (arg1) (arg1)->width = arg2;
4931 }
4932
4933
4934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
4935   float jresult ;
4936   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4937   float result;
4938
4939   arg1 = (Dali::Vector3 *)jarg1;
4940   result = (float) ((arg1)->width);
4941   jresult = result;
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
4947   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4948   float arg2 ;
4949
4950   arg1 = (Dali::Vector3 *)jarg1;
4951   arg2 = (float)jarg2;
4952   if (arg1) (arg1)->r = arg2;
4953 }
4954
4955
4956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
4957   float jresult ;
4958   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4959   float result;
4960
4961   arg1 = (Dali::Vector3 *)jarg1;
4962   result = (float) ((arg1)->r);
4963   jresult = result;
4964   return jresult;
4965 }
4966
4967
4968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
4969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4970   float arg2 ;
4971
4972   arg1 = (Dali::Vector3 *)jarg1;
4973   arg2 = (float)jarg2;
4974   if (arg1) (arg1)->y = arg2;
4975 }
4976
4977
4978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
4979   float jresult ;
4980   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4981   float result;
4982
4983   arg1 = (Dali::Vector3 *)jarg1;
4984   result = (float) ((arg1)->y);
4985   jresult = result;
4986   return jresult;
4987 }
4988
4989
4990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
4991   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4992   float arg2 ;
4993
4994   arg1 = (Dali::Vector3 *)jarg1;
4995   arg2 = (float)jarg2;
4996   if (arg1) (arg1)->height = arg2;
4997 }
4998
4999
5000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
5001   float jresult ;
5002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5003   float result;
5004
5005   arg1 = (Dali::Vector3 *)jarg1;
5006   result = (float) ((arg1)->height);
5007   jresult = result;
5008   return jresult;
5009 }
5010
5011
5012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5013   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5014   float arg2 ;
5015
5016   arg1 = (Dali::Vector3 *)jarg1;
5017   arg2 = (float)jarg2;
5018   if (arg1) (arg1)->g = arg2;
5019 }
5020
5021
5022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5023   float jresult ;
5024   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5025   float result;
5026
5027   arg1 = (Dali::Vector3 *)jarg1;
5028   result = (float) ((arg1)->g);
5029   jresult = result;
5030   return jresult;
5031 }
5032
5033
5034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
5035   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5036   float arg2 ;
5037
5038   arg1 = (Dali::Vector3 *)jarg1;
5039   arg2 = (float)jarg2;
5040   if (arg1) (arg1)->z = arg2;
5041 }
5042
5043
5044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
5045   float jresult ;
5046   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5047   float result;
5048
5049   arg1 = (Dali::Vector3 *)jarg1;
5050   result = (float) ((arg1)->z);
5051   jresult = result;
5052   return jresult;
5053 }
5054
5055
5056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
5057   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5058   float arg2 ;
5059
5060   arg1 = (Dali::Vector3 *)jarg1;
5061   arg2 = (float)jarg2;
5062   if (arg1) (arg1)->depth = arg2;
5063 }
5064
5065
5066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
5067   float jresult ;
5068   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5069   float result;
5070
5071   arg1 = (Dali::Vector3 *)jarg1;
5072   result = (float) ((arg1)->depth);
5073   jresult = result;
5074   return jresult;
5075 }
5076
5077
5078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5079   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5080   float arg2 ;
5081
5082   arg1 = (Dali::Vector3 *)jarg1;
5083   arg2 = (float)jarg2;
5084   if (arg1) (arg1)->b = arg2;
5085 }
5086
5087
5088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5089   float jresult ;
5090   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5091   float result;
5092
5093   arg1 = (Dali::Vector3 *)jarg1;
5094   result = (float) ((arg1)->b);
5095   jresult = result;
5096   return jresult;
5097 }
5098
5099
5100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5101   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5102
5103   arg1 = (Dali::Vector3 *)jarg1;
5104   {
5105     try {
5106       delete arg1;
5107     } CALL_CATCH_EXCEPTION();
5108   }
5109
5110 }
5111
5112
5113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5114   void * jresult ;
5115   Dali::Vector3 *arg1 = 0 ;
5116   Dali::Vector3 *arg2 = 0 ;
5117   Dali::Vector3 result;
5118
5119   arg1 = (Dali::Vector3 *)jarg1;
5120   if (!arg1) {
5121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5122     return 0;
5123   }
5124   arg2 = (Dali::Vector3 *)jarg2;
5125   if (!arg2) {
5126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5127     return 0;
5128   }
5129   {
5130     try {
5131       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5132     } CALL_CATCH_EXCEPTION(0);
5133   }
5134
5135   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5136   return jresult;
5137 }
5138
5139
5140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5141   void * jresult ;
5142   Dali::Vector3 *arg1 = 0 ;
5143   Dali::Vector3 *arg2 = 0 ;
5144   Dali::Vector3 result;
5145
5146   arg1 = (Dali::Vector3 *)jarg1;
5147   if (!arg1) {
5148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5149     return 0;
5150   }
5151   arg2 = (Dali::Vector3 *)jarg2;
5152   if (!arg2) {
5153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5154     return 0;
5155   }
5156   {
5157     try {
5158       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5159     } CALL_CATCH_EXCEPTION(0);
5160   }
5161
5162   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5163   return jresult;
5164 }
5165
5166
5167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5168   void * jresult ;
5169   Dali::Vector3 *arg1 = 0 ;
5170   float *arg2 = 0 ;
5171   float *arg3 = 0 ;
5172   float temp2 ;
5173   float temp3 ;
5174   Dali::Vector3 result;
5175
5176   arg1 = (Dali::Vector3 *)jarg1;
5177   if (!arg1) {
5178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5179     return 0;
5180   }
5181   temp2 = (float)jarg2;
5182   arg2 = &temp2;
5183   temp3 = (float)jarg3;
5184   arg3 = &temp3;
5185   {
5186     try {
5187       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5188     } CALL_CATCH_EXCEPTION(0);
5189   }
5190
5191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5197   void * jresult ;
5198   Dali::Vector4 *result = 0 ;
5199
5200   {
5201     try {
5202       result = (Dali::Vector4 *)new Dali::Vector4();
5203     } CALL_CATCH_EXCEPTION(0);
5204   }
5205
5206   jresult = (void *)result;
5207   return jresult;
5208 }
5209
5210
5211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5212   void * jresult ;
5213   float arg1 ;
5214   float arg2 ;
5215   float arg3 ;
5216   float arg4 ;
5217   Dali::Vector4 *result = 0 ;
5218
5219   arg1 = (float)jarg1;
5220   arg2 = (float)jarg2;
5221   arg3 = (float)jarg3;
5222   arg4 = (float)jarg4;
5223   {
5224     try {
5225       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5226     } CALL_CATCH_EXCEPTION(0);
5227   }
5228
5229   jresult = (void *)result;
5230   return jresult;
5231 }
5232
5233
5234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5235   void * jresult ;
5236   float *arg1 = (float *) 0 ;
5237   Dali::Vector4 *result = 0 ;
5238
5239   arg1 = jarg1;
5240   {
5241     try {
5242       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5243     } CALL_CATCH_EXCEPTION(0);
5244   }
5245
5246   jresult = (void *)result;
5247
5248
5249   return jresult;
5250 }
5251
5252
5253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5254   void * jresult ;
5255   Dali::Vector2 *arg1 = 0 ;
5256   Dali::Vector4 *result = 0 ;
5257
5258   arg1 = (Dali::Vector2 *)jarg1;
5259   if (!arg1) {
5260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5261     return 0;
5262   }
5263   {
5264     try {
5265       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5266     } CALL_CATCH_EXCEPTION(0);
5267   }
5268
5269   jresult = (void *)result;
5270   return jresult;
5271 }
5272
5273
5274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5275   void * jresult ;
5276   Dali::Vector3 *arg1 = 0 ;
5277   Dali::Vector4 *result = 0 ;
5278
5279   arg1 = (Dali::Vector3 *)jarg1;
5280   if (!arg1) {
5281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5282     return 0;
5283   }
5284   {
5285     try {
5286       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5287     } CALL_CATCH_EXCEPTION(0);
5288   }
5289
5290   jresult = (void *)result;
5291   return jresult;
5292 }
5293
5294
5295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5296   void * jresult ;
5297   Dali::Vector4 *result = 0 ;
5298
5299   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5300   jresult = (void *)result;
5301   return jresult;
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5306   void * jresult ;
5307   Dali::Vector4 *result = 0 ;
5308
5309   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5310   jresult = (void *)result;
5311   return jresult;
5312 }
5313
5314
5315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5316   void * jresult ;
5317   Dali::Vector4 *result = 0 ;
5318
5319   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5320   jresult = (void *)result;
5321   return jresult;
5322 }
5323
5324
5325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5326   void * jresult ;
5327   Dali::Vector4 *result = 0 ;
5328
5329   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5336   void * jresult ;
5337   Dali::Vector4 *result = 0 ;
5338
5339   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5340   jresult = (void *)result;
5341   return jresult;
5342 }
5343
5344
5345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5346   void * jresult ;
5347   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5348   float *arg2 = (float *) 0 ;
5349   Dali::Vector4 *result = 0 ;
5350
5351   arg1 = (Dali::Vector4 *)jarg1;
5352   arg2 = jarg2;
5353   {
5354     try {
5355       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5356     } CALL_CATCH_EXCEPTION(0);
5357   }
5358
5359   jresult = (void *)result;
5360
5361
5362   return jresult;
5363 }
5364
5365
5366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5367   void * jresult ;
5368   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5369   Dali::Vector2 *arg2 = 0 ;
5370   Dali::Vector4 *result = 0 ;
5371
5372   arg1 = (Dali::Vector4 *)jarg1;
5373   arg2 = (Dali::Vector2 *)jarg2;
5374   if (!arg2) {
5375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5376     return 0;
5377   }
5378   {
5379     try {
5380       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5381     } CALL_CATCH_EXCEPTION(0);
5382   }
5383
5384   jresult = (void *)result;
5385   return jresult;
5386 }
5387
5388
5389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5390   void * jresult ;
5391   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5392   Dali::Vector3 *arg2 = 0 ;
5393   Dali::Vector4 *result = 0 ;
5394
5395   arg1 = (Dali::Vector4 *)jarg1;
5396   arg2 = (Dali::Vector3 *)jarg2;
5397   if (!arg2) {
5398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5399     return 0;
5400   }
5401   {
5402     try {
5403       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5404     } CALL_CATCH_EXCEPTION(0);
5405   }
5406
5407   jresult = (void *)result;
5408   return jresult;
5409 }
5410
5411
5412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5413   void * jresult ;
5414   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5415   Dali::Vector4 *arg2 = 0 ;
5416   Dali::Vector4 result;
5417
5418   arg1 = (Dali::Vector4 *)jarg1;
5419   arg2 = (Dali::Vector4 *)jarg2;
5420   if (!arg2) {
5421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5422     return 0;
5423   }
5424   {
5425     try {
5426       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5427     } CALL_CATCH_EXCEPTION(0);
5428   }
5429
5430   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5431   return jresult;
5432 }
5433
5434
5435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5436   void * jresult ;
5437   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5438   Dali::Vector4 *arg2 = 0 ;
5439   Dali::Vector4 *result = 0 ;
5440
5441   arg1 = (Dali::Vector4 *)jarg1;
5442   arg2 = (Dali::Vector4 *)jarg2;
5443   if (!arg2) {
5444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5445     return 0;
5446   }
5447   {
5448     try {
5449       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5450     } CALL_CATCH_EXCEPTION(0);
5451   }
5452
5453   jresult = (void *)result;
5454   return jresult;
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5461   Dali::Vector4 *arg2 = 0 ;
5462   Dali::Vector4 result;
5463
5464   arg1 = (Dali::Vector4 *)jarg1;
5465   arg2 = (Dali::Vector4 *)jarg2;
5466   if (!arg2) {
5467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5468     return 0;
5469   }
5470   {
5471     try {
5472       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5473     } CALL_CATCH_EXCEPTION(0);
5474   }
5475
5476   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5477   return jresult;
5478 }
5479
5480
5481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5482   void * jresult ;
5483   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5484   Dali::Vector4 *arg2 = 0 ;
5485   Dali::Vector4 *result = 0 ;
5486
5487   arg1 = (Dali::Vector4 *)jarg1;
5488   arg2 = (Dali::Vector4 *)jarg2;
5489   if (!arg2) {
5490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5491     return 0;
5492   }
5493   {
5494     try {
5495       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5496     } CALL_CATCH_EXCEPTION(0);
5497   }
5498
5499   jresult = (void *)result;
5500   return jresult;
5501 }
5502
5503
5504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5505   void * jresult ;
5506   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5507   Dali::Vector4 *arg2 = 0 ;
5508   Dali::Vector4 result;
5509
5510   arg1 = (Dali::Vector4 *)jarg1;
5511   arg2 = (Dali::Vector4 *)jarg2;
5512   if (!arg2) {
5513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5514     return 0;
5515   }
5516   {
5517     try {
5518       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5519     } CALL_CATCH_EXCEPTION(0);
5520   }
5521
5522   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5523   return jresult;
5524 }
5525
5526
5527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5528   void * jresult ;
5529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5530   float arg2 ;
5531   Dali::Vector4 result;
5532
5533   arg1 = (Dali::Vector4 *)jarg1;
5534   arg2 = (float)jarg2;
5535   {
5536     try {
5537       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5538     } CALL_CATCH_EXCEPTION(0);
5539   }
5540
5541   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5542   return jresult;
5543 }
5544
5545
5546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5547   void * jresult ;
5548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5549   Dali::Vector4 *arg2 = 0 ;
5550   Dali::Vector4 *result = 0 ;
5551
5552   arg1 = (Dali::Vector4 *)jarg1;
5553   arg2 = (Dali::Vector4 *)jarg2;
5554   if (!arg2) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5556     return 0;
5557   }
5558   {
5559     try {
5560       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5561     } CALL_CATCH_EXCEPTION(0);
5562   }
5563
5564   jresult = (void *)result;
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5570   void * jresult ;
5571   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5572   float arg2 ;
5573   Dali::Vector4 *result = 0 ;
5574
5575   arg1 = (Dali::Vector4 *)jarg1;
5576   arg2 = (float)jarg2;
5577   {
5578     try {
5579       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5580     } CALL_CATCH_EXCEPTION(0);
5581   }
5582
5583   jresult = (void *)result;
5584   return jresult;
5585 }
5586
5587
5588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5589   void * jresult ;
5590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5591   Dali::Vector4 *arg2 = 0 ;
5592   Dali::Vector4 result;
5593
5594   arg1 = (Dali::Vector4 *)jarg1;
5595   arg2 = (Dali::Vector4 *)jarg2;
5596   if (!arg2) {
5597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5598     return 0;
5599   }
5600   {
5601     try {
5602       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5603     } CALL_CATCH_EXCEPTION(0);
5604   }
5605
5606   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5607   return jresult;
5608 }
5609
5610
5611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5612   void * jresult ;
5613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5614   float arg2 ;
5615   Dali::Vector4 result;
5616
5617   arg1 = (Dali::Vector4 *)jarg1;
5618   arg2 = (float)jarg2;
5619   {
5620     try {
5621       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5622     } CALL_CATCH_EXCEPTION(0);
5623   }
5624
5625   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5626   return jresult;
5627 }
5628
5629
5630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5631   void * jresult ;
5632   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5633   Dali::Vector4 *arg2 = 0 ;
5634   Dali::Vector4 *result = 0 ;
5635
5636   arg1 = (Dali::Vector4 *)jarg1;
5637   arg2 = (Dali::Vector4 *)jarg2;
5638   if (!arg2) {
5639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5640     return 0;
5641   }
5642   {
5643     try {
5644       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5645     } CALL_CATCH_EXCEPTION(0);
5646   }
5647
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5654   void * jresult ;
5655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5656   float arg2 ;
5657   Dali::Vector4 *result = 0 ;
5658
5659   arg1 = (Dali::Vector4 *)jarg1;
5660   arg2 = (float)jarg2;
5661   {
5662     try {
5663       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5664     } CALL_CATCH_EXCEPTION(0);
5665   }
5666
5667   jresult = (void *)result;
5668   return jresult;
5669 }
5670
5671
5672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5673   void * jresult ;
5674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5675   Dali::Vector4 result;
5676
5677   arg1 = (Dali::Vector4 *)jarg1;
5678   {
5679     try {
5680       result = ((Dali::Vector4 const *)arg1)->operator -();
5681     } CALL_CATCH_EXCEPTION(0);
5682   }
5683
5684   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5685   return jresult;
5686 }
5687
5688
5689 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5690   bool jresult ;
5691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5692   Dali::Vector4 *arg2 = 0 ;
5693   bool result;
5694
5695   arg1 = (Dali::Vector4 *)jarg1;
5696   arg2 = (Dali::Vector4 *)jarg2;
5697   if (!arg2) {
5698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5699     return 0;
5700   }
5701   {
5702     try {
5703       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5704     } CALL_CATCH_EXCEPTION(0);
5705   }
5706
5707   jresult = result;
5708   return jresult;
5709 }
5710
5711
5712 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5713   bool jresult ;
5714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5715   Dali::Vector4 *arg2 = 0 ;
5716   bool result;
5717
5718   arg1 = (Dali::Vector4 *)jarg1;
5719   arg2 = (Dali::Vector4 *)jarg2;
5720   if (!arg2) {
5721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5722     return 0;
5723   }
5724   {
5725     try {
5726       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5727     } CALL_CATCH_EXCEPTION(0);
5728   }
5729
5730   jresult = result;
5731   return jresult;
5732 }
5733
5734
5735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5736   float jresult ;
5737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5738   unsigned int arg2 ;
5739   float *result = 0 ;
5740
5741   arg1 = (Dali::Vector4 *)jarg1;
5742   arg2 = (unsigned int)jarg2;
5743   {
5744     try {
5745       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5746     } CALL_CATCH_EXCEPTION(0);
5747   }
5748
5749   jresult = *result;
5750   return jresult;
5751 }
5752
5753
5754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5755   float jresult ;
5756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5757   Dali::Vector3 *arg2 = 0 ;
5758   float result;
5759
5760   arg1 = (Dali::Vector4 *)jarg1;
5761   arg2 = (Dali::Vector3 *)jarg2;
5762   if (!arg2) {
5763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5764     return 0;
5765   }
5766   {
5767     try {
5768       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5769     } CALL_CATCH_EXCEPTION(0);
5770   }
5771
5772   jresult = result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5778   float jresult ;
5779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5780   Dali::Vector4 *arg2 = 0 ;
5781   float result;
5782
5783   arg1 = (Dali::Vector4 *)jarg1;
5784   arg2 = (Dali::Vector4 *)jarg2;
5785   if (!arg2) {
5786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5787     return 0;
5788   }
5789   {
5790     try {
5791       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5792     } CALL_CATCH_EXCEPTION(0);
5793   }
5794
5795   jresult = result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5801   float jresult ;
5802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5803   Dali::Vector4 *arg2 = 0 ;
5804   float result;
5805
5806   arg1 = (Dali::Vector4 *)jarg1;
5807   arg2 = (Dali::Vector4 *)jarg2;
5808   if (!arg2) {
5809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5810     return 0;
5811   }
5812   {
5813     try {
5814       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5815     } CALL_CATCH_EXCEPTION(0);
5816   }
5817
5818   jresult = result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5824   void * jresult ;
5825   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5826   Dali::Vector4 *arg2 = 0 ;
5827   Dali::Vector4 result;
5828
5829   arg1 = (Dali::Vector4 *)jarg1;
5830   arg2 = (Dali::Vector4 *)jarg2;
5831   if (!arg2) {
5832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5833     return 0;
5834   }
5835   {
5836     try {
5837       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5838     } CALL_CATCH_EXCEPTION(0);
5839   }
5840
5841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5847   float jresult ;
5848   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5849   float result;
5850
5851   arg1 = (Dali::Vector4 *)jarg1;
5852   {
5853     try {
5854       result = (float)((Dali::Vector4 const *)arg1)->Length();
5855     } CALL_CATCH_EXCEPTION(0);
5856   }
5857
5858   jresult = result;
5859   return jresult;
5860 }
5861
5862
5863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5864   float jresult ;
5865   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5866   float result;
5867
5868   arg1 = (Dali::Vector4 *)jarg1;
5869   {
5870     try {
5871       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5872     } CALL_CATCH_EXCEPTION(0);
5873   }
5874
5875   jresult = result;
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
5881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5882
5883   arg1 = (Dali::Vector4 *)jarg1;
5884   {
5885     try {
5886       (arg1)->Normalize();
5887     } CALL_CATCH_EXCEPTION();
5888   }
5889
5890 }
5891
5892
5893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5894   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5895   Dali::Vector4 *arg2 = 0 ;
5896   Dali::Vector4 *arg3 = 0 ;
5897
5898   arg1 = (Dali::Vector4 *)jarg1;
5899   arg2 = (Dali::Vector4 *)jarg2;
5900   if (!arg2) {
5901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5902     return ;
5903   }
5904   arg3 = (Dali::Vector4 *)jarg3;
5905   if (!arg3) {
5906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5907     return ;
5908   }
5909   {
5910     try {
5911       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
5912     } CALL_CATCH_EXCEPTION();
5913   }
5914
5915 }
5916
5917
5918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
5919   void * jresult ;
5920   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5921   float *result = 0 ;
5922
5923   arg1 = (Dali::Vector4 *)jarg1;
5924   {
5925     try {
5926       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
5927     } CALL_CATCH_EXCEPTION(0);
5928   }
5929
5930   jresult = (void *)result;
5931   return jresult;
5932 }
5933
5934
5935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
5936   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5937   float arg2 ;
5938
5939   arg1 = (Dali::Vector4 *)jarg1;
5940   arg2 = (float)jarg2;
5941   if (arg1) (arg1)->x = arg2;
5942 }
5943
5944
5945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
5946   float jresult ;
5947   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5948   float result;
5949
5950   arg1 = (Dali::Vector4 *)jarg1;
5951   result = (float) ((arg1)->x);
5952   jresult = result;
5953   return jresult;
5954 }
5955
5956
5957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
5958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5959   float arg2 ;
5960
5961   arg1 = (Dali::Vector4 *)jarg1;
5962   arg2 = (float)jarg2;
5963   if (arg1) (arg1)->r = arg2;
5964 }
5965
5966
5967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
5968   float jresult ;
5969   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5970   float result;
5971
5972   arg1 = (Dali::Vector4 *)jarg1;
5973   result = (float) ((arg1)->r);
5974   jresult = result;
5975   return jresult;
5976 }
5977
5978
5979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
5980   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5981   float arg2 ;
5982
5983   arg1 = (Dali::Vector4 *)jarg1;
5984   arg2 = (float)jarg2;
5985   if (arg1) (arg1)->s = arg2;
5986 }
5987
5988
5989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
5990   float jresult ;
5991   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5992   float result;
5993
5994   arg1 = (Dali::Vector4 *)jarg1;
5995   result = (float) ((arg1)->s);
5996   jresult = result;
5997   return jresult;
5998 }
5999
6000
6001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
6002   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6003   float arg2 ;
6004
6005   arg1 = (Dali::Vector4 *)jarg1;
6006   arg2 = (float)jarg2;
6007   if (arg1) (arg1)->y = arg2;
6008 }
6009
6010
6011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
6012   float jresult ;
6013   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6014   float result;
6015
6016   arg1 = (Dali::Vector4 *)jarg1;
6017   result = (float) ((arg1)->y);
6018   jresult = result;
6019   return jresult;
6020 }
6021
6022
6023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6024   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6025   float arg2 ;
6026
6027   arg1 = (Dali::Vector4 *)jarg1;
6028   arg2 = (float)jarg2;
6029   if (arg1) (arg1)->g = arg2;
6030 }
6031
6032
6033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6034   float jresult ;
6035   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6036   float result;
6037
6038   arg1 = (Dali::Vector4 *)jarg1;
6039   result = (float) ((arg1)->g);
6040   jresult = result;
6041   return jresult;
6042 }
6043
6044
6045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6046   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6047   float arg2 ;
6048
6049   arg1 = (Dali::Vector4 *)jarg1;
6050   arg2 = (float)jarg2;
6051   if (arg1) (arg1)->t = arg2;
6052 }
6053
6054
6055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6056   float jresult ;
6057   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6058   float result;
6059
6060   arg1 = (Dali::Vector4 *)jarg1;
6061   result = (float) ((arg1)->t);
6062   jresult = result;
6063   return jresult;
6064 }
6065
6066
6067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
6068   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6069   float arg2 ;
6070
6071   arg1 = (Dali::Vector4 *)jarg1;
6072   arg2 = (float)jarg2;
6073   if (arg1) (arg1)->z = arg2;
6074 }
6075
6076
6077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
6078   float jresult ;
6079   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6080   float result;
6081
6082   arg1 = (Dali::Vector4 *)jarg1;
6083   result = (float) ((arg1)->z);
6084   jresult = result;
6085   return jresult;
6086 }
6087
6088
6089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6090   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6091   float arg2 ;
6092
6093   arg1 = (Dali::Vector4 *)jarg1;
6094   arg2 = (float)jarg2;
6095   if (arg1) (arg1)->b = arg2;
6096 }
6097
6098
6099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6100   float jresult ;
6101   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6102   float result;
6103
6104   arg1 = (Dali::Vector4 *)jarg1;
6105   result = (float) ((arg1)->b);
6106   jresult = result;
6107   return jresult;
6108 }
6109
6110
6111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6112   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6113   float arg2 ;
6114
6115   arg1 = (Dali::Vector4 *)jarg1;
6116   arg2 = (float)jarg2;
6117   if (arg1) (arg1)->p = arg2;
6118 }
6119
6120
6121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6122   float jresult ;
6123   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6124   float result;
6125
6126   arg1 = (Dali::Vector4 *)jarg1;
6127   result = (float) ((arg1)->p);
6128   jresult = result;
6129   return jresult;
6130 }
6131
6132
6133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6134   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6135   float arg2 ;
6136
6137   arg1 = (Dali::Vector4 *)jarg1;
6138   arg2 = (float)jarg2;
6139   if (arg1) (arg1)->w = arg2;
6140 }
6141
6142
6143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6144   float jresult ;
6145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6146   float result;
6147
6148   arg1 = (Dali::Vector4 *)jarg1;
6149   result = (float) ((arg1)->w);
6150   jresult = result;
6151   return jresult;
6152 }
6153
6154
6155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6156   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6157   float arg2 ;
6158
6159   arg1 = (Dali::Vector4 *)jarg1;
6160   arg2 = (float)jarg2;
6161   if (arg1) (arg1)->a = arg2;
6162 }
6163
6164
6165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6166   float jresult ;
6167   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6168   float result;
6169
6170   arg1 = (Dali::Vector4 *)jarg1;
6171   result = (float) ((arg1)->a);
6172   jresult = result;
6173   return jresult;
6174 }
6175
6176
6177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6179   float arg2 ;
6180
6181   arg1 = (Dali::Vector4 *)jarg1;
6182   arg2 = (float)jarg2;
6183   if (arg1) (arg1)->q = arg2;
6184 }
6185
6186
6187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6188   float jresult ;
6189   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6190   float result;
6191
6192   arg1 = (Dali::Vector4 *)jarg1;
6193   result = (float) ((arg1)->q);
6194   jresult = result;
6195   return jresult;
6196 }
6197
6198
6199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6200   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6201
6202   arg1 = (Dali::Vector4 *)jarg1;
6203   {
6204     try {
6205       delete arg1;
6206     } CALL_CATCH_EXCEPTION();
6207   }
6208
6209 }
6210
6211
6212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6213   void * jresult ;
6214   Dali::Vector4 *arg1 = 0 ;
6215   Dali::Vector4 *arg2 = 0 ;
6216   Dali::Vector4 result;
6217
6218   arg1 = (Dali::Vector4 *)jarg1;
6219   if (!arg1) {
6220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6221     return 0;
6222   }
6223   arg2 = (Dali::Vector4 *)jarg2;
6224   if (!arg2) {
6225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6226     return 0;
6227   }
6228   {
6229     try {
6230       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6231     } CALL_CATCH_EXCEPTION(0);
6232   }
6233
6234   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6235   return jresult;
6236 }
6237
6238
6239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6240   void * jresult ;
6241   Dali::Vector4 *arg1 = 0 ;
6242   Dali::Vector4 *arg2 = 0 ;
6243   Dali::Vector4 result;
6244
6245   arg1 = (Dali::Vector4 *)jarg1;
6246   if (!arg1) {
6247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6248     return 0;
6249   }
6250   arg2 = (Dali::Vector4 *)jarg2;
6251   if (!arg2) {
6252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6253     return 0;
6254   }
6255   {
6256     try {
6257       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6258     } CALL_CATCH_EXCEPTION(0);
6259   }
6260
6261   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6262   return jresult;
6263 }
6264
6265
6266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6267   void * jresult ;
6268   Dali::Vector4 *arg1 = 0 ;
6269   float *arg2 = 0 ;
6270   float *arg3 = 0 ;
6271   float temp2 ;
6272   float temp3 ;
6273   Dali::Vector4 result;
6274
6275   arg1 = (Dali::Vector4 *)jarg1;
6276   if (!arg1) {
6277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6278     return 0;
6279   }
6280   temp2 = (float)jarg2;
6281   arg2 = &temp2;
6282   temp3 = (float)jarg3;
6283   arg3 = &temp3;
6284   {
6285     try {
6286       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6287     } CALL_CATCH_EXCEPTION(0);
6288   }
6289
6290   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6291   return jresult;
6292 }
6293
6294
6295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6296   void * jresult ;
6297   Dali::Uint16Pair *result = 0 ;
6298
6299   {
6300     try {
6301       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6302     } CALL_CATCH_EXCEPTION(0);
6303   }
6304
6305   jresult = (void *)result;
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6311   void * jresult ;
6312   uint32_t arg1 ;
6313   uint32_t arg2 ;
6314   Dali::Uint16Pair *result = 0 ;
6315
6316   arg1 = (uint32_t)jarg1;
6317   arg2 = (uint32_t)jarg2;
6318   {
6319     try {
6320       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6321     } CALL_CATCH_EXCEPTION(0);
6322   }
6323
6324   jresult = (void *)result;
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6330   void * jresult ;
6331   Dali::Uint16Pair *arg1 = 0 ;
6332   Dali::Uint16Pair *result = 0 ;
6333
6334   arg1 = (Dali::Uint16Pair *)jarg1;
6335   if (!arg1) {
6336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6337     return 0;
6338   }
6339   {
6340     try {
6341       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6342     } CALL_CATCH_EXCEPTION(0);
6343   }
6344
6345   jresult = (void *)result;
6346   return jresult;
6347 }
6348
6349
6350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6351   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6352   uint16_t arg2 ;
6353
6354   arg1 = (Dali::Uint16Pair *)jarg1;
6355   arg2 = (uint16_t)jarg2;
6356   {
6357     try {
6358       (arg1)->SetWidth(arg2);
6359     } CALL_CATCH_EXCEPTION();
6360   }
6361
6362 }
6363
6364
6365 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6366   unsigned short jresult ;
6367   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6368   uint16_t result;
6369
6370   arg1 = (Dali::Uint16Pair *)jarg1;
6371   {
6372     try {
6373       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6374     } CALL_CATCH_EXCEPTION(0);
6375   }
6376
6377   jresult = result;
6378   return jresult;
6379 }
6380
6381
6382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6383   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6384   uint16_t arg2 ;
6385
6386   arg1 = (Dali::Uint16Pair *)jarg1;
6387   arg2 = (uint16_t)jarg2;
6388   {
6389     try {
6390       (arg1)->SetHeight(arg2);
6391     } CALL_CATCH_EXCEPTION();
6392   }
6393
6394 }
6395
6396
6397 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6398   unsigned short jresult ;
6399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6400   uint16_t result;
6401
6402   arg1 = (Dali::Uint16Pair *)jarg1;
6403   {
6404     try {
6405       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6406     } CALL_CATCH_EXCEPTION(0);
6407   }
6408
6409   jresult = result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6415   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6416   uint16_t arg2 ;
6417
6418   arg1 = (Dali::Uint16Pair *)jarg1;
6419   arg2 = (uint16_t)jarg2;
6420   {
6421     try {
6422       (arg1)->SetX(arg2);
6423     } CALL_CATCH_EXCEPTION();
6424   }
6425
6426 }
6427
6428
6429 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6430   unsigned short jresult ;
6431   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6432   uint16_t result;
6433
6434   arg1 = (Dali::Uint16Pair *)jarg1;
6435   {
6436     try {
6437       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6438     } CALL_CATCH_EXCEPTION(0);
6439   }
6440
6441   jresult = result;
6442   return jresult;
6443 }
6444
6445
6446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6447   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6448   uint16_t arg2 ;
6449
6450   arg1 = (Dali::Uint16Pair *)jarg1;
6451   arg2 = (uint16_t)jarg2;
6452   {
6453     try {
6454       (arg1)->SetY(arg2);
6455     } CALL_CATCH_EXCEPTION();
6456   }
6457
6458 }
6459
6460
6461 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6462   unsigned short jresult ;
6463   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6464   uint16_t result;
6465
6466   arg1 = (Dali::Uint16Pair *)jarg1;
6467   {
6468     try {
6469       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6470     } CALL_CATCH_EXCEPTION(0);
6471   }
6472
6473   jresult = result;
6474   return jresult;
6475 }
6476
6477
6478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6479   void * jresult ;
6480   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6481   Dali::Uint16Pair *arg2 = 0 ;
6482   Dali::Uint16Pair *result = 0 ;
6483
6484   arg1 = (Dali::Uint16Pair *)jarg1;
6485   arg2 = (Dali::Uint16Pair *)jarg2;
6486   if (!arg2) {
6487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6488     return 0;
6489   }
6490   {
6491     try {
6492       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6493     } CALL_CATCH_EXCEPTION(0);
6494   }
6495
6496   jresult = (void *)result;
6497   return jresult;
6498 }
6499
6500
6501 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6502   bool jresult ;
6503   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6504   Dali::Uint16Pair *arg2 = 0 ;
6505   bool result;
6506
6507   arg1 = (Dali::Uint16Pair *)jarg1;
6508   arg2 = (Dali::Uint16Pair *)jarg2;
6509   if (!arg2) {
6510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6511     return 0;
6512   }
6513   {
6514     try {
6515       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6516     } CALL_CATCH_EXCEPTION(0);
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6525   bool jresult ;
6526   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6527   Dali::Uint16Pair *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Uint16Pair *)jarg1;
6531   arg2 = (Dali::Uint16Pair *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6539     } CALL_CATCH_EXCEPTION(0);
6540   }
6541
6542   jresult = result;
6543   return jresult;
6544 }
6545
6546
6547 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6548   bool jresult ;
6549   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6550   Dali::Uint16Pair *arg2 = 0 ;
6551   bool result;
6552
6553   arg1 = (Dali::Uint16Pair *)jarg1;
6554   arg2 = (Dali::Uint16Pair *)jarg2;
6555   if (!arg2) {
6556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6557     return 0;
6558   }
6559   {
6560     try {
6561       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6562     } CALL_CATCH_EXCEPTION(0);
6563   }
6564
6565   jresult = result;
6566   return jresult;
6567 }
6568
6569
6570 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6571   bool jresult ;
6572   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6573   Dali::Uint16Pair *arg2 = 0 ;
6574   bool result;
6575
6576   arg1 = (Dali::Uint16Pair *)jarg1;
6577   arg2 = (Dali::Uint16Pair *)jarg2;
6578   if (!arg2) {
6579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6580     return 0;
6581   }
6582   {
6583     try {
6584       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6585     } CALL_CATCH_EXCEPTION(0);
6586   }
6587
6588   jresult = result;
6589   return jresult;
6590 }
6591
6592
6593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6594   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6595
6596   arg1 = (Dali::Uint16Pair *)jarg1;
6597   {
6598     try {
6599       delete arg1;
6600     } CALL_CATCH_EXCEPTION();
6601   }
6602
6603 }
6604
6605
6606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6607   void * jresult ;
6608   Dali::Degree *result = 0 ;
6609
6610   {
6611     try {
6612       result = (Dali::Degree *)new Dali::Degree();
6613     } CALL_CATCH_EXCEPTION(0);
6614   }
6615
6616   jresult = (void *)result;
6617   return jresult;
6618 }
6619
6620
6621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6622   void * jresult ;
6623   float arg1 ;
6624   Dali::Degree *result = 0 ;
6625
6626   arg1 = (float)jarg1;
6627   {
6628     try {
6629       result = (Dali::Degree *)new Dali::Degree(arg1);
6630     } CALL_CATCH_EXCEPTION(0);
6631   }
6632
6633   jresult = (void *)result;
6634   return jresult;
6635 }
6636
6637
6638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6639   void * jresult ;
6640   Dali::Radian arg1 ;
6641   Dali::Radian *argp1 ;
6642   Dali::Degree *result = 0 ;
6643
6644   argp1 = (Dali::Radian *)jarg1;
6645   if (!argp1) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6647     return 0;
6648   }
6649   arg1 = *argp1;
6650   {
6651     try {
6652       result = (Dali::Degree *)new Dali::Degree(arg1);
6653     } CALL_CATCH_EXCEPTION(0);
6654   }
6655
6656   jresult = (void *)result;
6657   return jresult;
6658 }
6659
6660
6661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6662   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6663   float arg2 ;
6664
6665   arg1 = (Dali::Degree *)jarg1;
6666   arg2 = (float)jarg2;
6667   if (arg1) (arg1)->degree = arg2;
6668 }
6669
6670
6671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6672   float jresult ;
6673   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6674   float result;
6675
6676   arg1 = (Dali::Degree *)jarg1;
6677   result = (float) ((arg1)->degree);
6678   jresult = result;
6679   return jresult;
6680 }
6681
6682
6683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6684   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6685
6686   arg1 = (Dali::Degree *)jarg1;
6687   {
6688     try {
6689       delete arg1;
6690     } CALL_CATCH_EXCEPTION();
6691   }
6692
6693 }
6694
6695
6696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6697   void * jresult ;
6698   Dali::Radian *result = 0 ;
6699
6700   result = (Dali::Radian *)&Dali::ANGLE_360;
6701   jresult = (void *)result;
6702   return jresult;
6703 }
6704
6705
6706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6707   void * jresult ;
6708   Dali::Radian *result = 0 ;
6709
6710   result = (Dali::Radian *)&Dali::ANGLE_315;
6711   jresult = (void *)result;
6712   return jresult;
6713 }
6714
6715
6716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6717   void * jresult ;
6718   Dali::Radian *result = 0 ;
6719
6720   result = (Dali::Radian *)&Dali::ANGLE_270;
6721   jresult = (void *)result;
6722   return jresult;
6723 }
6724
6725
6726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6727   void * jresult ;
6728   Dali::Radian *result = 0 ;
6729
6730   result = (Dali::Radian *)&Dali::ANGLE_225;
6731   jresult = (void *)result;
6732   return jresult;
6733 }
6734
6735
6736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6737   void * jresult ;
6738   Dali::Radian *result = 0 ;
6739
6740   result = (Dali::Radian *)&Dali::ANGLE_180;
6741   jresult = (void *)result;
6742   return jresult;
6743 }
6744
6745
6746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6747   void * jresult ;
6748   Dali::Radian *result = 0 ;
6749
6750   result = (Dali::Radian *)&Dali::ANGLE_135;
6751   jresult = (void *)result;
6752   return jresult;
6753 }
6754
6755
6756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6757   void * jresult ;
6758   Dali::Radian *result = 0 ;
6759
6760   result = (Dali::Radian *)&Dali::ANGLE_120;
6761   jresult = (void *)result;
6762   return jresult;
6763 }
6764
6765
6766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6767   void * jresult ;
6768   Dali::Radian *result = 0 ;
6769
6770   result = (Dali::Radian *)&Dali::ANGLE_90;
6771   jresult = (void *)result;
6772   return jresult;
6773 }
6774
6775
6776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6777   void * jresult ;
6778   Dali::Radian *result = 0 ;
6779
6780   result = (Dali::Radian *)&Dali::ANGLE_60;
6781   jresult = (void *)result;
6782   return jresult;
6783 }
6784
6785
6786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6787   void * jresult ;
6788   Dali::Radian *result = 0 ;
6789
6790   result = (Dali::Radian *)&Dali::ANGLE_45;
6791   jresult = (void *)result;
6792   return jresult;
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6797   void * jresult ;
6798   Dali::Radian *result = 0 ;
6799
6800   result = (Dali::Radian *)&Dali::ANGLE_30;
6801   jresult = (void *)result;
6802   return jresult;
6803 }
6804
6805
6806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6807   void * jresult ;
6808   Dali::Radian *result = 0 ;
6809
6810   result = (Dali::Radian *)&Dali::ANGLE_0;
6811   jresult = (void *)result;
6812   return jresult;
6813 }
6814
6815
6816 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6817   bool jresult ;
6818   Dali::Degree *arg1 = 0 ;
6819   Dali::Degree *arg2 = 0 ;
6820   bool result;
6821
6822   arg1 = (Dali::Degree *)jarg1;
6823   if (!arg1) {
6824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6825     return 0;
6826   }
6827   arg2 = (Dali::Degree *)jarg2;
6828   if (!arg2) {
6829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6830     return 0;
6831   }
6832   {
6833     try {
6834       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6835     } CALL_CATCH_EXCEPTION(0);
6836   }
6837
6838   jresult = result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6844   bool jresult ;
6845   Dali::Degree *arg1 = 0 ;
6846   Dali::Degree *arg2 = 0 ;
6847   bool result;
6848
6849   arg1 = (Dali::Degree *)jarg1;
6850   if (!arg1) {
6851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6852     return 0;
6853   }
6854   arg2 = (Dali::Degree *)jarg2;
6855   if (!arg2) {
6856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6857     return 0;
6858   }
6859   {
6860     try {
6861       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6862     } CALL_CATCH_EXCEPTION(0);
6863   }
6864
6865   jresult = result;
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6871   void * jresult ;
6872   Dali::Degree arg1 ;
6873   float arg2 ;
6874   float arg3 ;
6875   Dali::Degree *argp1 ;
6876   Dali::Degree result;
6877
6878   argp1 = (Dali::Degree *)jarg1;
6879   if (!argp1) {
6880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6881     return 0;
6882   }
6883   arg1 = *argp1;
6884   arg2 = (float)jarg2;
6885   arg3 = (float)jarg3;
6886   {
6887     try {
6888       result = Dali::Clamp(arg1,arg2,arg3);
6889     } CALL_CATCH_EXCEPTION(0);
6890   }
6891
6892   jresult = new Dali::Degree((const Dali::Degree &)result);
6893   return jresult;
6894 }
6895
6896
6897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
6898   void * jresult ;
6899   Dali::Radian *result = 0 ;
6900
6901   {
6902     try {
6903       result = (Dali::Radian *)new Dali::Radian();
6904     } CALL_CATCH_EXCEPTION(0);
6905   }
6906
6907   jresult = (void *)result;
6908   return jresult;
6909 }
6910
6911
6912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
6913   void * jresult ;
6914   float arg1 ;
6915   Dali::Radian *result = 0 ;
6916
6917   arg1 = (float)jarg1;
6918   {
6919     try {
6920       result = (Dali::Radian *)new Dali::Radian(arg1);
6921     } CALL_CATCH_EXCEPTION(0);
6922   }
6923
6924   jresult = (void *)result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
6930   void * jresult ;
6931   Dali::Degree arg1 ;
6932   Dali::Degree *argp1 ;
6933   Dali::Radian *result = 0 ;
6934
6935   argp1 = (Dali::Degree *)jarg1;
6936   if (!argp1) {
6937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6938     return 0;
6939   }
6940   arg1 = *argp1;
6941   {
6942     try {
6943       result = (Dali::Radian *)new Dali::Radian(arg1);
6944     } CALL_CATCH_EXCEPTION(0);
6945   }
6946
6947   jresult = (void *)result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
6953   void * jresult ;
6954   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6955   float arg2 ;
6956   Dali::Radian *result = 0 ;
6957
6958   arg1 = (Dali::Radian *)jarg1;
6959   arg2 = (float)jarg2;
6960   {
6961     try {
6962       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6963     } CALL_CATCH_EXCEPTION(0);
6964   }
6965
6966   jresult = (void *)result;
6967   return jresult;
6968 }
6969
6970
6971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
6972   void * jresult ;
6973   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6974   Dali::Degree arg2 ;
6975   Dali::Degree *argp2 ;
6976   Dali::Radian *result = 0 ;
6977
6978   arg1 = (Dali::Radian *)jarg1;
6979   argp2 = (Dali::Degree *)jarg2;
6980   if (!argp2) {
6981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
6982     return 0;
6983   }
6984   arg2 = *argp2;
6985   {
6986     try {
6987       result = (Dali::Radian *) &(arg1)->operator =(arg2);
6988     } CALL_CATCH_EXCEPTION(0);
6989   }
6990
6991   jresult = (void *)result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
6997   float jresult ;
6998   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
6999   float result;
7000
7001   arg1 = (Dali::Radian *)jarg1;
7002   {
7003     try {
7004       result = (float)((Dali::Radian const *)arg1)->operator float();
7005     } CALL_CATCH_EXCEPTION(0);
7006   }
7007
7008   jresult = result;
7009   return jresult;
7010 }
7011
7012
7013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
7014   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7015   float arg2 ;
7016
7017   arg1 = (Dali::Radian *)jarg1;
7018   arg2 = (float)jarg2;
7019   if (arg1) (arg1)->radian = arg2;
7020 }
7021
7022
7023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
7024   float jresult ;
7025   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7026   float result;
7027
7028   arg1 = (Dali::Radian *)jarg1;
7029   result = (float) ((arg1)->radian);
7030   jresult = result;
7031   return jresult;
7032 }
7033
7034
7035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
7036   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7037
7038   arg1 = (Dali::Radian *)jarg1;
7039   {
7040     try {
7041       delete arg1;
7042     } CALL_CATCH_EXCEPTION();
7043   }
7044
7045 }
7046
7047
7048 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7049   bool jresult ;
7050   Dali::Radian arg1 ;
7051   Dali::Radian arg2 ;
7052   Dali::Radian *argp1 ;
7053   Dali::Radian *argp2 ;
7054   bool result;
7055
7056   argp1 = (Dali::Radian *)jarg1;
7057   if (!argp1) {
7058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7059     return 0;
7060   }
7061   arg1 = *argp1;
7062   argp2 = (Dali::Radian *)jarg2;
7063   if (!argp2) {
7064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7065     return 0;
7066   }
7067   arg2 = *argp2;
7068   {
7069     try {
7070       result = (bool)Dali::operator ==(arg1,arg2);
7071     } CALL_CATCH_EXCEPTION(0);
7072   }
7073
7074   jresult = result;
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7080   bool jresult ;
7081   Dali::Radian arg1 ;
7082   Dali::Radian arg2 ;
7083   Dali::Radian *argp1 ;
7084   Dali::Radian *argp2 ;
7085   bool result;
7086
7087   argp1 = (Dali::Radian *)jarg1;
7088   if (!argp1) {
7089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7090     return 0;
7091   }
7092   arg1 = *argp1;
7093   argp2 = (Dali::Radian *)jarg2;
7094   if (!argp2) {
7095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7096     return 0;
7097   }
7098   arg2 = *argp2;
7099   {
7100     try {
7101       result = (bool)Dali::operator !=(arg1,arg2);
7102     } CALL_CATCH_EXCEPTION(0);
7103   }
7104
7105   jresult = result;
7106   return jresult;
7107 }
7108
7109
7110 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7111   bool jresult ;
7112   Dali::Radian arg1 ;
7113   Dali::Degree arg2 ;
7114   Dali::Radian *argp1 ;
7115   Dali::Degree *argp2 ;
7116   bool result;
7117
7118   argp1 = (Dali::Radian *)jarg1;
7119   if (!argp1) {
7120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7121     return 0;
7122   }
7123   arg1 = *argp1;
7124   argp2 = (Dali::Degree *)jarg2;
7125   if (!argp2) {
7126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7127     return 0;
7128   }
7129   arg2 = *argp2;
7130   {
7131     try {
7132       result = (bool)Dali::operator ==(arg1,arg2);
7133     } CALL_CATCH_EXCEPTION(0);
7134   }
7135
7136   jresult = result;
7137   return jresult;
7138 }
7139
7140
7141 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7142   bool jresult ;
7143   Dali::Radian arg1 ;
7144   Dali::Degree arg2 ;
7145   Dali::Radian *argp1 ;
7146   Dali::Degree *argp2 ;
7147   bool result;
7148
7149   argp1 = (Dali::Radian *)jarg1;
7150   if (!argp1) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7152     return 0;
7153   }
7154   arg1 = *argp1;
7155   argp2 = (Dali::Degree *)jarg2;
7156   if (!argp2) {
7157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7158     return 0;
7159   }
7160   arg2 = *argp2;
7161   {
7162     try {
7163       result = (bool)Dali::operator !=(arg1,arg2);
7164     } CALL_CATCH_EXCEPTION(0);
7165   }
7166
7167   jresult = result;
7168   return jresult;
7169 }
7170
7171
7172 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7173   bool jresult ;
7174   Dali::Degree arg1 ;
7175   Dali::Radian arg2 ;
7176   Dali::Degree *argp1 ;
7177   Dali::Radian *argp2 ;
7178   bool result;
7179
7180   argp1 = (Dali::Degree *)jarg1;
7181   if (!argp1) {
7182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7183     return 0;
7184   }
7185   arg1 = *argp1;
7186   argp2 = (Dali::Radian *)jarg2;
7187   if (!argp2) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7189     return 0;
7190   }
7191   arg2 = *argp2;
7192   {
7193     try {
7194       result = (bool)Dali::operator ==(arg1,arg2);
7195     } CALL_CATCH_EXCEPTION(0);
7196   }
7197
7198   jresult = result;
7199   return jresult;
7200 }
7201
7202
7203 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7204   bool jresult ;
7205   Dali::Degree arg1 ;
7206   Dali::Radian arg2 ;
7207   Dali::Degree *argp1 ;
7208   Dali::Radian *argp2 ;
7209   bool result;
7210
7211   argp1 = (Dali::Degree *)jarg1;
7212   if (!argp1) {
7213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7214     return 0;
7215   }
7216   arg1 = *argp1;
7217   argp2 = (Dali::Radian *)jarg2;
7218   if (!argp2) {
7219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7220     return 0;
7221   }
7222   arg2 = *argp2;
7223   {
7224     try {
7225       result = (bool)Dali::operator !=(arg1,arg2);
7226     } CALL_CATCH_EXCEPTION(0);
7227   }
7228
7229   jresult = result;
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7235   bool jresult ;
7236   Dali::Radian arg1 ;
7237   Dali::Radian arg2 ;
7238   Dali::Radian *argp1 ;
7239   Dali::Radian *argp2 ;
7240   bool result;
7241
7242   argp1 = (Dali::Radian *)jarg1;
7243   if (!argp1) {
7244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7245     return 0;
7246   }
7247   arg1 = *argp1;
7248   argp2 = (Dali::Radian *)jarg2;
7249   if (!argp2) {
7250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7251     return 0;
7252   }
7253   arg2 = *argp2;
7254   {
7255     try {
7256       result = (bool)Dali::operator >(arg1,arg2);
7257     } CALL_CATCH_EXCEPTION(0);
7258   }
7259
7260   jresult = result;
7261   return jresult;
7262 }
7263
7264
7265 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7266   bool jresult ;
7267   Dali::Radian arg1 ;
7268   Dali::Degree arg2 ;
7269   Dali::Radian *argp1 ;
7270   Dali::Degree *argp2 ;
7271   bool result;
7272
7273   argp1 = (Dali::Radian *)jarg1;
7274   if (!argp1) {
7275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7276     return 0;
7277   }
7278   arg1 = *argp1;
7279   argp2 = (Dali::Degree *)jarg2;
7280   if (!argp2) {
7281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7282     return 0;
7283   }
7284   arg2 = *argp2;
7285   {
7286     try {
7287       result = (bool)Dali::operator >(arg1,arg2);
7288     } CALL_CATCH_EXCEPTION(0);
7289   }
7290
7291   jresult = result;
7292   return jresult;
7293 }
7294
7295
7296 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7297   bool jresult ;
7298   Dali::Degree arg1 ;
7299   Dali::Radian arg2 ;
7300   Dali::Degree *argp1 ;
7301   Dali::Radian *argp2 ;
7302   bool result;
7303
7304   argp1 = (Dali::Degree *)jarg1;
7305   if (!argp1) {
7306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7307     return 0;
7308   }
7309   arg1 = *argp1;
7310   argp2 = (Dali::Radian *)jarg2;
7311   if (!argp2) {
7312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7313     return 0;
7314   }
7315   arg2 = *argp2;
7316   {
7317     try {
7318       result = (bool)Dali::operator >(arg1,arg2);
7319     } CALL_CATCH_EXCEPTION(0);
7320   }
7321
7322   jresult = result;
7323   return jresult;
7324 }
7325
7326
7327 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7328   bool jresult ;
7329   Dali::Radian arg1 ;
7330   Dali::Radian arg2 ;
7331   Dali::Radian *argp1 ;
7332   Dali::Radian *argp2 ;
7333   bool result;
7334
7335   argp1 = (Dali::Radian *)jarg1;
7336   if (!argp1) {
7337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7338     return 0;
7339   }
7340   arg1 = *argp1;
7341   argp2 = (Dali::Radian *)jarg2;
7342   if (!argp2) {
7343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7344     return 0;
7345   }
7346   arg2 = *argp2;
7347   {
7348     try {
7349       result = (bool)Dali::operator <(arg1,arg2);
7350     } CALL_CATCH_EXCEPTION(0);
7351   }
7352
7353   jresult = result;
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7359   bool jresult ;
7360   Dali::Radian arg1 ;
7361   Dali::Degree arg2 ;
7362   Dali::Radian *argp1 ;
7363   Dali::Degree *argp2 ;
7364   bool result;
7365
7366   argp1 = (Dali::Radian *)jarg1;
7367   if (!argp1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7369     return 0;
7370   }
7371   arg1 = *argp1;
7372   argp2 = (Dali::Degree *)jarg2;
7373   if (!argp2) {
7374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7375     return 0;
7376   }
7377   arg2 = *argp2;
7378   {
7379     try {
7380       result = (bool)Dali::operator <(arg1,arg2);
7381     } CALL_CATCH_EXCEPTION(0);
7382   }
7383
7384   jresult = result;
7385   return jresult;
7386 }
7387
7388
7389 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7390   bool jresult ;
7391   Dali::Degree arg1 ;
7392   Dali::Radian arg2 ;
7393   Dali::Degree *argp1 ;
7394   Dali::Radian *argp2 ;
7395   bool result;
7396
7397   argp1 = (Dali::Degree *)jarg1;
7398   if (!argp1) {
7399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7400     return 0;
7401   }
7402   arg1 = *argp1;
7403   argp2 = (Dali::Radian *)jarg2;
7404   if (!argp2) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7406     return 0;
7407   }
7408   arg2 = *argp2;
7409   {
7410     try {
7411       result = (bool)Dali::operator <(arg1,arg2);
7412     } CALL_CATCH_EXCEPTION(0);
7413   }
7414
7415   jresult = result;
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7421   void * jresult ;
7422   Dali::Radian arg1 ;
7423   float arg2 ;
7424   Dali::Radian *argp1 ;
7425   Dali::Radian result;
7426
7427   argp1 = (Dali::Radian *)jarg1;
7428   if (!argp1) {
7429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7430     return 0;
7431   }
7432   arg1 = *argp1;
7433   arg2 = (float)jarg2;
7434   {
7435     try {
7436       result = Dali::operator *(arg1,arg2);
7437     } CALL_CATCH_EXCEPTION(0);
7438   }
7439
7440   jresult = new Dali::Radian((const Dali::Radian &)result);
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7446   void * jresult ;
7447   Dali::Radian arg1 ;
7448   Dali::Radian *argp1 ;
7449   Dali::Radian result;
7450
7451   argp1 = (Dali::Radian *)jarg1;
7452   if (!argp1) {
7453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7454     return 0;
7455   }
7456   arg1 = *argp1;
7457   {
7458     try {
7459       result = Dali::operator -(arg1);
7460     } CALL_CATCH_EXCEPTION(0);
7461   }
7462
7463   jresult = new Dali::Radian((const Dali::Radian &)result);
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7469   void * jresult ;
7470   Dali::Radian arg1 ;
7471   float arg2 ;
7472   float arg3 ;
7473   Dali::Radian *argp1 ;
7474   Dali::Radian result;
7475
7476   argp1 = (Dali::Radian *)jarg1;
7477   if (!argp1) {
7478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7479     return 0;
7480   }
7481   arg1 = *argp1;
7482   arg2 = (float)jarg2;
7483   arg3 = (float)jarg3;
7484   {
7485     try {
7486       result = Dali::Clamp(arg1,arg2,arg3);
7487     } CALL_CATCH_EXCEPTION(0);
7488   }
7489
7490   jresult = new Dali::Radian((const Dali::Radian &)result);
7491   return jresult;
7492 }
7493
7494
7495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
7496   void * jresult ;
7497   Dali::Matrix *result = 0 ;
7498
7499   {
7500     try {
7501       result = (Dali::Matrix *)new Dali::Matrix();
7502     } CALL_CATCH_EXCEPTION(0);
7503   }
7504
7505   jresult = (void *)result;
7506   return jresult;
7507 }
7508
7509
7510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
7511   void * jresult ;
7512   bool arg1 ;
7513   Dali::Matrix *result = 0 ;
7514
7515   arg1 = jarg1 ? true : false;
7516   {
7517     try {
7518       result = (Dali::Matrix *)new Dali::Matrix(arg1);
7519     } CALL_CATCH_EXCEPTION(0);
7520   }
7521
7522   jresult = (void *)result;
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
7528   void * jresult ;
7529   float *arg1 = (float *) 0 ;
7530   Dali::Matrix *result = 0 ;
7531
7532   arg1 = jarg1;
7533   {
7534     try {
7535       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
7536     } CALL_CATCH_EXCEPTION(0);
7537   }
7538
7539   jresult = (void *)result;
7540
7541
7542   return jresult;
7543 }
7544
7545
7546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
7547   void * jresult ;
7548   Dali::Quaternion *arg1 = 0 ;
7549   Dali::Matrix *result = 0 ;
7550
7551   arg1 = (Dali::Quaternion *)jarg1;
7552   if (!arg1) {
7553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7554     return 0;
7555   }
7556   {
7557     try {
7558       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
7559     } CALL_CATCH_EXCEPTION(0);
7560   }
7561
7562   jresult = (void *)result;
7563   return jresult;
7564 }
7565
7566
7567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
7568   void * jresult ;
7569   Dali::Matrix *arg1 = 0 ;
7570   Dali::Matrix *result = 0 ;
7571
7572   arg1 = (Dali::Matrix *)jarg1;
7573   if (!arg1) {
7574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7575     return 0;
7576   }
7577   {
7578     try {
7579       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
7580     } CALL_CATCH_EXCEPTION(0);
7581   }
7582
7583   jresult = (void *)result;
7584   return jresult;
7585 }
7586
7587
7588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
7589   void * jresult ;
7590   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7591   Dali::Matrix *arg2 = 0 ;
7592   Dali::Matrix *result = 0 ;
7593
7594   arg1 = (Dali::Matrix *)jarg1;
7595   arg2 = (Dali::Matrix *)jarg2;
7596   if (!arg2) {
7597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7598     return 0;
7599   }
7600   {
7601     try {
7602       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
7603     } CALL_CATCH_EXCEPTION(0);
7604   }
7605
7606   jresult = (void *)result;
7607   return jresult;
7608 }
7609
7610
7611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
7612   void * jresult ;
7613   Dali::Matrix *result = 0 ;
7614
7615   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
7616   jresult = (void *)result;
7617   return jresult;
7618 }
7619
7620
7621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
7622   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7623
7624   arg1 = (Dali::Matrix *)jarg1;
7625   {
7626     try {
7627       (arg1)->SetIdentity();
7628     } CALL_CATCH_EXCEPTION();
7629   }
7630
7631 }
7632
7633
7634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
7635   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7636   Dali::Vector3 *arg2 = 0 ;
7637
7638   arg1 = (Dali::Matrix *)jarg1;
7639   arg2 = (Dali::Vector3 *)jarg2;
7640   if (!arg2) {
7641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7642     return ;
7643   }
7644   {
7645     try {
7646       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
7647     } CALL_CATCH_EXCEPTION();
7648   }
7649
7650 }
7651
7652
7653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
7654   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7655   Dali::Matrix *arg2 = 0 ;
7656
7657   arg1 = (Dali::Matrix *)jarg1;
7658   arg2 = (Dali::Matrix *)jarg2;
7659   if (!arg2) {
7660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7661     return ;
7662   }
7663   {
7664     try {
7665       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
7666     } CALL_CATCH_EXCEPTION();
7667   }
7668
7669 }
7670
7671
7672 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
7673   bool jresult ;
7674   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7675   bool result;
7676
7677   arg1 = (Dali::Matrix *)jarg1;
7678   {
7679     try {
7680       result = (bool)(arg1)->Invert();
7681     } CALL_CATCH_EXCEPTION(0);
7682   }
7683
7684   jresult = result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
7690   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7691
7692   arg1 = (Dali::Matrix *)jarg1;
7693   {
7694     try {
7695       (arg1)->Transpose();
7696     } CALL_CATCH_EXCEPTION();
7697   }
7698
7699 }
7700
7701
7702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
7703   void * jresult ;
7704   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7705   Dali::Vector3 result;
7706
7707   arg1 = (Dali::Matrix *)jarg1;
7708   {
7709     try {
7710       result = ((Dali::Matrix const *)arg1)->GetXAxis();
7711     } CALL_CATCH_EXCEPTION(0);
7712   }
7713
7714   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7715   return jresult;
7716 }
7717
7718
7719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
7720   void * jresult ;
7721   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7722   Dali::Vector3 result;
7723
7724   arg1 = (Dali::Matrix *)jarg1;
7725   {
7726     try {
7727       result = ((Dali::Matrix const *)arg1)->GetYAxis();
7728     } CALL_CATCH_EXCEPTION(0);
7729   }
7730
7731   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7732   return jresult;
7733 }
7734
7735
7736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
7737   void * jresult ;
7738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7739   Dali::Vector3 result;
7740
7741   arg1 = (Dali::Matrix *)jarg1;
7742   {
7743     try {
7744       result = ((Dali::Matrix const *)arg1)->GetZAxis();
7745     } CALL_CATCH_EXCEPTION(0);
7746   }
7747
7748   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7749   return jresult;
7750 }
7751
7752
7753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
7754   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7755   Dali::Vector3 *arg2 = 0 ;
7756
7757   arg1 = (Dali::Matrix *)jarg1;
7758   arg2 = (Dali::Vector3 *)jarg2;
7759   if (!arg2) {
7760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7761     return ;
7762   }
7763   {
7764     try {
7765       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
7766     } CALL_CATCH_EXCEPTION();
7767   }
7768
7769 }
7770
7771
7772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
7773   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7774   Dali::Vector3 *arg2 = 0 ;
7775
7776   arg1 = (Dali::Matrix *)jarg1;
7777   arg2 = (Dali::Vector3 *)jarg2;
7778   if (!arg2) {
7779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7780     return ;
7781   }
7782   {
7783     try {
7784       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
7785     } CALL_CATCH_EXCEPTION();
7786   }
7787
7788 }
7789
7790
7791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
7792   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7793   Dali::Vector3 *arg2 = 0 ;
7794
7795   arg1 = (Dali::Matrix *)jarg1;
7796   arg2 = (Dali::Vector3 *)jarg2;
7797   if (!arg2) {
7798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7799     return ;
7800   }
7801   {
7802     try {
7803       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
7804     } CALL_CATCH_EXCEPTION();
7805   }
7806
7807 }
7808
7809
7810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
7811   void * jresult ;
7812   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7813   Dali::Vector4 *result = 0 ;
7814
7815   arg1 = (Dali::Matrix *)jarg1;
7816   {
7817     try {
7818       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
7819     } CALL_CATCH_EXCEPTION(0);
7820   }
7821
7822   jresult = (void *)result;
7823   return jresult;
7824 }
7825
7826
7827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
7828   void * jresult ;
7829   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7830   Dali::Vector3 *result = 0 ;
7831
7832   arg1 = (Dali::Matrix *)jarg1;
7833   {
7834     try {
7835       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
7836     } CALL_CATCH_EXCEPTION(0);
7837   }
7838
7839   jresult = (void *)result;
7840   return jresult;
7841 }
7842
7843
7844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
7845   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847
7848   arg1 = (Dali::Matrix *)jarg1;
7849   arg2 = (Dali::Vector4 *)jarg2;
7850   if (!arg2) {
7851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7852     return ;
7853   }
7854   {
7855     try {
7856       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
7857     } CALL_CATCH_EXCEPTION();
7858   }
7859
7860 }
7861
7862
7863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
7864   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7865   Dali::Vector3 *arg2 = 0 ;
7866
7867   arg1 = (Dali::Matrix *)jarg1;
7868   arg2 = (Dali::Vector3 *)jarg2;
7869   if (!arg2) {
7870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7871     return ;
7872   }
7873   {
7874     try {
7875       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
7876     } CALL_CATCH_EXCEPTION();
7877   }
7878
7879 }
7880
7881
7882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
7883   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7884
7885   arg1 = (Dali::Matrix *)jarg1;
7886   {
7887     try {
7888       (arg1)->OrthoNormalize();
7889     } CALL_CATCH_EXCEPTION();
7890   }
7891
7892 }
7893
7894
7895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
7896   void * jresult ;
7897   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7898   float *result = 0 ;
7899
7900   arg1 = (Dali::Matrix *)jarg1;
7901   {
7902     try {
7903       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
7904     } CALL_CATCH_EXCEPTION(0);
7905   }
7906
7907   jresult = (void *)result;
7908   return jresult;
7909 }
7910
7911
7912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
7913   Dali::Matrix *arg1 = 0 ;
7914   Dali::Matrix *arg2 = 0 ;
7915   Dali::Matrix *arg3 = 0 ;
7916
7917   arg1 = (Dali::Matrix *)jarg1;
7918   if (!arg1) {
7919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7920     return ;
7921   }
7922   arg2 = (Dali::Matrix *)jarg2;
7923   if (!arg2) {
7924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7925     return ;
7926   }
7927   arg3 = (Dali::Matrix *)jarg3;
7928   if (!arg3) {
7929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7930     return ;
7931   }
7932   {
7933     try {
7934       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
7935     } CALL_CATCH_EXCEPTION();
7936   }
7937
7938 }
7939
7940
7941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
7942   Dali::Matrix *arg1 = 0 ;
7943   Dali::Matrix *arg2 = 0 ;
7944   Dali::Quaternion *arg3 = 0 ;
7945
7946   arg1 = (Dali::Matrix *)jarg1;
7947   if (!arg1) {
7948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7949     return ;
7950   }
7951   arg2 = (Dali::Matrix *)jarg2;
7952   if (!arg2) {
7953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7954     return ;
7955   }
7956   arg3 = (Dali::Quaternion *)jarg3;
7957   if (!arg3) {
7958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7959     return ;
7960   }
7961   {
7962     try {
7963       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
7964     } CALL_CATCH_EXCEPTION();
7965   }
7966
7967 }
7968
7969
7970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
7971   void * jresult ;
7972   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7973   Dali::Vector4 *arg2 = 0 ;
7974   Dali::Vector4 result;
7975
7976   arg1 = (Dali::Matrix *)jarg1;
7977   arg2 = (Dali::Vector4 *)jarg2;
7978   if (!arg2) {
7979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7980     return 0;
7981   }
7982   {
7983     try {
7984       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7985     } CALL_CATCH_EXCEPTION(0);
7986   }
7987
7988   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7989   return jresult;
7990 }
7991
7992
7993 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
7994   bool jresult ;
7995   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
7996   Dali::Matrix *arg2 = 0 ;
7997   bool result;
7998
7999   arg1 = (Dali::Matrix *)jarg1;
8000   arg2 = (Dali::Matrix *)jarg2;
8001   if (!arg2) {
8002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8003     return 0;
8004   }
8005   {
8006     try {
8007       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8008     } CALL_CATCH_EXCEPTION(0);
8009   }
8010
8011   jresult = result;
8012   return jresult;
8013 }
8014
8015
8016 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8017   bool jresult ;
8018   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8019   Dali::Matrix *arg2 = 0 ;
8020   bool result;
8021
8022   arg1 = (Dali::Matrix *)jarg1;
8023   arg2 = (Dali::Matrix *)jarg2;
8024   if (!arg2) {
8025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8026     return 0;
8027   }
8028   {
8029     try {
8030       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8031     } CALL_CATCH_EXCEPTION(0);
8032   }
8033
8034   jresult = result;
8035   return jresult;
8036 }
8037
8038
8039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8040   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8041   Dali::Vector3 *arg2 = 0 ;
8042   Dali::Quaternion *arg3 = 0 ;
8043   Dali::Vector3 *arg4 = 0 ;
8044
8045   arg1 = (Dali::Matrix *)jarg1;
8046   arg2 = (Dali::Vector3 *)jarg2;
8047   if (!arg2) {
8048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8049     return ;
8050   }
8051   arg3 = (Dali::Quaternion *)jarg3;
8052   if (!arg3) {
8053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8054     return ;
8055   }
8056   arg4 = (Dali::Vector3 *)jarg4;
8057   if (!arg4) {
8058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8059     return ;
8060   }
8061   {
8062     try {
8063       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8064     } CALL_CATCH_EXCEPTION();
8065   }
8066
8067 }
8068
8069
8070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8071   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8072   Dali::Vector3 *arg2 = 0 ;
8073   Dali::Quaternion *arg3 = 0 ;
8074   Dali::Vector3 *arg4 = 0 ;
8075
8076   arg1 = (Dali::Matrix *)jarg1;
8077   arg2 = (Dali::Vector3 *)jarg2;
8078   if (!arg2) {
8079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8080     return ;
8081   }
8082   arg3 = (Dali::Quaternion *)jarg3;
8083   if (!arg3) {
8084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8085     return ;
8086   }
8087   arg4 = (Dali::Vector3 *)jarg4;
8088   if (!arg4) {
8089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8090     return ;
8091   }
8092   {
8093     try {
8094       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8095     } CALL_CATCH_EXCEPTION();
8096   }
8097
8098 }
8099
8100
8101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8102   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8103   Dali::Vector3 *arg2 = 0 ;
8104   Dali::Vector3 *arg3 = 0 ;
8105   Dali::Vector3 *arg4 = 0 ;
8106   Dali::Vector3 *arg5 = 0 ;
8107
8108   arg1 = (Dali::Matrix *)jarg1;
8109   arg2 = (Dali::Vector3 *)jarg2;
8110   if (!arg2) {
8111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8112     return ;
8113   }
8114   arg3 = (Dali::Vector3 *)jarg3;
8115   if (!arg3) {
8116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8117     return ;
8118   }
8119   arg4 = (Dali::Vector3 *)jarg4;
8120   if (!arg4) {
8121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8122     return ;
8123   }
8124   arg5 = (Dali::Vector3 *)jarg5;
8125   if (!arg5) {
8126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8127     return ;
8128   }
8129   {
8130     try {
8131       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8132     } CALL_CATCH_EXCEPTION();
8133   }
8134
8135 }
8136
8137
8138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8139   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8140   Dali::Vector3 *arg2 = 0 ;
8141   Dali::Quaternion *arg3 = 0 ;
8142   Dali::Vector3 *arg4 = 0 ;
8143
8144   arg1 = (Dali::Matrix *)jarg1;
8145   arg2 = (Dali::Vector3 *)jarg2;
8146   if (!arg2) {
8147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8148     return ;
8149   }
8150   arg3 = (Dali::Quaternion *)jarg3;
8151   if (!arg3) {
8152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
8153     return ;
8154   }
8155   arg4 = (Dali::Vector3 *)jarg4;
8156   if (!arg4) {
8157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
8158     return ;
8159   }
8160   {
8161     try {
8162       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
8163     } CALL_CATCH_EXCEPTION();
8164   }
8165
8166 }
8167
8168
8169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
8170   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8171
8172   arg1 = (Dali::Matrix *)jarg1;
8173   {
8174     try {
8175       delete arg1;
8176     } CALL_CATCH_EXCEPTION();
8177   }
8178
8179 }
8180
8181
8182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
8183   void * jresult ;
8184   Dali::Matrix3 *result = 0 ;
8185
8186   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
8187   jresult = (void *)result;
8188   return jresult;
8189 }
8190
8191
8192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
8193   void * jresult ;
8194   Dali::Matrix3 *result = 0 ;
8195
8196   {
8197     try {
8198       result = (Dali::Matrix3 *)new Dali::Matrix3();
8199     } CALL_CATCH_EXCEPTION(0);
8200   }
8201
8202   jresult = (void *)result;
8203   return jresult;
8204 }
8205
8206
8207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
8208   void * jresult ;
8209   Dali::Matrix3 *arg1 = 0 ;
8210   Dali::Matrix3 *result = 0 ;
8211
8212   arg1 = (Dali::Matrix3 *)jarg1;
8213   if (!arg1) {
8214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8215     return 0;
8216   }
8217   {
8218     try {
8219       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
8220     } CALL_CATCH_EXCEPTION(0);
8221   }
8222
8223   jresult = (void *)result;
8224   return jresult;
8225 }
8226
8227
8228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
8229   void * jresult ;
8230   Dali::Matrix *arg1 = 0 ;
8231   Dali::Matrix3 *result = 0 ;
8232
8233   arg1 = (Dali::Matrix *)jarg1;
8234   if (!arg1) {
8235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8236     return 0;
8237   }
8238   {
8239     try {
8240       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
8241     } CALL_CATCH_EXCEPTION(0);
8242   }
8243
8244   jresult = (void *)result;
8245   return jresult;
8246 }
8247
8248
8249 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) {
8250   void * jresult ;
8251   float arg1 ;
8252   float arg2 ;
8253   float arg3 ;
8254   float arg4 ;
8255   float arg5 ;
8256   float arg6 ;
8257   float arg7 ;
8258   float arg8 ;
8259   float arg9 ;
8260   Dali::Matrix3 *result = 0 ;
8261
8262   arg1 = (float)jarg1;
8263   arg2 = (float)jarg2;
8264   arg3 = (float)jarg3;
8265   arg4 = (float)jarg4;
8266   arg5 = (float)jarg5;
8267   arg6 = (float)jarg6;
8268   arg7 = (float)jarg7;
8269   arg8 = (float)jarg8;
8270   arg9 = (float)jarg9;
8271   {
8272     try {
8273       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8274     } CALL_CATCH_EXCEPTION(0);
8275   }
8276
8277   jresult = (void *)result;
8278   return jresult;
8279 }
8280
8281
8282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
8283   void * jresult ;
8284   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8285   Dali::Matrix3 *arg2 = 0 ;
8286   Dali::Matrix3 *result = 0 ;
8287
8288   arg1 = (Dali::Matrix3 *)jarg1;
8289   arg2 = (Dali::Matrix3 *)jarg2;
8290   if (!arg2) {
8291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8292     return 0;
8293   }
8294   {
8295     try {
8296       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
8297     } CALL_CATCH_EXCEPTION(0);
8298   }
8299
8300   jresult = (void *)result;
8301   return jresult;
8302 }
8303
8304
8305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
8306   void * jresult ;
8307   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8308   Dali::Matrix *arg2 = 0 ;
8309   Dali::Matrix3 *result = 0 ;
8310
8311   arg1 = (Dali::Matrix3 *)jarg1;
8312   arg2 = (Dali::Matrix *)jarg2;
8313   if (!arg2) {
8314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8315     return 0;
8316   }
8317   {
8318     try {
8319       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8320     } CALL_CATCH_EXCEPTION(0);
8321   }
8322
8323   jresult = (void *)result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
8329   bool jresult ;
8330   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8331   Dali::Matrix3 *arg2 = 0 ;
8332   bool result;
8333
8334   arg1 = (Dali::Matrix3 *)jarg1;
8335   arg2 = (Dali::Matrix3 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
8343     } CALL_CATCH_EXCEPTION(0);
8344   }
8345
8346   jresult = result;
8347   return jresult;
8348 }
8349
8350
8351 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
8352   bool jresult ;
8353   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8354   Dali::Matrix3 *arg2 = 0 ;
8355   bool result;
8356
8357   arg1 = (Dali::Matrix3 *)jarg1;
8358   arg2 = (Dali::Matrix3 *)jarg2;
8359   if (!arg2) {
8360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8361     return 0;
8362   }
8363   {
8364     try {
8365       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
8366     } CALL_CATCH_EXCEPTION(0);
8367   }
8368
8369   jresult = result;
8370   return jresult;
8371 }
8372
8373
8374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
8375   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8376
8377   arg1 = (Dali::Matrix3 *)jarg1;
8378   {
8379     try {
8380       delete arg1;
8381     } CALL_CATCH_EXCEPTION();
8382   }
8383
8384 }
8385
8386
8387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
8388   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8389
8390   arg1 = (Dali::Matrix3 *)jarg1;
8391   {
8392     try {
8393       (arg1)->SetIdentity();
8394     } CALL_CATCH_EXCEPTION();
8395   }
8396
8397 }
8398
8399
8400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
8401   void * jresult ;
8402   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8403   float *result = 0 ;
8404
8405   arg1 = (Dali::Matrix3 *)jarg1;
8406   {
8407     try {
8408       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
8409     } CALL_CATCH_EXCEPTION(0);
8410   }
8411
8412   jresult = (void *)result;
8413   return jresult;
8414 }
8415
8416
8417 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
8418   bool jresult ;
8419   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8420   bool result;
8421
8422   arg1 = (Dali::Matrix3 *)jarg1;
8423   {
8424     try {
8425       result = (bool)(arg1)->Invert();
8426     } CALL_CATCH_EXCEPTION(0);
8427   }
8428
8429   jresult = result;
8430   return jresult;
8431 }
8432
8433
8434 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
8435   bool jresult ;
8436   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8437   bool result;
8438
8439   arg1 = (Dali::Matrix3 *)jarg1;
8440   {
8441     try {
8442       result = (bool)(arg1)->Transpose();
8443     } CALL_CATCH_EXCEPTION(0);
8444   }
8445
8446   jresult = result;
8447   return jresult;
8448 }
8449
8450
8451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
8452   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8453   float arg2 ;
8454
8455   arg1 = (Dali::Matrix3 *)jarg1;
8456   arg2 = (float)jarg2;
8457   {
8458     try {
8459       (arg1)->Scale(arg2);
8460     } CALL_CATCH_EXCEPTION();
8461   }
8462
8463 }
8464
8465
8466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
8467   float jresult ;
8468   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8469   float result;
8470
8471   arg1 = (Dali::Matrix3 *)jarg1;
8472   {
8473     try {
8474       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
8475     } CALL_CATCH_EXCEPTION(0);
8476   }
8477
8478   jresult = result;
8479   return jresult;
8480 }
8481
8482
8483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
8484   bool jresult ;
8485   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
8486   bool result;
8487
8488   arg1 = (Dali::Matrix3 *)jarg1;
8489   {
8490     try {
8491       result = (bool)(arg1)->ScaledInverseTranspose();
8492     } CALL_CATCH_EXCEPTION(0);
8493   }
8494
8495   jresult = result;
8496   return jresult;
8497 }
8498
8499
8500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
8501   Dali::Matrix3 *arg1 = 0 ;
8502   Dali::Matrix3 *arg2 = 0 ;
8503   Dali::Matrix3 *arg3 = 0 ;
8504
8505   arg1 = (Dali::Matrix3 *)jarg1;
8506   if (!arg1) {
8507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
8508     return ;
8509   }
8510   arg2 = (Dali::Matrix3 *)jarg2;
8511   if (!arg2) {
8512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8513     return ;
8514   }
8515   arg3 = (Dali::Matrix3 *)jarg3;
8516   if (!arg3) {
8517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
8518     return ;
8519   }
8520   {
8521     try {
8522       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
8523     } CALL_CATCH_EXCEPTION();
8524   }
8525
8526 }
8527
8528
8529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
8530   float jresult ;
8531   float arg1 ;
8532   float arg2 ;
8533   float result;
8534
8535   arg1 = (float)jarg1;
8536   arg2 = (float)jarg2;
8537   {
8538     try {
8539       result = (float)Dali::Random::Range(arg1,arg2);
8540     } CALL_CATCH_EXCEPTION(0);
8541   }
8542
8543   jresult = result;
8544   return jresult;
8545 }
8546
8547
8548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
8549   void * jresult ;
8550   Dali::Vector4 result;
8551
8552   {
8553     try {
8554       result = Dali::Random::Axis();
8555     } CALL_CATCH_EXCEPTION(0);
8556   }
8557
8558   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8559   return jresult;
8560 }
8561
8562
8563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
8564   void * jresult ;
8565   Dali::AngleAxis *result = 0 ;
8566
8567   {
8568     try {
8569       result = (Dali::AngleAxis *)new Dali::AngleAxis();
8570     } CALL_CATCH_EXCEPTION(0);
8571   }
8572
8573   jresult = (void *)result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
8579   void * jresult ;
8580   Dali::Radian arg1 ;
8581   Dali::Vector3 *arg2 = 0 ;
8582   Dali::Radian *argp1 ;
8583   Dali::AngleAxis *result = 0 ;
8584
8585   argp1 = (Dali::Radian *)jarg1;
8586   if (!argp1) {
8587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8588     return 0;
8589   }
8590   arg1 = *argp1;
8591   arg2 = (Dali::Vector3 *)jarg2;
8592   if (!arg2) {
8593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8594     return 0;
8595   }
8596   {
8597     try {
8598       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
8599     } CALL_CATCH_EXCEPTION(0);
8600   }
8601
8602   jresult = (void *)result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
8608   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8609   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
8610
8611   arg1 = (Dali::AngleAxis *)jarg1;
8612   arg2 = (Dali::Radian *)jarg2;
8613   if (arg1) (arg1)->angle = *arg2;
8614 }
8615
8616
8617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
8618   void * jresult ;
8619   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8620   Dali::Radian *result = 0 ;
8621
8622   arg1 = (Dali::AngleAxis *)jarg1;
8623   result = (Dali::Radian *)& ((arg1)->angle);
8624   jresult = (void *)result;
8625   return jresult;
8626 }
8627
8628
8629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
8630   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8631   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
8632
8633   arg1 = (Dali::AngleAxis *)jarg1;
8634   arg2 = (Dali::Vector3 *)jarg2;
8635   if (arg1) (arg1)->axis = *arg2;
8636 }
8637
8638
8639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
8640   void * jresult ;
8641   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8642   Dali::Vector3 *result = 0 ;
8643
8644   arg1 = (Dali::AngleAxis *)jarg1;
8645   result = (Dali::Vector3 *)& ((arg1)->axis);
8646   jresult = (void *)result;
8647   return jresult;
8648 }
8649
8650
8651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
8652   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
8653
8654   arg1 = (Dali::AngleAxis *)jarg1;
8655   {
8656     try {
8657       delete arg1;
8658     } CALL_CATCH_EXCEPTION();
8659   }
8660
8661 }
8662
8663
8664 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
8665   bool jresult ;
8666   Dali::AngleAxis *arg1 = 0 ;
8667   Dali::AngleAxis *arg2 = 0 ;
8668   bool result;
8669
8670   arg1 = (Dali::AngleAxis *)jarg1;
8671   if (!arg1) {
8672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
8673     return 0;
8674   }
8675   arg2 = (Dali::AngleAxis *)jarg2;
8676   if (!arg2) {
8677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
8678     return 0;
8679   }
8680   {
8681     try {
8682       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
8683     } CALL_CATCH_EXCEPTION(0);
8684   }
8685
8686   jresult = result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
8692   unsigned int jresult ;
8693   unsigned int arg1 ;
8694   unsigned int result;
8695
8696   arg1 = (unsigned int)jarg1;
8697   {
8698     try {
8699       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
8700     } CALL_CATCH_EXCEPTION(0);
8701   }
8702
8703   jresult = result;
8704   return jresult;
8705 }
8706
8707
8708 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
8709   bool jresult ;
8710   unsigned int arg1 ;
8711   bool result;
8712
8713   arg1 = (unsigned int)jarg1;
8714   {
8715     try {
8716       result = (bool)Dali::IsPowerOfTwo(arg1);
8717     } CALL_CATCH_EXCEPTION(0);
8718   }
8719
8720   jresult = result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
8726   float jresult ;
8727   float arg1 ;
8728   float arg2 ;
8729   float result;
8730
8731   arg1 = (float)jarg1;
8732   arg2 = (float)jarg2;
8733   {
8734     try {
8735       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
8736     } CALL_CATCH_EXCEPTION(0);
8737   }
8738
8739   jresult = result;
8740   return jresult;
8741 }
8742
8743
8744 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
8745   bool jresult ;
8746   float arg1 ;
8747   bool result;
8748
8749   arg1 = (float)jarg1;
8750   {
8751     try {
8752       result = (bool)Dali::EqualsZero(arg1);
8753     } CALL_CATCH_EXCEPTION(0);
8754   }
8755
8756   jresult = result;
8757   return jresult;
8758 }
8759
8760
8761 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
8762   bool jresult ;
8763   float arg1 ;
8764   float arg2 ;
8765   bool result;
8766
8767   arg1 = (float)jarg1;
8768   arg2 = (float)jarg2;
8769   {
8770     try {
8771       result = (bool)Dali::Equals(arg1,arg2);
8772     } CALL_CATCH_EXCEPTION(0);
8773   }
8774
8775   jresult = result;
8776   return jresult;
8777 }
8778
8779
8780 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
8781   bool jresult ;
8782   float arg1 ;
8783   float arg2 ;
8784   float arg3 ;
8785   bool result;
8786
8787   arg1 = (float)jarg1;
8788   arg2 = (float)jarg2;
8789   arg3 = (float)jarg3;
8790   {
8791     try {
8792       result = (bool)Dali::Equals(arg1,arg2,arg3);
8793     } CALL_CATCH_EXCEPTION(0);
8794   }
8795
8796   jresult = result;
8797   return jresult;
8798 }
8799
8800
8801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
8802   float jresult ;
8803   float arg1 ;
8804   int arg2 ;
8805   float result;
8806
8807   arg1 = (float)jarg1;
8808   arg2 = (int)jarg2;
8809   {
8810     try {
8811       result = (float)Dali::Round(arg1,arg2);
8812     } CALL_CATCH_EXCEPTION(0);
8813   }
8814
8815   jresult = result;
8816   return jresult;
8817 }
8818
8819
8820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
8821   float jresult ;
8822   float arg1 ;
8823   float arg2 ;
8824   float arg3 ;
8825   float result;
8826
8827   arg1 = (float)jarg1;
8828   arg2 = (float)jarg2;
8829   arg3 = (float)jarg3;
8830   {
8831     try {
8832       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
8833     } CALL_CATCH_EXCEPTION(0);
8834   }
8835
8836   jresult = result;
8837   return jresult;
8838 }
8839
8840
8841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
8842   float jresult ;
8843   float arg1 ;
8844   float arg2 ;
8845   float arg3 ;
8846   float arg4 ;
8847   float result;
8848
8849   arg1 = (float)jarg1;
8850   arg2 = (float)jarg2;
8851   arg3 = (float)jarg3;
8852   arg4 = (float)jarg4;
8853   {
8854     try {
8855       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
8856     } CALL_CATCH_EXCEPTION(0);
8857   }
8858
8859   jresult = result;
8860   return jresult;
8861 }
8862
8863
8864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
8865   int jresult ;
8866   int result;
8867
8868   result = (int)(int)Dali::Property::INVALID_INDEX;
8869   jresult = result;
8870   return jresult;
8871 }
8872
8873
8874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
8875   int jresult ;
8876   int result;
8877
8878   result = (int)(int)Dali::Property::INVALID_KEY;
8879   jresult = result;
8880   return jresult;
8881 }
8882
8883
8884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
8885   int jresult ;
8886   int result;
8887
8888   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
8889   jresult = result;
8890   return jresult;
8891 }
8892
8893
8894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
8895   void * jresult ;
8896   Dali::Handle *arg1 = 0 ;
8897   Dali::Property::Index arg2 ;
8898   Dali::Property *result = 0 ;
8899
8900   arg1 = (Dali::Handle *)jarg1;
8901   if (!arg1) {
8902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
8903     return 0;
8904   }
8905   arg2 = (Dali::Property::Index)jarg2;
8906   {
8907     try {
8908       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
8909     } CALL_CATCH_EXCEPTION(0);
8910   }
8911
8912   jresult = (void *)result;
8913   return jresult;
8914 }
8915
8916
8917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
8918   void * jresult ;
8919   Dali::Handle *arg1 = 0 ;
8920   Dali::Property::Index arg2 ;
8921   int arg3 ;
8922   Dali::Property *result = 0 ;
8923
8924   arg1 = (Dali::Handle *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
8927     return 0;
8928   }
8929   arg2 = (Dali::Property::Index)jarg2;
8930   arg3 = (int)jarg3;
8931   {
8932     try {
8933       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
8934     } CALL_CATCH_EXCEPTION(0);
8935   }
8936
8937   jresult = (void *)result;
8938   return jresult;
8939 }
8940
8941
8942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
8943   void * jresult ;
8944   Dali::Handle *arg1 = 0 ;
8945   std::string *arg2 = 0 ;
8946   Dali::Property *result = 0 ;
8947
8948   arg1 = (Dali::Handle *)jarg1;
8949   if (!arg1) {
8950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
8951     return 0;
8952   }
8953   if (!jarg2) {
8954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8955     return 0;
8956   }
8957   std::string arg2_str(jarg2);
8958   arg2 = &arg2_str;
8959   {
8960     try {
8961       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
8962     } CALL_CATCH_EXCEPTION(0);
8963   }
8964
8965   jresult = (void *)result;
8966
8967   //argout typemap for const std::string&
8968
8969   return jresult;
8970 }
8971
8972
8973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
8974   void * jresult ;
8975   Dali::Handle *arg1 = 0 ;
8976   std::string *arg2 = 0 ;
8977   int arg3 ;
8978   Dali::Property *result = 0 ;
8979
8980   arg1 = (Dali::Handle *)jarg1;
8981   if (!arg1) {
8982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
8983     return 0;
8984   }
8985   if (!jarg2) {
8986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8987     return 0;
8988   }
8989   std::string arg2_str(jarg2);
8990   arg2 = &arg2_str;
8991   arg3 = (int)jarg3;
8992   {
8993     try {
8994       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
8995     } CALL_CATCH_EXCEPTION(0);
8996   }
8997
8998   jresult = (void *)result;
8999
9000   //argout typemap for const std::string&
9001
9002   return jresult;
9003 }
9004
9005
9006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9007   Dali::Property *arg1 = (Dali::Property *) 0 ;
9008
9009   arg1 = (Dali::Property *)jarg1;
9010   {
9011     try {
9012       delete arg1;
9013     } CALL_CATCH_EXCEPTION();
9014   }
9015
9016 }
9017
9018
9019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9020   Dali::Property *arg1 = (Dali::Property *) 0 ;
9021   Dali::Handle *arg2 = 0 ;
9022
9023   arg1 = (Dali::Property *)jarg1;
9024   arg2 = (Dali::Handle *)jarg2;
9025   if (!arg2) {
9026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9027     return ;
9028   }
9029   if (arg1) (arg1)->object = *arg2;
9030 }
9031
9032
9033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9034   void * jresult ;
9035   Dali::Property *arg1 = (Dali::Property *) 0 ;
9036   Dali::Handle *result = 0 ;
9037
9038   arg1 = (Dali::Property *)jarg1;
9039   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9040   jresult = (void *)result;
9041   return jresult;
9042 }
9043
9044
9045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9046   Dali::Property *arg1 = (Dali::Property *) 0 ;
9047   Dali::Property::Index arg2 ;
9048
9049   arg1 = (Dali::Property *)jarg1;
9050   arg2 = (Dali::Property::Index)jarg2;
9051   if (arg1) (arg1)->propertyIndex = arg2;
9052 }
9053
9054
9055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9056   int jresult ;
9057   Dali::Property *arg1 = (Dali::Property *) 0 ;
9058   Dali::Property::Index result;
9059
9060   arg1 = (Dali::Property *)jarg1;
9061   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9062   jresult = result;
9063   return jresult;
9064 }
9065
9066
9067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9068   Dali::Property *arg1 = (Dali::Property *) 0 ;
9069   int arg2 ;
9070
9071   arg1 = (Dali::Property *)jarg1;
9072   arg2 = (int)jarg2;
9073   if (arg1) (arg1)->componentIndex = arg2;
9074 }
9075
9076
9077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9078   int jresult ;
9079   Dali::Property *arg1 = (Dali::Property *) 0 ;
9080   int result;
9081
9082   arg1 = (Dali::Property *)jarg1;
9083   result = (int) ((arg1)->componentIndex);
9084   jresult = result;
9085   return jresult;
9086 }
9087
9088
9089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9090   void * jresult ;
9091   Dali::Property::Array *result = 0 ;
9092
9093   {
9094     try {
9095       result = (Dali::Property::Array *)new Dali::Property::Array();
9096     } CALL_CATCH_EXCEPTION(0);
9097   }
9098
9099   jresult = (void *)result;
9100   return jresult;
9101 }
9102
9103
9104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9105   void * jresult ;
9106   Dali::Property::Array *arg1 = 0 ;
9107   Dali::Property::Array *result = 0 ;
9108
9109   arg1 = (Dali::Property::Array *)jarg1;
9110   if (!arg1) {
9111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9112     return 0;
9113   }
9114   {
9115     try {
9116       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9117     } CALL_CATCH_EXCEPTION(0);
9118   }
9119
9120   jresult = (void *)result;
9121   return jresult;
9122 }
9123
9124
9125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9126   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9127
9128   arg1 = (Dali::Property::Array *)jarg1;
9129   {
9130     try {
9131       delete arg1;
9132     } CALL_CATCH_EXCEPTION();
9133   }
9134
9135 }
9136
9137
9138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
9139   unsigned long jresult ;
9140   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9141   Dali::Property::Array::SizeType result;
9142
9143   arg1 = (Dali::Property::Array *)jarg1;
9144   {
9145     try {
9146       result = ((Dali::Property::Array const *)arg1)->Size();
9147     } CALL_CATCH_EXCEPTION(0);
9148   }
9149
9150   jresult = (unsigned long)result;
9151   return jresult;
9152 }
9153
9154
9155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
9156   unsigned long jresult ;
9157   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9158   Dali::Property::Array::SizeType result;
9159
9160   arg1 = (Dali::Property::Array *)jarg1;
9161   {
9162     try {
9163       result = ((Dali::Property::Array const *)arg1)->Count();
9164     } CALL_CATCH_EXCEPTION(0);
9165   }
9166
9167   jresult = (unsigned long)result;
9168   return jresult;
9169 }
9170
9171
9172 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
9173   bool jresult ;
9174   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9175   bool result;
9176
9177   arg1 = (Dali::Property::Array *)jarg1;
9178   {
9179     try {
9180       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
9181     } CALL_CATCH_EXCEPTION(0);
9182   }
9183
9184   jresult = result;
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
9190   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9191
9192   arg1 = (Dali::Property::Array *)jarg1;
9193   {
9194     try {
9195       (arg1)->Clear();
9196     } CALL_CATCH_EXCEPTION();
9197   }
9198
9199 }
9200
9201
9202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
9203   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9204   Dali::Property::Array::SizeType arg2 ;
9205
9206   arg1 = (Dali::Property::Array *)jarg1;
9207   arg2 = (Dali::Property::Array::SizeType)jarg2;
9208   {
9209     try {
9210       (arg1)->Reserve(arg2);
9211     } CALL_CATCH_EXCEPTION();
9212   }
9213
9214 }
9215
9216
9217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
9218   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9219   Dali::Property::Array::SizeType arg2 ;
9220
9221   arg1 = (Dali::Property::Array *)jarg1;
9222   arg2 = (Dali::Property::Array::SizeType)jarg2;
9223   {
9224     try {
9225       (arg1)->Resize(arg2);
9226     } CALL_CATCH_EXCEPTION();
9227   }
9228
9229 }
9230
9231
9232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
9233   unsigned long jresult ;
9234   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9235   Dali::Property::Array::SizeType result;
9236
9237   arg1 = (Dali::Property::Array *)jarg1;
9238   {
9239     try {
9240       result = (arg1)->Capacity();
9241     } CALL_CATCH_EXCEPTION(0);
9242   }
9243
9244   jresult = (unsigned long)result;
9245   return jresult;
9246 }
9247
9248
9249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
9250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9251   Dali::Property::Value *arg2 = 0 ;
9252
9253   arg1 = (Dali::Property::Array *)jarg1;
9254   arg2 = (Dali::Property::Value *)jarg2;
9255   if (!arg2) {
9256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9257     return ;
9258   }
9259   {
9260     try {
9261       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
9262     } CALL_CATCH_EXCEPTION();
9263   }
9264
9265 }
9266
9267
9268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
9269   void * jresult ;
9270   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9271   Dali::Property::Value *arg2 = 0 ;
9272   Dali::Property::Array *result = 0 ;
9273
9274   arg1 = (Dali::Property::Array *)jarg1;
9275   arg2 = (Dali::Property::Value *)jarg2;
9276   if (!arg2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9278     return 0;
9279   }
9280   {
9281     try {
9282       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
9283     } CALL_CATCH_EXCEPTION(0);
9284   }
9285
9286   jresult = (void *)result;
9287   return jresult;
9288 }
9289
9290
9291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
9292   void * jresult ;
9293   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9294   Dali::Property::Array::SizeType arg2 ;
9295   Dali::Property::Value *result = 0 ;
9296
9297   arg1 = (Dali::Property::Array *)jarg1;
9298   arg2 = (Dali::Property::Array::SizeType)jarg2;
9299   {
9300     try {
9301       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
9302     } CALL_CATCH_EXCEPTION(0);
9303   }
9304
9305   jresult = (void *)result;
9306   return jresult;
9307 }
9308
9309
9310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
9311   void * jresult ;
9312   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9313   Dali::Property::Array::SizeType arg2 ;
9314   Dali::Property::Value *result = 0 ;
9315
9316   arg1 = (Dali::Property::Array *)jarg1;
9317   arg2 = (Dali::Property::Array::SizeType)jarg2;
9318   {
9319     try {
9320       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
9321     } CALL_CATCH_EXCEPTION(0);
9322   }
9323
9324   jresult = (void *)result;
9325   return jresult;
9326 }
9327
9328
9329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
9330   void * jresult ;
9331   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9332   Dali::Property::Array *arg2 = 0 ;
9333   Dali::Property::Array *result = 0 ;
9334
9335   arg1 = (Dali::Property::Array *)jarg1;
9336   arg2 = (Dali::Property::Array *)jarg2;
9337   if (!arg2) {
9338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9339     return 0;
9340   }
9341   {
9342     try {
9343       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
9344     } CALL_CATCH_EXCEPTION(0);
9345   }
9346
9347   jresult = (void *)result;
9348   return jresult;
9349 }
9350
9351
9352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
9353   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9354   enum Dali::Property::Key::Type arg2 ;
9355
9356   arg1 = (Dali::Property::Key *)jarg1;
9357   arg2 = (enum Dali::Property::Key::Type)jarg2;
9358   if (arg1) (arg1)->type = arg2;
9359 }
9360
9361
9362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
9363   int jresult ;
9364   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9365   enum Dali::Property::Key::Type result;
9366
9367   arg1 = (Dali::Property::Key *)jarg1;
9368   result = (enum Dali::Property::Key::Type) ((arg1)->type);
9369   jresult = (int)result;
9370   return jresult;
9371 }
9372
9373
9374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
9375   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9376   Dali::Property::Index arg2 ;
9377
9378   arg1 = (Dali::Property::Key *)jarg1;
9379   arg2 = (Dali::Property::Index)jarg2;
9380   if (arg1) (arg1)->indexKey = arg2;
9381 }
9382
9383
9384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
9385   int jresult ;
9386   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9387   Dali::Property::Index result;
9388
9389   arg1 = (Dali::Property::Key *)jarg1;
9390   result = (Dali::Property::Index) ((arg1)->indexKey);
9391   jresult = result;
9392   return jresult;
9393 }
9394
9395
9396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
9397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9398   std::string *arg2 = 0 ;
9399
9400   arg1 = (Dali::Property::Key *)jarg1;
9401   if (!jarg2) {
9402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9403     return ;
9404   }
9405   std::string arg2_str(jarg2);
9406   arg2 = &arg2_str;
9407   if (arg1) (arg1)->stringKey = *arg2;
9408
9409   //argout typemap for const std::string&
9410
9411 }
9412
9413
9414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
9415   char * jresult ;
9416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9417   std::string *result = 0 ;
9418
9419   arg1 = (Dali::Property::Key *)jarg1;
9420   result = (std::string *) & ((arg1)->stringKey);
9421   jresult = SWIG_csharp_string_callback(result->c_str());
9422   return jresult;
9423 }
9424
9425
9426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
9427   void * jresult ;
9428   std::string *arg1 = 0 ;
9429   Dali::Property::Key *result = 0 ;
9430
9431   if (!jarg1) {
9432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9433     return 0;
9434   }
9435   std::string arg1_str(jarg1);
9436   arg1 = &arg1_str;
9437   {
9438     try {
9439       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
9440     } CALL_CATCH_EXCEPTION(0);
9441   }
9442
9443   jresult = (void *)result;
9444
9445   //argout typemap for const std::string&
9446
9447   return jresult;
9448 }
9449
9450
9451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
9452   void * jresult ;
9453   Dali::Property::Index arg1 ;
9454   Dali::Property::Key *result = 0 ;
9455
9456   arg1 = (Dali::Property::Index)jarg1;
9457   {
9458     try {
9459       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
9460     } CALL_CATCH_EXCEPTION(0);
9461   }
9462
9463   jresult = (void *)result;
9464   return jresult;
9465 }
9466
9467
9468 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
9469   bool jresult ;
9470   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9471   std::string *arg2 = 0 ;
9472   bool result;
9473
9474   arg1 = (Dali::Property::Key *)jarg1;
9475   if (!jarg2) {
9476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9477     return 0;
9478   }
9479   std::string arg2_str(jarg2);
9480   arg2 = &arg2_str;
9481   {
9482     try {
9483       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
9484     } CALL_CATCH_EXCEPTION(0);
9485   }
9486
9487   jresult = result;
9488
9489   //argout typemap for const std::string&
9490
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
9496   bool jresult ;
9497   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9498   Dali::Property::Index arg2 ;
9499   bool result;
9500
9501   arg1 = (Dali::Property::Key *)jarg1;
9502   arg2 = (Dali::Property::Index)jarg2;
9503   {
9504     try {
9505       result = (bool)(arg1)->operator ==(arg2);
9506     } CALL_CATCH_EXCEPTION(0);
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
9515   bool jresult ;
9516   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9517   Dali::Property::Key *arg2 = 0 ;
9518   bool result;
9519
9520   arg1 = (Dali::Property::Key *)jarg1;
9521   arg2 = (Dali::Property::Key *)jarg2;
9522   if (!arg2) {
9523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9524     return 0;
9525   }
9526   {
9527     try {
9528       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
9529     } CALL_CATCH_EXCEPTION(0);
9530   }
9531
9532   jresult = result;
9533   return jresult;
9534 }
9535
9536
9537 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
9538   bool jresult ;
9539   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9540   std::string *arg2 = 0 ;
9541   bool result;
9542
9543   arg1 = (Dali::Property::Key *)jarg1;
9544   if (!jarg2) {
9545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9546     return 0;
9547   }
9548   std::string arg2_str(jarg2);
9549   arg2 = &arg2_str;
9550   {
9551     try {
9552       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
9553     } CALL_CATCH_EXCEPTION(0);
9554   }
9555
9556   jresult = result;
9557
9558   //argout typemap for const std::string&
9559
9560   return jresult;
9561 }
9562
9563
9564 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
9565   bool jresult ;
9566   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9567   Dali::Property::Index arg2 ;
9568   bool result;
9569
9570   arg1 = (Dali::Property::Key *)jarg1;
9571   arg2 = (Dali::Property::Index)jarg2;
9572   {
9573     try {
9574       result = (bool)(arg1)->operator !=(arg2);
9575     } CALL_CATCH_EXCEPTION(0);
9576   }
9577
9578   jresult = result;
9579   return jresult;
9580 }
9581
9582
9583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
9584   bool jresult ;
9585   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9586   Dali::Property::Key *arg2 = 0 ;
9587   bool result;
9588
9589   arg1 = (Dali::Property::Key *)jarg1;
9590   arg2 = (Dali::Property::Key *)jarg2;
9591   if (!arg2) {
9592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
9593     return 0;
9594   }
9595   {
9596     try {
9597       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
9598     } CALL_CATCH_EXCEPTION(0);
9599   }
9600
9601   jresult = result;
9602   return jresult;
9603 }
9604
9605
9606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
9607   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
9608
9609   arg1 = (Dali::Property::Key *)jarg1;
9610   {
9611     try {
9612       delete arg1;
9613     } CALL_CATCH_EXCEPTION();
9614   }
9615
9616 }
9617
9618
9619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
9620   void * jresult ;
9621   Dali::Property::Map *result = 0 ;
9622
9623   {
9624     try {
9625       result = (Dali::Property::Map *)new Dali::Property::Map();
9626     } CALL_CATCH_EXCEPTION(0);
9627   }
9628
9629   jresult = (void *)result;
9630   return jresult;
9631 }
9632
9633
9634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
9635   void * jresult ;
9636   Dali::Property::Map *arg1 = 0 ;
9637   Dali::Property::Map *result = 0 ;
9638
9639   arg1 = (Dali::Property::Map *)jarg1;
9640   if (!arg1) {
9641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
9642     return 0;
9643   }
9644   {
9645     try {
9646       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
9647     } CALL_CATCH_EXCEPTION(0);
9648   }
9649
9650   jresult = (void *)result;
9651   return jresult;
9652 }
9653
9654
9655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
9656   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9657
9658   arg1 = (Dali::Property::Map *)jarg1;
9659   {
9660     try {
9661       delete arg1;
9662     } CALL_CATCH_EXCEPTION();
9663   }
9664
9665 }
9666
9667
9668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
9669   unsigned long jresult ;
9670   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9671   Dali::Property::Map::SizeType result;
9672
9673   arg1 = (Dali::Property::Map *)jarg1;
9674   {
9675     try {
9676       result = ((Dali::Property::Map const *)arg1)->Count();
9677     } CALL_CATCH_EXCEPTION(0);
9678   }
9679
9680   jresult = (unsigned long)result;
9681   return jresult;
9682 }
9683
9684
9685 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
9686   bool jresult ;
9687   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9688   bool result;
9689
9690   arg1 = (Dali::Property::Map *)jarg1;
9691   {
9692     try {
9693       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
9694     } CALL_CATCH_EXCEPTION(0);
9695   }
9696
9697   jresult = result;
9698   return jresult;
9699 }
9700
9701
9702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9703   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9704   char *arg2 = (char *) 0 ;
9705   Dali::Property::Value *arg3 = 0 ;
9706
9707   arg1 = (Dali::Property::Map *)jarg1;
9708   arg2 = (char *)jarg2;
9709   arg3 = (Dali::Property::Value *)jarg3;
9710   if (!arg3) {
9711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9712     return ;
9713   }
9714   {
9715     try {
9716       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
9717     } CALL_CATCH_EXCEPTION();
9718   }
9719
9720 }
9721
9722
9723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
9724   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9725   Dali::Property::Index arg2 ;
9726   Dali::Property::Value *arg3 = 0 ;
9727
9728   arg1 = (Dali::Property::Map *)jarg1;
9729   arg2 = (Dali::Property::Index)jarg2;
9730   arg3 = (Dali::Property::Value *)jarg3;
9731   if (!arg3) {
9732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9733     return ;
9734   }
9735   {
9736     try {
9737       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
9738     } CALL_CATCH_EXCEPTION();
9739   }
9740
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9745   void * jresult ;
9746   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9747   char *arg2 = (char *) 0 ;
9748   Dali::Property::Value *arg3 = 0 ;
9749   Dali::Property::Map *result = 0 ;
9750
9751   arg1 = (Dali::Property::Map *)jarg1;
9752   arg2 = (char *)jarg2;
9753   arg3 = (Dali::Property::Value *)jarg3;
9754   if (!arg3) {
9755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9756     return 0;
9757   }
9758   {
9759     try {
9760       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
9761     } CALL_CATCH_EXCEPTION(0);
9762   }
9763
9764   jresult = (void *)result;
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
9770   void * jresult ;
9771   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9772   Dali::Property::Index arg2 ;
9773   Dali::Property::Value *arg3 = 0 ;
9774   Dali::Property::Map *result = 0 ;
9775
9776   arg1 = (Dali::Property::Map *)jarg1;
9777   arg2 = (Dali::Property::Index)jarg2;
9778   arg3 = (Dali::Property::Value *)jarg3;
9779   if (!arg3) {
9780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9781     return 0;
9782   }
9783   {
9784     try {
9785       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
9786     } CALL_CATCH_EXCEPTION(0);
9787   }
9788
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
9795   void * jresult ;
9796   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9797   Dali::Property::Map::SizeType arg2 ;
9798   Dali::Property::Value *result = 0 ;
9799
9800   arg1 = (Dali::Property::Map *)jarg1;
9801   arg2 = (Dali::Property::Map::SizeType)jarg2;
9802   {
9803     try {
9804       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
9805     } CALL_CATCH_EXCEPTION(0);
9806   }
9807
9808   jresult = (void *)result;
9809   return jresult;
9810 }
9811
9812
9813 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
9814   char * jresult ;
9815   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9816   Dali::Property::Map::SizeType arg2 ;
9817   std::string *result = 0 ;
9818
9819   arg1 = (Dali::Property::Map *)jarg1;
9820   arg2 = (Dali::Property::Map::SizeType)jarg2;
9821   {
9822     try {
9823       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
9824     } CALL_CATCH_EXCEPTION(0);
9825   }
9826
9827   jresult = SWIG_csharp_string_callback(result->c_str());
9828   return jresult;
9829 }
9830
9831
9832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
9833   void * jresult ;
9834   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9835   Dali::Property::Map::SizeType arg2 ;
9836   SwigValueWrapper< Dali::Property::Key > result;
9837
9838   arg1 = (Dali::Property::Map *)jarg1;
9839   arg2 = (Dali::Property::Map::SizeType)jarg2;
9840   {
9841     try {
9842       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
9843     } CALL_CATCH_EXCEPTION(0);
9844   }
9845
9846   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
9847   return jresult;
9848 }
9849
9850
9851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
9852   void * jresult ;
9853   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9854   Dali::Property::Map::SizeType arg2 ;
9855   StringValuePair *result = 0 ;
9856
9857   arg1 = (Dali::Property::Map *)jarg1;
9858   arg2 = (Dali::Property::Map::SizeType)jarg2;
9859   {
9860     try {
9861       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
9862     } CALL_CATCH_EXCEPTION(0);
9863   }
9864
9865   jresult = (void *)result;
9866   return jresult;
9867 }
9868
9869
9870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
9871   void * jresult ;
9872   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9873   char *arg2 = (char *) 0 ;
9874   Dali::Property::Value *result = 0 ;
9875
9876   arg1 = (Dali::Property::Map *)jarg1;
9877   arg2 = (char *)jarg2;
9878   {
9879     try {
9880       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
9881     } CALL_CATCH_EXCEPTION(0);
9882   }
9883
9884   jresult = (void *)result;
9885   return jresult;
9886 }
9887
9888
9889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
9890   void * jresult ;
9891   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9892   Dali::Property::Index arg2 ;
9893   Dali::Property::Value *result = 0 ;
9894
9895   arg1 = (Dali::Property::Map *)jarg1;
9896   arg2 = (Dali::Property::Index)jarg2;
9897   {
9898     try {
9899       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
9900     } CALL_CATCH_EXCEPTION(0);
9901   }
9902
9903   jresult = (void *)result;
9904   return jresult;
9905 }
9906
9907
9908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
9909   void * jresult ;
9910   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9911   Dali::Property::Index arg2 ;
9912   std::string *arg3 = 0 ;
9913   Dali::Property::Value *result = 0 ;
9914
9915   arg1 = (Dali::Property::Map *)jarg1;
9916   arg2 = (Dali::Property::Index)jarg2;
9917   if (!jarg3) {
9918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9919     return 0;
9920   }
9921   std::string arg3_str(jarg3);
9922   arg3 = &arg3_str;
9923   {
9924     try {
9925       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
9926     } CALL_CATCH_EXCEPTION(0);
9927   }
9928
9929   jresult = (void *)result;
9930
9931   //argout typemap for const std::string&
9932
9933   return jresult;
9934 }
9935
9936
9937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
9938   void * jresult ;
9939   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9940   std::string *arg2 = 0 ;
9941   Dali::Property::Type arg3 ;
9942   Dali::Property::Value *result = 0 ;
9943
9944   arg1 = (Dali::Property::Map *)jarg1;
9945   if (!jarg2) {
9946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9947     return 0;
9948   }
9949   std::string arg2_str(jarg2);
9950   arg2 = &arg2_str;
9951   arg3 = (Dali::Property::Type)jarg3;
9952   {
9953     try {
9954       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
9955     } CALL_CATCH_EXCEPTION(0);
9956   }
9957
9958   jresult = (void *)result;
9959
9960   //argout typemap for const std::string&
9961
9962   return jresult;
9963 }
9964
9965
9966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
9967   void * jresult ;
9968   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9969   Dali::Property::Index arg2 ;
9970   Dali::Property::Type arg3 ;
9971   Dali::Property::Value *result = 0 ;
9972
9973   arg1 = (Dali::Property::Map *)jarg1;
9974   arg2 = (Dali::Property::Index)jarg2;
9975   arg3 = (Dali::Property::Type)jarg3;
9976   {
9977     try {
9978       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
9979     } CALL_CATCH_EXCEPTION(0);
9980   }
9981
9982   jresult = (void *)result;
9983   return jresult;
9984 }
9985
9986
9987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
9988   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
9989
9990   arg1 = (Dali::Property::Map *)jarg1;
9991   {
9992     try {
9993       (arg1)->Clear();
9994     } CALL_CATCH_EXCEPTION();
9995   }
9996
9997 }
9998
9999
10000 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
10001   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10002   Dali::Property::Index intKey = (Dali::Property::Index)key;
10003   bool isRemoved = false;
10004   {
10005     try {
10006       isRemoved = propertyMap->Remove(intKey);
10007     } CALL_CATCH_EXCEPTION(0);
10008   }
10009   return isRemoved;
10010 }
10011
10012
10013 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
10014   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
10015   std::string strKey(key);
10016   bool isRemoved = false;
10017   {
10018     try {
10019       isRemoved = propertyMap->Remove(strKey);
10020     } CALL_CATCH_EXCEPTION(0);
10021   }
10022   return isRemoved;
10023 }
10024
10025
10026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10027   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10028   Dali::Property::Map *arg2 = 0 ;
10029
10030   arg1 = (Dali::Property::Map *)jarg1;
10031   arg2 = (Dali::Property::Map *)jarg2;
10032   if (!arg2) {
10033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10034     return ;
10035   }
10036   {
10037     try {
10038       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10039     } CALL_CATCH_EXCEPTION();
10040   }
10041
10042 }
10043
10044
10045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10046   void * jresult ;
10047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10048   std::string *arg2 = 0 ;
10049   Dali::Property::Value *result = 0 ;
10050
10051   arg1 = (Dali::Property::Map *)jarg1;
10052   if (!jarg2) {
10053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10054     return 0;
10055   }
10056   std::string arg2_str(jarg2);
10057   arg2 = &arg2_str;
10058   {
10059     try {
10060       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10061     } CALL_CATCH_EXCEPTION(0);
10062   }
10063
10064   jresult = (void *)result;
10065
10066   //argout typemap for const std::string&
10067
10068   return jresult;
10069 }
10070
10071
10072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10073   void * jresult ;
10074   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10075   Dali::Property::Index arg2 ;
10076   Dali::Property::Value *result = 0 ;
10077
10078   arg1 = (Dali::Property::Map *)jarg1;
10079   arg2 = (Dali::Property::Index)jarg2;
10080   {
10081     try {
10082       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10083     } CALL_CATCH_EXCEPTION(0);
10084   }
10085
10086   jresult = (void *)result;
10087   return jresult;
10088 }
10089
10090
10091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10092   void * jresult ;
10093   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10094   Dali::Property::Map *arg2 = 0 ;
10095   Dali::Property::Map *result = 0 ;
10096
10097   arg1 = (Dali::Property::Map *)jarg1;
10098   arg2 = (Dali::Property::Map *)jarg2;
10099   if (!arg2) {
10100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10101     return 0;
10102   }
10103   {
10104     try {
10105       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10106     } CALL_CATCH_EXCEPTION(0);
10107   }
10108
10109   jresult = (void *)result;
10110   return jresult;
10111 }
10112
10113
10114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10115
10116   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10117
10118   if (!jarg2) {
10119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10120     return;
10121   }
10122   std::string arg2_str(jarg2);
10123   std::string* arg2 = &arg2_str;
10124
10125   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10126
10127   {
10128     try {
10129       arg1->operator[]((std::string const &)*arg2) = *arg3;
10130     } CALL_CATCH_EXCEPTION();
10131   }
10132 }
10133
10134
10135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10136
10137   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10138   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10139   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10140
10141   {
10142     try {
10143       arg1->operator[](arg2) = *arg3;
10144     } CALL_CATCH_EXCEPTION();
10145   }
10146 }
10147
10148
10149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10150   void * jresult ;
10151   Dali::Property::Value *result = 0 ;
10152
10153   {
10154     try {
10155       result = (Dali::Property::Value *)new Dali::Property::Value();
10156     } CALL_CATCH_EXCEPTION(0);
10157   }
10158
10159   jresult = (void *)result;
10160   return jresult;
10161 }
10162
10163
10164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
10165   void * jresult ;
10166   bool arg1 ;
10167   Dali::Property::Value *result = 0 ;
10168
10169   arg1 = jarg1 ? true : false;
10170   {
10171     try {
10172       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10173     } CALL_CATCH_EXCEPTION(0);
10174   }
10175
10176   jresult = (void *)result;
10177   return jresult;
10178 }
10179
10180
10181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
10182   void * jresult ;
10183   int arg1 ;
10184   Dali::Property::Value *result = 0 ;
10185
10186   arg1 = (int)jarg1;
10187   {
10188     try {
10189       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10190     } CALL_CATCH_EXCEPTION(0);
10191   }
10192
10193   jresult = (void *)result;
10194   return jresult;
10195 }
10196
10197
10198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
10199   void * jresult ;
10200   float arg1 ;
10201   Dali::Property::Value *result = 0 ;
10202
10203   arg1 = (float)jarg1;
10204   {
10205     try {
10206       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10207     } CALL_CATCH_EXCEPTION(0);
10208   }
10209
10210   jresult = (void *)result;
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
10216   void * jresult ;
10217   Dali::Vector2 *arg1 = 0 ;
10218   Dali::Property::Value *result = 0 ;
10219
10220   arg1 = (Dali::Vector2 *)jarg1;
10221   if (!arg1) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
10223     return 0;
10224   }
10225   {
10226     try {
10227       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
10228     } CALL_CATCH_EXCEPTION(0);
10229   }
10230
10231   jresult = (void *)result;
10232   return jresult;
10233 }
10234
10235
10236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
10237   void * jresult ;
10238   Dali::Vector3 *arg1 = 0 ;
10239   Dali::Property::Value *result = 0 ;
10240
10241   arg1 = (Dali::Vector3 *)jarg1;
10242   if (!arg1) {
10243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10244     return 0;
10245   }
10246   {
10247     try {
10248       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
10249     } CALL_CATCH_EXCEPTION(0);
10250   }
10251
10252   jresult = (void *)result;
10253   return jresult;
10254 }
10255
10256
10257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
10258   void * jresult ;
10259   Dali::Vector4 *arg1 = 0 ;
10260   Dali::Property::Value *result = 0 ;
10261
10262   arg1 = (Dali::Vector4 *)jarg1;
10263   if (!arg1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10265     return 0;
10266   }
10267   {
10268     try {
10269       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
10270     } CALL_CATCH_EXCEPTION(0);
10271   }
10272
10273   jresult = (void *)result;
10274   return jresult;
10275 }
10276
10277
10278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
10279   void * jresult ;
10280   Dali::Matrix3 *arg1 = 0 ;
10281   Dali::Property::Value *result = 0 ;
10282
10283   arg1 = (Dali::Matrix3 *)jarg1;
10284   if (!arg1) {
10285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
10286     return 0;
10287   }
10288   {
10289     try {
10290       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
10291     } CALL_CATCH_EXCEPTION(0);
10292   }
10293
10294   jresult = (void *)result;
10295   return jresult;
10296 }
10297
10298
10299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
10300   void * jresult ;
10301   Dali::Matrix *arg1 = 0 ;
10302   Dali::Property::Value *result = 0 ;
10303
10304   arg1 = (Dali::Matrix *)jarg1;
10305   if (!arg1) {
10306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10307     return 0;
10308   }
10309   {
10310     try {
10311       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
10312     } CALL_CATCH_EXCEPTION(0);
10313   }
10314
10315   jresult = (void *)result;
10316   return jresult;
10317 }
10318
10319
10320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
10321   void * jresult ;
10322   Dali::Rect< int > *arg1 = 0 ;
10323   Dali::Property::Value *result = 0 ;
10324
10325   arg1 = (Dali::Rect< int > *)jarg1;
10326   if (!arg1) {
10327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
10328     return 0;
10329   }
10330   {
10331     try {
10332       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
10333     } CALL_CATCH_EXCEPTION(0);
10334   }
10335
10336   jresult = (void *)result;
10337   return jresult;
10338 }
10339
10340
10341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
10342   void * jresult ;
10343   Dali::AngleAxis *arg1 = 0 ;
10344   Dali::Property::Value *result = 0 ;
10345
10346   arg1 = (Dali::AngleAxis *)jarg1;
10347   if (!arg1) {
10348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
10349     return 0;
10350   }
10351   {
10352     try {
10353       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
10354     } CALL_CATCH_EXCEPTION(0);
10355   }
10356
10357   jresult = (void *)result;
10358   return jresult;
10359 }
10360
10361
10362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
10363   void * jresult ;
10364   Dali::Quaternion *arg1 = 0 ;
10365   Dali::Property::Value *result = 0 ;
10366
10367   arg1 = (Dali::Quaternion *)jarg1;
10368   if (!arg1) {
10369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10370     return 0;
10371   }
10372   {
10373     try {
10374       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
10375     } CALL_CATCH_EXCEPTION(0);
10376   }
10377
10378   jresult = (void *)result;
10379   return jresult;
10380 }
10381
10382
10383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
10384   void * jresult ;
10385   std::string *arg1 = 0 ;
10386   Dali::Property::Value *result = 0 ;
10387
10388   if (!jarg1) {
10389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10390     return 0;
10391   }
10392   std::string arg1_str(jarg1);
10393   arg1 = &arg1_str;
10394   {
10395     try {
10396       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
10397     } CALL_CATCH_EXCEPTION(0);
10398   }
10399
10400   jresult = (void *)result;
10401
10402   //argout typemap for const std::string&
10403
10404   return jresult;
10405 }
10406
10407
10408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
10409   void * jresult ;
10410   Dali::Property::Array *arg1 = 0 ;
10411   Dali::Property::Value *result = 0 ;
10412
10413   arg1 = (Dali::Property::Array *)jarg1;
10414   if (!arg1) {
10415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
10416     return 0;
10417   }
10418   {
10419     try {
10420       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10421     } CALL_CATCH_EXCEPTION(0);
10422   }
10423
10424   jresult = (void *)result;
10425   return jresult;
10426 }
10427
10428
10429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
10430   void * jresult ;
10431   Dali::Property::Map *arg1 = 0 ;
10432   Dali::Property::Value *result = 0 ;
10433
10434   arg1 = (Dali::Property::Map *)jarg1;
10435   if (!arg1) {
10436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
10437     return 0;
10438   }
10439   {
10440     try {
10441       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
10442     } CALL_CATCH_EXCEPTION(0);
10443   }
10444
10445   jresult = (void *)result;
10446   return jresult;
10447 }
10448
10449
10450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
10451   void * jresult ;
10452   Extents *arg1 = 0 ;
10453   Dali::Property::Value *result = 0 ;
10454
10455   arg1 = (Extents *)jarg1;
10456   if (!arg1) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
10458     return 0;
10459   }
10460   {
10461     try {
10462       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
10463     } CALL_CATCH_EXCEPTION(0);
10464   }
10465
10466   jresult = (void*) result;
10467   return jresult;
10468 }
10469
10470
10471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
10472   void * jresult ;
10473   Dali::Property::Type arg1 ;
10474   Dali::Property::Value *result = 0 ;
10475
10476   arg1 = (Dali::Property::Type)jarg1;
10477   {
10478     try {
10479       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
10480     } CALL_CATCH_EXCEPTION(0);
10481   }
10482
10483   jresult = (void *)result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
10489   void * jresult ;
10490   Dali::Property::Value *arg1 = 0 ;
10491   Dali::Property::Value *result = 0 ;
10492
10493   arg1 = (Dali::Property::Value *)jarg1;
10494   if (!arg1) {
10495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10496     return 0;
10497   }
10498   {
10499     try {
10500       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
10501     } CALL_CATCH_EXCEPTION(0);
10502   }
10503
10504   jresult = (void *)result;
10505   return jresult;
10506 }
10507
10508
10509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
10510   void * jresult ;
10511   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10512   Dali::Property::Value *arg2 = 0 ;
10513   Dali::Property::Value *result = 0 ;
10514
10515   arg1 = (Dali::Property::Value *)jarg1;
10516   arg2 = (Dali::Property::Value *)jarg2;
10517   if (!arg2) {
10518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10519     return 0;
10520   }
10521   {
10522     try {
10523       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
10524     } CALL_CATCH_EXCEPTION(0);
10525   }
10526
10527   jresult = (void *)result;
10528   return jresult;
10529 }
10530
10531
10532 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
10533   bool jresult;
10534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10535   Dali::Property::Value *arg2 = 0 ;
10536   bool result;
10537
10538   arg1 = (Dali::Property::Value *)jarg1;
10539   arg2 = (Dali::Property::Value *)jarg2;
10540   if (!arg2) {
10541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10542     return 0;
10543   }
10544   {
10545     try {
10546       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
10547     } CALL_CATCH_EXCEPTION(0);
10548   }
10549
10550   jresult = result;
10551   return jresult;
10552 }
10553
10554 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
10555   bool jresult;
10556   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10557   Dali::Property::Value *arg2 = 0 ;
10558   bool result;
10559
10560   arg1 = (Dali::Property::Value *)jarg1;
10561   arg2 = (Dali::Property::Value *)jarg2;
10562   if (!arg2) {
10563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10564     return 0;
10565   }
10566   {
10567     try {
10568       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
10569     } CALL_CATCH_EXCEPTION(0);
10570   }
10571
10572   jresult = result;
10573   return jresult;
10574 }
10575
10576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
10577   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10578
10579   arg1 = (Dali::Property::Value *)jarg1;
10580   {
10581     try {
10582       delete arg1;
10583     } CALL_CATCH_EXCEPTION();
10584   }
10585
10586 }
10587
10588
10589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
10590   int jresult ;
10591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10592   Dali::Property::Type result;
10593
10594   arg1 = (Dali::Property::Value *)jarg1;
10595   {
10596     try {
10597       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
10598     } CALL_CATCH_EXCEPTION(0);
10599   }
10600
10601   jresult = (int)result;
10602   return jresult;
10603 }
10604
10605
10606 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
10607   bool jresult ;
10608   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10609   bool *arg2 = 0 ;
10610   bool result;
10611
10612   arg1 = (Dali::Property::Value *)jarg1;
10613   arg2 = (bool *)jarg2;
10614   {
10615     try {
10616       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10617     } CALL_CATCH_EXCEPTION(0);
10618   }
10619
10620   jresult = result;
10621   return jresult;
10622 }
10623
10624
10625 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
10626   bool jresult ;
10627   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10628   float *arg2 = 0 ;
10629   bool result;
10630
10631   arg1 = (Dali::Property::Value *)jarg1;
10632   arg2 = (float *)jarg2;
10633   {
10634     try {
10635       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10636     } CALL_CATCH_EXCEPTION(0);
10637   }
10638
10639   jresult = result;
10640   return jresult;
10641 }
10642
10643
10644 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
10645   bool jresult ;
10646   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10647   int *arg2 = 0 ;
10648   bool result;
10649
10650   arg1 = (Dali::Property::Value *)jarg1;
10651   arg2 = (int *)jarg2;
10652   {
10653     try {
10654       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10655     } CALL_CATCH_EXCEPTION(0);
10656   }
10657
10658   jresult = result;
10659   return jresult;
10660 }
10661
10662
10663 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
10664   bool jresult ;
10665   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10666   Dali::Rect< int > *arg2 = 0 ;
10667   bool result;
10668
10669   arg1 = (Dali::Property::Value *)jarg1;
10670   arg2 = (Dali::Rect< int > *)jarg2;
10671   if (!arg2) {
10672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
10673     return 0;
10674   }
10675   {
10676     try {
10677       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10678     } CALL_CATCH_EXCEPTION(0);
10679   }
10680
10681   jresult = result;
10682   return jresult;
10683 }
10684
10685
10686 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
10687   bool jresult ;
10688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10689   Dali::Vector2 *arg2 = 0 ;
10690   bool result;
10691
10692   arg1 = (Dali::Property::Value *)jarg1;
10693   arg2 = (Dali::Vector2 *)jarg2;
10694   if (!arg2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
10696     return 0;
10697   }
10698   {
10699     try {
10700       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10701     } CALL_CATCH_EXCEPTION(0);
10702   }
10703
10704   jresult = result;
10705   return jresult;
10706 }
10707
10708
10709 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
10710   bool jresult ;
10711   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10712   Dali::Vector3 *arg2 = 0 ;
10713   bool result;
10714
10715   arg1 = (Dali::Property::Value *)jarg1;
10716   arg2 = (Dali::Vector3 *)jarg2;
10717   if (!arg2) {
10718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10719     return 0;
10720   }
10721   {
10722     try {
10723       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10724     } CALL_CATCH_EXCEPTION(0);
10725   }
10726
10727   jresult = result;
10728   return jresult;
10729 }
10730
10731
10732 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
10733   bool jresult ;
10734   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10735   Dali::Vector4 *arg2 = 0 ;
10736   bool result;
10737
10738   arg1 = (Dali::Property::Value *)jarg1;
10739   arg2 = (Dali::Vector4 *)jarg2;
10740   if (!arg2) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
10742     return 0;
10743   }
10744   {
10745     try {
10746       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10747     } CALL_CATCH_EXCEPTION(0);
10748   }
10749
10750   jresult = result;
10751   return jresult;
10752 }
10753
10754
10755 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
10756   bool jresult ;
10757   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10758   Dali::Matrix3 *arg2 = 0 ;
10759   bool result;
10760
10761   arg1 = (Dali::Property::Value *)jarg1;
10762   arg2 = (Dali::Matrix3 *)jarg2;
10763   if (!arg2) {
10764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
10765     return 0;
10766   }
10767   {
10768     try {
10769       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10770     } CALL_CATCH_EXCEPTION(0);
10771   }
10772
10773   jresult = result;
10774   return jresult;
10775 }
10776
10777
10778 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
10779   bool jresult ;
10780   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10781   Dali::Matrix *arg2 = 0 ;
10782   bool result;
10783
10784   arg1 = (Dali::Property::Value *)jarg1;
10785   arg2 = (Dali::Matrix *)jarg2;
10786   if (!arg2) {
10787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
10788     return 0;
10789   }
10790   {
10791     try {
10792       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10793     } CALL_CATCH_EXCEPTION(0);
10794   }
10795
10796   jresult = result;
10797   return jresult;
10798 }
10799
10800
10801 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
10802   bool jresult ;
10803   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10804   Dali::AngleAxis *arg2 = 0 ;
10805   bool result;
10806
10807   arg1 = (Dali::Property::Value *)jarg1;
10808   arg2 = (Dali::AngleAxis *)jarg2;
10809   if (!arg2) {
10810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
10811     return 0;
10812   }
10813   {
10814     try {
10815       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10816     } CALL_CATCH_EXCEPTION(0);
10817   }
10818
10819   jresult = result;
10820   return jresult;
10821 }
10822
10823
10824 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
10825   bool jresult ;
10826   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10827   Dali::Quaternion *arg2 = 0 ;
10828   bool result;
10829
10830   arg1 = (Dali::Property::Value *)jarg1;
10831   arg2 = (Dali::Quaternion *)jarg2;
10832   if (!arg2) {
10833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
10834     return 0;
10835   }
10836   {
10837     try {
10838       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10839     } CALL_CATCH_EXCEPTION(0);
10840   }
10841
10842   jresult = result;
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
10848   bool jresult ;
10849   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10850   std::string *arg2 = 0 ;
10851   bool result;
10852
10853   arg1 = (Dali::Property::Value *)jarg1;
10854
10855   //typemap in
10856   std::string temp;
10857   arg2 = &temp;
10858
10859   {
10860     try {
10861       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10862     } CALL_CATCH_EXCEPTION(0);
10863   }
10864
10865   jresult = result;
10866
10867   //Typemap argout in c++ file.
10868   //This will convert c++ string to c# string
10869   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
10870
10871   return jresult;
10872 }
10873
10874
10875 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
10876   bool jresult ;
10877   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10878   Dali::Property::Array *arg2 = 0 ;
10879   bool result;
10880
10881   arg1 = (Dali::Property::Value *)jarg1;
10882   arg2 = (Dali::Property::Array *)jarg2;
10883   if (!arg2) {
10884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
10885     return 0;
10886   }
10887   {
10888     try {
10889       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10890     } CALL_CATCH_EXCEPTION(0);
10891   }
10892
10893   jresult = result;
10894   return jresult;
10895 }
10896
10897
10898 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
10899   bool jresult ;
10900   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10901   Dali::Property::Map *arg2 = 0 ;
10902   bool result;
10903
10904   arg1 = (Dali::Property::Value *)jarg1;
10905   arg2 = (Dali::Property::Map *)jarg2;
10906   if (!arg2) {
10907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
10908     return 0;
10909   }
10910   {
10911     try {
10912       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10913     } CALL_CATCH_EXCEPTION(0);
10914   }
10915
10916   jresult = result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
10922   bool jresult ;
10923   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10924   Extents *arg2 = 0 ;
10925   bool result;
10926
10927   arg1 = (Dali::Property::Value *)jarg1;
10928   arg2 = (Extents *)jarg2;
10929   if (!arg2) {
10930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
10931     return 0;
10932   }
10933   {
10934     try {
10935       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
10936     } CALL_CATCH_EXCEPTION(0);
10937   }
10938   jresult = result;
10939   return jresult;
10940 }
10941
10942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
10943   void * jresult ;
10944   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10945   Dali::Property::Array *result = 0 ;
10946
10947   arg1 = (Dali::Property::Value *)jarg1;
10948   {
10949     try {
10950       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
10951     } CALL_CATCH_EXCEPTION(0);
10952   }
10953
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
10960   void * jresult ;
10961   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
10962   Dali::Property::Map *result = 0 ;
10963
10964   arg1 = (Dali::Property::Value *)jarg1;
10965   {
10966     try {
10967       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
10968     } CALL_CATCH_EXCEPTION(0);
10969   }
10970
10971   jresult = (void *)result;
10972   return jresult;
10973 }
10974
10975
10976 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
10977   char * jresult ;
10978   Dali::Property::Type arg1 ;
10979   char *result = 0 ;
10980
10981   arg1 = (Dali::Property::Type)jarg1;
10982   {
10983     try {
10984       result = (char *)Dali::PropertyTypes::GetName(arg1);
10985     } CALL_CATCH_EXCEPTION(0);
10986   }
10987
10988   jresult = SWIG_csharp_string_callback((const char *)result);
10989   return jresult;
10990 }
10991
10992
10993 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
10994   bool jresult ;
10995   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
10996   std::string *arg2 = 0 ;
10997   Dali::Property::Map *arg3 = 0 ;
10998   bool result;
10999
11000   arg1 = (Dali::BaseObject *)jarg1;
11001   if (!jarg2) {
11002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11003     return 0;
11004   }
11005   std::string arg2_str(jarg2);
11006   arg2 = &arg2_str;
11007   arg3 = (Dali::Property::Map *)jarg3;
11008   if (!arg3) {
11009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11010     return 0;
11011   }
11012   {
11013     try {
11014       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11015     } CALL_CATCH_EXCEPTION(0);
11016   }
11017
11018   jresult = result;
11019
11020   //argout typemap for const std::string&
11021
11022   return jresult;
11023 }
11024
11025
11026 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11027   char * jresult ;
11028   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11029   std::string *result = 0 ;
11030
11031   arg1 = (Dali::BaseObject *)jarg1;
11032   {
11033     try {
11034       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11035     } CALL_CATCH_EXCEPTION(0);
11036   }
11037
11038   jresult = SWIG_csharp_string_callback(result->c_str());
11039   return jresult;
11040 }
11041
11042
11043 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11044   bool jresult ;
11045   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11046   Dali::TypeInfo *arg2 = 0 ;
11047   bool result;
11048
11049   arg1 = (Dali::BaseObject *)jarg1;
11050   arg2 = (Dali::TypeInfo *)jarg2;
11051   if (!arg2) {
11052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11053     return 0;
11054   }
11055   {
11056     try {
11057       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11058     } CALL_CATCH_EXCEPTION(0);
11059   }
11060
11061   jresult = result;
11062   return jresult;
11063 }
11064
11065
11066 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11067   bool jresult ;
11068   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11069   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11070   std::string *arg3 = 0 ;
11071   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11072   bool result;
11073
11074   arg1 = (Dali::BaseObject *)jarg1;
11075   arg2 = (ConnectionTrackerInterface *)jarg2;
11076   if (!jarg3) {
11077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11078     return 0;
11079   }
11080   std::string arg3_str(jarg3);
11081   arg3 = &arg3_str;
11082   arg4 = (FunctorDelegate *)jarg4;
11083   {
11084     try {
11085       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11086     } CALL_CATCH_EXCEPTION(0);
11087   }
11088
11089   jresult = result;
11090
11091   //argout typemap for const std::string&
11092
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11098   void * jresult ;
11099   Dali::BaseHandle *arg1 = 0 ;
11100   Dali::BaseObject *result = 0 ;
11101
11102   arg1 = (Dali::BaseHandle *)jarg1;
11103   if (!arg1) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11110     } CALL_CATCH_EXCEPTION(0);
11111   }
11112
11113   jresult = (void *)result;
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11119   void * jresult ;
11120   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11121   Dali::BaseHandle *result = 0 ;
11122
11123   arg1 = (Dali::BaseObject *)jarg1;
11124   {
11125     try {
11126       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11127     } CALL_CATCH_EXCEPTION(0);
11128   }
11129
11130   jresult = (void *)result;
11131   return jresult;
11132 }
11133
11134
11135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11136   void * jresult ;
11137   Dali::BaseHandle *result = 0 ;
11138
11139   {
11140     try {
11141       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11142     } CALL_CATCH_EXCEPTION(0);
11143   }
11144
11145   jresult = (void *)result;
11146   return jresult;
11147 }
11148
11149
11150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11151   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11152
11153   arg1 = (Dali::BaseHandle *)jarg1;
11154   {
11155     try {
11156       delete arg1;
11157     } CALL_CATCH_EXCEPTION();
11158   }
11159
11160 }
11161
11162
11163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11164   void * jresult ;
11165   Dali::BaseHandle *arg1 = 0 ;
11166   Dali::BaseHandle *result = 0 ;
11167
11168   arg1 = (Dali::BaseHandle *)jarg1;
11169   if (!arg1) {
11170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11171     return 0;
11172   }
11173   {
11174     try {
11175       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11176     } CALL_CATCH_EXCEPTION(0);
11177   }
11178
11179   jresult = (void *)result;
11180   return jresult;
11181 }
11182
11183
11184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11185   void * jresult ;
11186   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11187   Dali::BaseHandle *arg2 = 0 ;
11188   Dali::BaseHandle *result = 0 ;
11189
11190   arg1 = (Dali::BaseHandle *)jarg1;
11191   arg2 = (Dali::BaseHandle *)jarg2;
11192   if (!arg2) {
11193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11194     return 0;
11195   }
11196   {
11197     try {
11198       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11199     } CALL_CATCH_EXCEPTION(0);
11200   }
11201
11202   jresult = (void *)result;
11203   return jresult;
11204 }
11205
11206
11207 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11208   bool jresult ;
11209   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11210   std::string *arg2 = 0 ;
11211   Dali::Property::Map *arg3 = 0 ;
11212   bool result;
11213
11214   arg1 = (Dali::BaseHandle *)jarg1;
11215   if (!jarg2) {
11216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11217     return 0;
11218   }
11219   std::string arg2_str(jarg2);
11220   arg2 = &arg2_str;
11221   arg3 = (Dali::Property::Map *)jarg3;
11222   if (!arg3) {
11223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11224     return 0;
11225   }
11226   {
11227     try {
11228       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11229     } CALL_CATCH_EXCEPTION(0);
11230   }
11231
11232   jresult = result;
11233
11234   //argout typemap for const std::string&
11235
11236   return jresult;
11237 }
11238
11239
11240 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
11241   char * jresult ;
11242   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11243   std::string *result = 0 ;
11244
11245   arg1 = (Dali::BaseHandle *)jarg1;
11246   {
11247     try {
11248       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
11249     } CALL_CATCH_EXCEPTION(0);
11250   }
11251
11252   jresult = SWIG_csharp_string_callback(result->c_str());
11253   return jresult;
11254 }
11255
11256
11257 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
11258   bool jresult ;
11259   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11260   Dali::TypeInfo *arg2 = 0 ;
11261   bool result;
11262
11263   arg1 = (Dali::BaseHandle *)jarg1;
11264   arg2 = (Dali::TypeInfo *)jarg2;
11265   if (!arg2) {
11266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11267     return 0;
11268   }
11269   {
11270     try {
11271       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
11272     } CALL_CATCH_EXCEPTION(0);
11273   }
11274
11275   jresult = result;
11276   return jresult;
11277 }
11278
11279
11280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
11281   void * jresult ;
11282   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11283   Dali::BaseObject *result = 0 ;
11284
11285   arg1 = (Dali::BaseHandle *)jarg1;
11286   {
11287     try {
11288       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
11289     } CALL_CATCH_EXCEPTION(0);
11290   }
11291
11292   jresult = (void *)result;
11293   return jresult;
11294 }
11295
11296
11297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
11298   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11299
11300   arg1 = (Dali::BaseHandle *)jarg1;
11301   {
11302     try {
11303       (arg1)->Reset();
11304     } CALL_CATCH_EXCEPTION();
11305   }
11306
11307 }
11308
11309
11310 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
11311   bool jresult ;
11312   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11313   Dali::BaseHandle *arg2 = 0 ;
11314   bool result;
11315
11316   arg1 = (Dali::BaseHandle *)jarg1;
11317   arg2 = (Dali::BaseHandle *)jarg2;
11318   if (!arg2) {
11319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11320     return 0;
11321   }
11322   {
11323     try {
11324       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
11325     } CALL_CATCH_EXCEPTION(0);
11326   }
11327
11328   jresult = result;
11329   return jresult;
11330 }
11331
11332
11333 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
11334   bool jresult ;
11335   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11336   Dali::BaseHandle *arg2 = 0 ;
11337   bool result;
11338
11339   arg1 = (Dali::BaseHandle *)jarg1;
11340   arg2 = (Dali::BaseHandle *)jarg2;
11341   if (!arg2) {
11342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11343     return 0;
11344   }
11345   {
11346     try {
11347       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
11348     } CALL_CATCH_EXCEPTION(0);
11349   }
11350
11351   jresult = result;
11352   return jresult;
11353 }
11354
11355
11356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
11357   void * jresult ;
11358   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11359   Dali::RefObject *result = 0 ;
11360
11361   arg1 = (Dali::BaseHandle *)jarg1;
11362   {
11363     try {
11364       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
11365     } CALL_CATCH_EXCEPTION(0);
11366   }
11367
11368   jresult = (void *)result;
11369   return jresult;
11370 }
11371
11372
11373 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
11374   bool jresult ;
11375   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11376   bool result;
11377
11378   arg1 = (Dali::BaseHandle *)jarg1;
11379   {
11380     try {
11381       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
11382     } CALL_CATCH_EXCEPTION(0);
11383   }
11384
11385   jresult = result;
11386   return jresult;
11387 }
11388
11389
11390 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
11391   bool jresult ;
11392   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11393   Dali::BaseHandle *arg2 = 0 ;
11394   bool result;
11395
11396   arg1 = (Dali::BaseHandle *)jarg1;
11397   arg2 = (Dali::BaseHandle *)jarg2;
11398   if (!arg2) {
11399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11400     return 0;
11401   }
11402   {
11403     try {
11404       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
11405     } CALL_CATCH_EXCEPTION(0);
11406   }
11407
11408   jresult = result;
11409   return jresult;
11410 }
11411
11412
11413 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
11414   bool jresult ;
11415   Dali::BaseHandle *arg1 = 0 ;
11416   Dali::BaseHandle *arg2 = 0 ;
11417   bool result;
11418
11419   arg1 = (Dali::BaseHandle *)jarg1;
11420   if (!arg1) {
11421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11422     return 0;
11423   }
11424   arg2 = (Dali::BaseHandle *)jarg2;
11425   if (!arg2) {
11426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11427     return 0;
11428   }
11429   {
11430     try {
11431       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
11432     } CALL_CATCH_EXCEPTION(0);
11433   }
11434
11435   jresult = result;
11436   return jresult;
11437 }
11438
11439
11440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
11441   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11442
11443   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11444   {
11445     try {
11446       delete arg1;
11447     } CALL_CATCH_EXCEPTION();
11448   }
11449
11450 }
11451
11452
11453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11454   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
11455   SlotObserver *arg2 = (SlotObserver *) 0 ;
11456   CallbackBase *arg3 = (CallbackBase *) 0 ;
11457
11458   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
11459   arg2 = (SlotObserver *)jarg2;
11460   arg3 = (CallbackBase *)jarg3;
11461   {
11462     try {
11463       (arg1)->SignalConnected(arg2,arg3);
11464     } CALL_CATCH_EXCEPTION();
11465   }
11466
11467 }
11468
11469
11470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
11471   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11472
11473   arg1 = (Dali::SignalObserver *)jarg1;
11474   {
11475     try {
11476       delete arg1;
11477     } CALL_CATCH_EXCEPTION();
11478   }
11479
11480 }
11481
11482
11483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11484   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
11485   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11486   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11487
11488   arg1 = (Dali::SignalObserver *)jarg1;
11489   arg2 = (Dali::SlotObserver *)jarg2;
11490   arg3 = (Dali::CallbackBase *)jarg3;
11491   {
11492     try {
11493       (arg1)->SignalDisconnected(arg2,arg3);
11494     } CALL_CATCH_EXCEPTION();
11495   }
11496
11497 }
11498
11499
11500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
11501   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11502
11503   arg1 = (Dali::SlotObserver *)jarg1;
11504   {
11505     try {
11506       delete arg1;
11507     } CALL_CATCH_EXCEPTION();
11508   }
11509
11510 }
11511
11512
11513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
11514   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
11515   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
11516
11517   arg1 = (Dali::SlotObserver *)jarg1;
11518   arg2 = (Dali::CallbackBase *)jarg2;
11519   {
11520     try {
11521       (arg1)->SlotDisconnected(arg2);
11522     } CALL_CATCH_EXCEPTION();
11523   }
11524
11525 }
11526
11527
11528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
11529   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11530
11531   arg1 = (Dali::ConnectionTracker *)jarg1;
11532   {
11533     try {
11534       delete arg1;
11535     } CALL_CATCH_EXCEPTION();
11536   }
11537
11538 }
11539
11540
11541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
11542   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11543
11544   arg1 = (Dali::ConnectionTracker *)jarg1;
11545   {
11546     try {
11547       (arg1)->DisconnectAll();
11548     } CALL_CATCH_EXCEPTION();
11549   }
11550
11551 }
11552
11553
11554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
11555   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11556   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11557   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11558
11559   arg1 = (Dali::ConnectionTracker *)jarg1;
11560   arg2 = (Dali::SlotObserver *)jarg2;
11561   arg3 = (Dali::CallbackBase *)jarg3;
11562   {
11563     try {
11564       (arg1)->SignalConnected(arg2,arg3);
11565     } CALL_CATCH_EXCEPTION();
11566   }
11567
11568 }
11569
11570
11571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
11572   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11573   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
11574   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
11575
11576   arg1 = (Dali::ConnectionTracker *)jarg1;
11577   arg2 = (Dali::SlotObserver *)jarg2;
11578   arg3 = (Dali::CallbackBase *)jarg3;
11579   {
11580     try {
11581       (arg1)->SignalDisconnected(arg2,arg3);
11582     } CALL_CATCH_EXCEPTION();
11583   }
11584
11585 }
11586
11587
11588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
11589   unsigned long jresult ;
11590   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
11591   std::size_t result;
11592
11593   arg1 = (Dali::ConnectionTracker *)jarg1;
11594   {
11595     try {
11596       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
11597     } CALL_CATCH_EXCEPTION(0);
11598   }
11599
11600   jresult = (unsigned long)result;
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
11606   void * jresult ;
11607   Dali::ObjectRegistry *result = 0 ;
11608
11609   {
11610     try {
11611       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
11612     } CALL_CATCH_EXCEPTION(0);
11613   }
11614
11615   jresult = (void *)result;
11616   return jresult;
11617 }
11618
11619
11620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
11621   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11622
11623   arg1 = (Dali::ObjectRegistry *)jarg1;
11624   {
11625     try {
11626       delete arg1;
11627     } CALL_CATCH_EXCEPTION();
11628   }
11629
11630 }
11631
11632
11633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
11634   void * jresult ;
11635   Dali::ObjectRegistry *arg1 = 0 ;
11636   Dali::ObjectRegistry *result = 0 ;
11637
11638   arg1 = (Dali::ObjectRegistry *)jarg1;
11639   if (!arg1) {
11640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
11641     return 0;
11642   }
11643   {
11644     try {
11645       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
11646     } CALL_CATCH_EXCEPTION(0);
11647   }
11648
11649   jresult = (void *)result;
11650   return jresult;
11651 }
11652
11653
11654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
11655   void * jresult ;
11656   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11657   Dali::ObjectRegistry *arg2 = 0 ;
11658   Dali::ObjectRegistry *result = 0 ;
11659
11660   arg1 = (Dali::ObjectRegistry *)jarg1;
11661   arg2 = (Dali::ObjectRegistry *)jarg2;
11662   if (!arg2) {
11663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
11664     return 0;
11665   }
11666   {
11667     try {
11668       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
11669     } CALL_CATCH_EXCEPTION(0);
11670   }
11671
11672   jresult = (void *)result;
11673   return jresult;
11674 }
11675
11676
11677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
11678   void * jresult ;
11679   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11680   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
11681
11682   arg1 = (Dali::ObjectRegistry *)jarg1;
11683   {
11684     try {
11685       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
11686     } CALL_CATCH_EXCEPTION(0);
11687   }
11688
11689   jresult = (void *)result;
11690   return jresult;
11691 }
11692
11693
11694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
11695   void * jresult ;
11696   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
11697   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
11698
11699   arg1 = (Dali::ObjectRegistry *)jarg1;
11700   {
11701     try {
11702       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
11703     } CALL_CATCH_EXCEPTION(0);
11704   }
11705
11706   jresult = (void *)result;
11707   return jresult;
11708 }
11709
11710
11711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
11712   void * jresult ;
11713   Dali::PropertyCondition *result = 0 ;
11714
11715   {
11716     try {
11717       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
11718     } CALL_CATCH_EXCEPTION(0);
11719   }
11720
11721   jresult = (void *)result;
11722   return jresult;
11723 }
11724
11725
11726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
11727   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11728
11729   arg1 = (Dali::PropertyCondition *)jarg1;
11730   {
11731     try {
11732       delete arg1;
11733     } CALL_CATCH_EXCEPTION();
11734   }
11735
11736 }
11737
11738
11739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
11740   void * jresult ;
11741   Dali::PropertyCondition *arg1 = 0 ;
11742   Dali::PropertyCondition *result = 0 ;
11743
11744   arg1 = (Dali::PropertyCondition *)jarg1;
11745   if (!arg1) {
11746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
11747     return 0;
11748   }
11749   {
11750     try {
11751       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
11752     } CALL_CATCH_EXCEPTION(0);
11753   }
11754
11755   jresult = (void *)result;
11756   return jresult;
11757 }
11758
11759
11760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
11761   void * jresult ;
11762   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11763   Dali::PropertyCondition *arg2 = 0 ;
11764   Dali::PropertyCondition *result = 0 ;
11765
11766   arg1 = (Dali::PropertyCondition *)jarg1;
11767   arg2 = (Dali::PropertyCondition *)jarg2;
11768   if (!arg2) {
11769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
11770     return 0;
11771   }
11772   {
11773     try {
11774       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
11775     } CALL_CATCH_EXCEPTION(0);
11776   }
11777
11778   jresult = (void *)result;
11779   return jresult;
11780 }
11781
11782
11783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
11784   unsigned long jresult ;
11785   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11786   std::size_t result;
11787
11788   arg1 = (Dali::PropertyCondition *)jarg1;
11789   {
11790     try {
11791       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
11792     } CALL_CATCH_EXCEPTION(0);
11793   }
11794   jresult = (unsigned long)result;
11795   return jresult;
11796 }
11797
11798
11799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
11800   float jresult ;
11801   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
11802   std::size_t arg2 ;
11803   float result;
11804
11805   arg1 = (Dali::PropertyCondition *)jarg1;
11806   arg2 = (std::size_t)jarg2;
11807   {
11808     try {
11809       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
11810     } CALL_CATCH_EXCEPTION(0);
11811   }
11812   jresult = result;
11813   return jresult;
11814 }
11815
11816
11817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
11818   void * jresult ;
11819   float arg1 ;
11820   Dali::PropertyCondition result;
11821
11822   arg1 = (float)jarg1;
11823   {
11824     try {
11825       result = Dali::LessThanCondition(arg1);
11826     } CALL_CATCH_EXCEPTION(0);
11827   }
11828
11829   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11830   return jresult;
11831 }
11832
11833
11834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
11835   void * jresult ;
11836   float arg1 ;
11837   Dali::PropertyCondition result;
11838
11839   arg1 = (float)jarg1;
11840   {
11841     try {
11842       result = Dali::GreaterThanCondition(arg1);
11843     } CALL_CATCH_EXCEPTION(0);
11844   }
11845
11846   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11847   return jresult;
11848 }
11849
11850
11851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
11852   void * jresult ;
11853   float arg1 ;
11854   float arg2 ;
11855   Dali::PropertyCondition result;
11856
11857   arg1 = (float)jarg1;
11858   arg2 = (float)jarg2;
11859   {
11860     try {
11861       result = Dali::InsideCondition(arg1,arg2);
11862     } CALL_CATCH_EXCEPTION(0);
11863   }
11864
11865   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11866   return jresult;
11867 }
11868
11869
11870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
11871   void * jresult ;
11872   float arg1 ;
11873   float arg2 ;
11874   Dali::PropertyCondition result;
11875
11876   arg1 = (float)jarg1;
11877   arg2 = (float)jarg2;
11878   {
11879     try {
11880       result = Dali::OutsideCondition(arg1,arg2);
11881     } CALL_CATCH_EXCEPTION(0);
11882   }
11883
11884   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11885   return jresult;
11886 }
11887
11888
11889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
11890   void * jresult ;
11891   float arg1 ;
11892   float arg2 ;
11893   Dali::PropertyCondition result;
11894
11895   arg1 = (float)jarg1;
11896   arg2 = (float)jarg2;
11897   {
11898     try {
11899       result = Dali::StepCondition(arg1,arg2);
11900     } CALL_CATCH_EXCEPTION(0);
11901   }
11902
11903   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11904   return jresult;
11905 }
11906
11907
11908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
11909   void * jresult ;
11910   float arg1 ;
11911   Dali::PropertyCondition result;
11912
11913   arg1 = (float)jarg1;
11914   {
11915     try {
11916       result = Dali::StepCondition(arg1);
11917     } CALL_CATCH_EXCEPTION(0);
11918   }
11919
11920   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11921   return jresult;
11922 }
11923
11924
11925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
11926   void * jresult ;
11927   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
11928   Dali::PropertyCondition result;
11929
11930   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
11931   if (!arg1) {
11932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
11933     return 0;
11934   }
11935   {
11936     try {
11937       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
11938     } CALL_CATCH_EXCEPTION(0);
11939   }
11940
11941   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
11942   return jresult;
11943 }
11944
11945
11946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
11947   void * jresult ;
11948   Dali::PropertyNotification *result = 0 ;
11949
11950   {
11951     try {
11952       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
11953     } CALL_CATCH_EXCEPTION(0);
11954   }
11955
11956   jresult = (void *)result;
11957   return jresult;
11958 }
11959
11960
11961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
11962   void * jresult ;
11963   Dali::BaseHandle arg1 ;
11964   Dali::BaseHandle *argp1 ;
11965   Dali::PropertyNotification result;
11966
11967   argp1 = (Dali::BaseHandle *)jarg1;
11968   if (!argp1) {
11969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11970     return 0;
11971   }
11972   arg1 = *argp1;
11973   {
11974     try {
11975       result = Dali::PropertyNotification::DownCast(arg1);
11976     } CALL_CATCH_EXCEPTION(0);
11977   }
11978
11979   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
11980   return jresult;
11981 }
11982
11983
11984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
11985   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
11986
11987   arg1 = (Dali::PropertyNotification *)jarg1;
11988   {
11989     try {
11990       delete arg1;
11991     } CALL_CATCH_EXCEPTION();
11992   }
11993
11994 }
11995
11996
11997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
11998   void * jresult ;
11999   Dali::PropertyNotification *arg1 = 0 ;
12000   Dali::PropertyNotification *result = 0 ;
12001
12002   arg1 = (Dali::PropertyNotification *)jarg1;
12003   if (!arg1) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12005     return 0;
12006   }
12007   {
12008     try {
12009       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12010     } CALL_CATCH_EXCEPTION(0);
12011   }
12012
12013   jresult = (void *)result;
12014   return jresult;
12015 }
12016
12017
12018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12019   void * jresult ;
12020   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12021   Dali::PropertyNotification *arg2 = 0 ;
12022   Dali::PropertyNotification *result = 0 ;
12023
12024   arg1 = (Dali::PropertyNotification *)jarg1;
12025   arg2 = (Dali::PropertyNotification *)jarg2;
12026   if (!arg2) {
12027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12028     return 0;
12029   }
12030   {
12031     try {
12032       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12033     } CALL_CATCH_EXCEPTION(0);
12034   }
12035
12036   jresult = (void *)result;
12037   return jresult;
12038 }
12039
12040
12041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12042   void * jresult ;
12043   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12044   Dali::PropertyCondition result;
12045
12046   arg1 = (Dali::PropertyNotification *)jarg1;
12047   {
12048     try {
12049       result = (arg1)->GetCondition();
12050     } CALL_CATCH_EXCEPTION(0);
12051   }
12052
12053   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12054   return jresult;
12055 }
12056
12057
12058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12059   void * jresult ;
12060   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12061   Dali::Handle result;
12062
12063   arg1 = (Dali::PropertyNotification *)jarg1;
12064   {
12065     try {
12066       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12067     } CALL_CATCH_EXCEPTION(0);
12068   }
12069
12070   jresult = new Dali::Handle((const Dali::Handle &)result);
12071   return jresult;
12072 }
12073
12074
12075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12076   int jresult ;
12077   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12078   Dali::Property::Index result;
12079
12080   arg1 = (Dali::PropertyNotification *)jarg1;
12081   {
12082     try {
12083       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12084     } CALL_CATCH_EXCEPTION(0);
12085   }
12086
12087   jresult = result;
12088   return jresult;
12089 }
12090
12091
12092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12093   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12094   Dali::PropertyNotification::NotifyMode arg2 ;
12095
12096   arg1 = (Dali::PropertyNotification *)jarg1;
12097   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12098   {
12099     try {
12100       (arg1)->SetNotifyMode(arg2);
12101     } CALL_CATCH_EXCEPTION();
12102   }
12103
12104 }
12105
12106
12107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12108   int jresult ;
12109   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12110   Dali::PropertyNotification::NotifyMode result;
12111
12112   arg1 = (Dali::PropertyNotification *)jarg1;
12113   {
12114     try {
12115       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12116     } CALL_CATCH_EXCEPTION(0);
12117   }
12118
12119   jresult = (int)result;
12120   return jresult;
12121 }
12122
12123
12124 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12125   bool jresult ;
12126   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12127   bool result;
12128
12129   arg1 = (Dali::PropertyNotification *)jarg1;
12130   {
12131     try {
12132       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12133     } CALL_CATCH_EXCEPTION(0);
12134   }
12135
12136   jresult = result;
12137   return jresult;
12138 }
12139
12140
12141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12142   void * jresult ;
12143   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12144   Dali::PropertyNotifySignalType *result = 0 ;
12145
12146   arg1 = (Dali::PropertyNotification *)jarg1;
12147   {
12148     try {
12149       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12150     } CALL_CATCH_EXCEPTION(0);
12151   }
12152
12153   jresult = (void *)result;
12154   return jresult;
12155 }
12156
12157
12158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12159   void * jresult ;
12160   Dali::Handle *result = 0 ;
12161
12162   {
12163     try {
12164       result = (Dali::Handle *)new Dali::Handle();
12165     } CALL_CATCH_EXCEPTION(0);
12166   }
12167
12168   jresult = (void *)result;
12169   return jresult;
12170 }
12171
12172
12173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12174   void * jresult ;
12175   Dali::Handle result;
12176
12177   {
12178     try {
12179       result = Dali::Handle::New();
12180     } CALL_CATCH_EXCEPTION(0);
12181   }
12182
12183   jresult = new Dali::Handle((const Dali::Handle &)result);
12184   return jresult;
12185 }
12186
12187
12188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12189   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12190
12191   arg1 = (Dali::Handle *)jarg1;
12192   {
12193     try {
12194       delete arg1;
12195     } CALL_CATCH_EXCEPTION();
12196   }
12197
12198 }
12199
12200
12201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12202   void * jresult ;
12203   Dali::Handle *arg1 = 0 ;
12204   Dali::Handle *result = 0 ;
12205
12206   arg1 = (Dali::Handle *)jarg1;
12207   if (!arg1) {
12208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12209     return 0;
12210   }
12211   {
12212     try {
12213       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
12214     } CALL_CATCH_EXCEPTION(0);
12215   }
12216
12217   jresult = (void *)result;
12218   return jresult;
12219 }
12220
12221
12222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
12223   void * jresult ;
12224   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12225   Dali::Handle *arg2 = 0 ;
12226   Dali::Handle *result = 0 ;
12227
12228   arg1 = (Dali::Handle *)jarg1;
12229   arg2 = (Dali::Handle *)jarg2;
12230   if (!arg2) {
12231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
12232     return 0;
12233   }
12234   {
12235     try {
12236       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
12237     } CALL_CATCH_EXCEPTION(0);
12238   }
12239
12240   jresult = (void *)result;
12241   return jresult;
12242 }
12243
12244
12245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
12246   void * jresult ;
12247   Dali::BaseHandle arg1 ;
12248   Dali::BaseHandle *argp1 ;
12249   Dali::Handle result;
12250
12251   argp1 = (Dali::BaseHandle *)jarg1;
12252   if (!argp1) {
12253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12254     return 0;
12255   }
12256   arg1 = *argp1;
12257   {
12258     try {
12259       result = Dali::Handle::DownCast(arg1);
12260     } CALL_CATCH_EXCEPTION(0);
12261   }
12262
12263   jresult = new Dali::Handle((const Dali::Handle &)result);
12264   return jresult;
12265 }
12266
12267
12268 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
12269   bool jresult ;
12270   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12271   Dali::Handle::Capability arg2 ;
12272   bool result;
12273
12274   arg1 = (Dali::Handle *)jarg1;
12275   arg2 = (Dali::Handle::Capability)jarg2;
12276   {
12277     try {
12278       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
12279     } CALL_CATCH_EXCEPTION(0);
12280   }
12281
12282   jresult = result;
12283   return jresult;
12284 }
12285
12286
12287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
12288   unsigned int jresult ;
12289   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12290   unsigned int result;
12291
12292   arg1 = (Dali::Handle *)jarg1;
12293   {
12294     try {
12295       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
12296     } CALL_CATCH_EXCEPTION(0);
12297   }
12298
12299   jresult = result;
12300   return jresult;
12301 }
12302
12303
12304 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
12305   char * jresult ;
12306   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12307   Dali::Property::Index arg2 ;
12308   std::string result;
12309
12310   arg1 = (Dali::Handle *)jarg1;
12311   arg2 = (Dali::Property::Index)jarg2;
12312   {
12313     try {
12314       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
12315     } CALL_CATCH_EXCEPTION(0);
12316   }
12317
12318   jresult = SWIG_csharp_string_callback((&result)->c_str());
12319   return jresult;
12320 }
12321
12322
12323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
12324   int jresult ;
12325   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12326   std::string *arg2 = 0 ;
12327   Dali::Property::Index result;
12328
12329   arg1 = (Dali::Handle *)jarg1;
12330   if (!jarg2) {
12331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12332     return 0;
12333   }
12334   std::string arg2_str(jarg2);
12335   arg2 = &arg2_str;
12336   {
12337     try {
12338       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
12339     } CALL_CATCH_EXCEPTION(0);
12340   }
12341
12342   jresult = result;
12343
12344   //argout typemap for const std::string&
12345
12346   return jresult;
12347 }
12348
12349
12350 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
12351   bool jresult ;
12352   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12353   Dali::Property::Index arg2 ;
12354   bool result;
12355
12356   arg1 = (Dali::Handle *)jarg1;
12357   arg2 = (Dali::Property::Index)jarg2;
12358   {
12359     try {
12360       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
12361     } CALL_CATCH_EXCEPTION(0);
12362   }
12363
12364   jresult = result;
12365   return jresult;
12366 }
12367
12368
12369 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
12370   bool jresult ;
12371   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12372   Dali::Property::Index arg2 ;
12373   bool result;
12374
12375   arg1 = (Dali::Handle *)jarg1;
12376   arg2 = (Dali::Property::Index)jarg2;
12377   {
12378     try {
12379       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
12380     } CALL_CATCH_EXCEPTION(0);
12381   }
12382
12383   jresult = result;
12384   return jresult;
12385 }
12386
12387
12388 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
12389   bool jresult ;
12390   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12391   Dali::Property::Index arg2 ;
12392   bool result;
12393
12394   arg1 = (Dali::Handle *)jarg1;
12395   arg2 = (Dali::Property::Index)jarg2;
12396   {
12397     try {
12398       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
12399     } CALL_CATCH_EXCEPTION(0);
12400   }
12401
12402   jresult = result;
12403   return jresult;
12404 }
12405
12406
12407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
12408   int jresult ;
12409   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12410   Dali::Property::Index arg2 ;
12411   Dali::Property::Type result;
12412
12413   arg1 = (Dali::Handle *)jarg1;
12414   arg2 = (Dali::Property::Index)jarg2;
12415   {
12416     try {
12417       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
12418     } CALL_CATCH_EXCEPTION(0);
12419   }
12420
12421   jresult = (int)result;
12422   return jresult;
12423 }
12424
12425
12426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
12427   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12428   Dali::Property::Index arg2 ;
12429   Dali::Property::Value *arg3 = 0 ;
12430
12431   arg1 = (Dali::Handle *)jarg1;
12432   arg2 = (Dali::Property::Index)jarg2;
12433   arg3 = (Dali::Property::Value *)jarg3;
12434   if (!arg3) {
12435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12436     return ;
12437   }
12438   {
12439     try {
12440       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
12441     } CALL_CATCH_EXCEPTION();
12442   }
12443
12444 }
12445
12446
12447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
12448   int jresult ;
12449   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12450   std::string *arg2 = 0 ;
12451   Dali::Property::Value *arg3 = 0 ;
12452   Dali::Property::Index result;
12453
12454   arg1 = (Dali::Handle *)jarg1;
12455   if (!jarg2) {
12456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12457     return 0;
12458   }
12459   std::string arg2_str(jarg2);
12460   arg2 = &arg2_str;
12461   arg3 = (Dali::Property::Value *)jarg3;
12462   if (!arg3) {
12463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12464     return 0;
12465   }
12466   {
12467     try {
12468       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
12469     } CALL_CATCH_EXCEPTION(0);
12470   }
12471
12472   jresult = result;
12473
12474   //argout typemap for const std::string&
12475
12476   return jresult;
12477 }
12478
12479
12480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
12481   int jresult ;
12482   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12483   std::string *arg2 = 0 ;
12484   Dali::Property::Value *arg3 = 0 ;
12485   Dali::Property::AccessMode arg4 ;
12486   Dali::Property::Index result;
12487
12488   arg1 = (Dali::Handle *)jarg1;
12489   if (!jarg2) {
12490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12491     return 0;
12492   }
12493   std::string arg2_str(jarg2);
12494   arg2 = &arg2_str;
12495   arg3 = (Dali::Property::Value *)jarg3;
12496   if (!arg3) {
12497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12498     return 0;
12499   }
12500   arg4 = (Dali::Property::AccessMode)jarg4;
12501   {
12502     try {
12503       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
12504     } CALL_CATCH_EXCEPTION(0);
12505   }
12506
12507   jresult = result;
12508
12509   //argout typemap for const std::string&
12510
12511   return jresult;
12512 }
12513
12514
12515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
12516   void * jresult ;
12517   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12518   Dali::Property::Index arg2 ;
12519   Dali::Property::Value result;
12520
12521   arg1 = (Dali::Handle *)jarg1;
12522   arg2 = (Dali::Property::Index)jarg2;
12523   {
12524     try {
12525       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
12526     } CALL_CATCH_EXCEPTION(0);
12527   }
12528
12529   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
12530   return jresult;
12531 }
12532
12533
12534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
12535   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12536   Dali::Property::IndexContainer *arg2 = 0 ;
12537
12538   arg1 = (Dali::Handle *)jarg1;
12539   arg2 = (Dali::Property::IndexContainer *)jarg2;
12540   if (!arg2) {
12541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
12542     return ;
12543   }
12544   {
12545     try {
12546       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
12547     } CALL_CATCH_EXCEPTION();
12548   }
12549
12550 }
12551
12552
12553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
12554   void * jresult ;
12555   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12556   Dali::Property::Index arg2 ;
12557   Dali::PropertyCondition *arg3 = 0 ;
12558   Dali::PropertyNotification result;
12559
12560   arg1 = (Dali::Handle *)jarg1;
12561   arg2 = (Dali::Property::Index)jarg2;
12562   arg3 = (Dali::PropertyCondition *)jarg3;
12563   if (!arg3) {
12564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12565     return 0;
12566   }
12567   {
12568     try {
12569       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
12570     } CALL_CATCH_EXCEPTION(0);
12571   }
12572
12573   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12574   return jresult;
12575 }
12576
12577
12578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
12579   void * jresult ;
12580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12581   Dali::Property::Index arg2 ;
12582   int arg3 ;
12583   Dali::PropertyCondition *arg4 = 0 ;
12584   Dali::PropertyNotification result;
12585
12586   arg1 = (Dali::Handle *)jarg1;
12587   arg2 = (Dali::Property::Index)jarg2;
12588   arg3 = (int)jarg3;
12589   arg4 = (Dali::PropertyCondition *)jarg4;
12590   if (!arg4) {
12591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12592     return 0;
12593   }
12594   {
12595     try {
12596       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
12597     } CALL_CATCH_EXCEPTION(0);
12598   }
12599
12600   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12601   return jresult;
12602 }
12603
12604
12605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
12606   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12607   Dali::PropertyNotification arg2 ;
12608   Dali::PropertyNotification *argp2 ;
12609
12610   arg1 = (Dali::Handle *)jarg1;
12611   argp2 = (Dali::PropertyNotification *)jarg2;
12612   if (!argp2) {
12613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
12614     return ;
12615   }
12616   arg2 = *argp2;
12617   {
12618     try {
12619       (arg1)->RemovePropertyNotification(arg2);
12620     } CALL_CATCH_EXCEPTION();
12621   }
12622
12623 }
12624
12625
12626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
12627   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12628
12629   arg1 = (Dali::Handle *)jarg1;
12630   {
12631     try {
12632       (arg1)->RemovePropertyNotifications();
12633     } CALL_CATCH_EXCEPTION();
12634   }
12635
12636 }
12637
12638
12639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
12640   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12641
12642   arg1 = (Dali::Handle *)jarg1;
12643   {
12644     try {
12645       (arg1)->RemoveConstraints();
12646     } CALL_CATCH_EXCEPTION();
12647   }
12648
12649 }
12650
12651
12652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
12653   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12654   unsigned int arg2 ;
12655
12656   arg1 = (Dali::Handle *)jarg1;
12657   arg2 = (unsigned int)jarg2;
12658   {
12659     try {
12660       (arg1)->RemoveConstraints(arg2);
12661     } CALL_CATCH_EXCEPTION();
12662   }
12663
12664 }
12665
12666
12667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
12668   int jresult ;
12669   Dali::Property::Index result;
12670
12671   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
12672   jresult = result;
12673   return jresult;
12674 }
12675
12676
12677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
12678   void * jresult ;
12679   Dali::Handle result;
12680
12681   {
12682     try {
12683       result = Dali::WeightObject::New();
12684     } CALL_CATCH_EXCEPTION(0);
12685   }
12686
12687   jresult = new Dali::Handle((const Dali::Handle &)result);
12688   return jresult;
12689 }
12690
12691
12692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
12693   void * jresult ;
12694   Dali::TypeInfo *result = 0 ;
12695
12696   {
12697     try {
12698       result = (Dali::TypeInfo *)new Dali::TypeInfo();
12699     } CALL_CATCH_EXCEPTION(0);
12700   }
12701
12702   jresult = (void *)result;
12703   return jresult;
12704 }
12705
12706
12707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
12708   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12709
12710   arg1 = (Dali::TypeInfo *)jarg1;
12711   {
12712     try {
12713       delete arg1;
12714     } CALL_CATCH_EXCEPTION();
12715   }
12716
12717 }
12718
12719
12720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
12721   void * jresult ;
12722   Dali::TypeInfo *arg1 = 0 ;
12723   Dali::TypeInfo *result = 0 ;
12724
12725   arg1 = (Dali::TypeInfo *)jarg1;
12726   if (!arg1) {
12727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
12728     return 0;
12729   }
12730   {
12731     try {
12732       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
12733     } CALL_CATCH_EXCEPTION(0);
12734   }
12735
12736   jresult = (void *)result;
12737   return jresult;
12738 }
12739
12740
12741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
12742   void * jresult ;
12743   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12744   Dali::TypeInfo *arg2 = 0 ;
12745   Dali::TypeInfo *result = 0 ;
12746
12747   arg1 = (Dali::TypeInfo *)jarg1;
12748   arg2 = (Dali::TypeInfo *)jarg2;
12749   if (!arg2) {
12750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
12751     return 0;
12752   }
12753   {
12754     try {
12755       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
12756     } CALL_CATCH_EXCEPTION(0);
12757   }
12758
12759   jresult = (void *)result;
12760   return jresult;
12761 }
12762
12763
12764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
12765   char * jresult ;
12766   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12767   std::string *result = 0 ;
12768
12769   arg1 = (Dali::TypeInfo *)jarg1;
12770   {
12771     try {
12772       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
12773     } CALL_CATCH_EXCEPTION(0);
12774   }
12775
12776   jresult = SWIG_csharp_string_callback(result->c_str());
12777   return jresult;
12778 }
12779
12780
12781 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
12782   char * jresult ;
12783   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12784   std::string *result = 0 ;
12785
12786   arg1 = (Dali::TypeInfo *)jarg1;
12787   {
12788     try {
12789       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
12790     } CALL_CATCH_EXCEPTION(0);
12791   }
12792
12793   jresult = SWIG_csharp_string_callback(result->c_str());
12794   return jresult;
12795 }
12796
12797
12798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
12799   void * jresult ;
12800   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12801   Dali::BaseHandle result;
12802
12803   arg1 = (Dali::TypeInfo *)jarg1;
12804   {
12805     try {
12806       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
12807     } CALL_CATCH_EXCEPTION(0);
12808   }
12809
12810   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
12811   return jresult;
12812 }
12813
12814
12815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
12816   unsigned long jresult ;
12817   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12818   size_t result;
12819
12820   arg1 = (Dali::TypeInfo *)jarg1;
12821   {
12822     try {
12823       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
12824     } CALL_CATCH_EXCEPTION(0);
12825   }
12826
12827   jresult = (unsigned long)result;
12828   return jresult;
12829 }
12830
12831
12832 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
12833   char * jresult ;
12834   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12835   size_t arg2 ;
12836   std::string result;
12837
12838   arg1 = (Dali::TypeInfo *)jarg1;
12839   arg2 = (size_t)jarg2;
12840   {
12841     try {
12842       result = (arg1)->GetActionName(arg2);
12843     } CALL_CATCH_EXCEPTION(0);
12844   }
12845
12846   jresult = SWIG_csharp_string_callback((&result)->c_str());
12847   return jresult;
12848 }
12849
12850
12851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
12852   unsigned long jresult ;
12853   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12854   size_t result;
12855
12856   arg1 = (Dali::TypeInfo *)jarg1;
12857   {
12858     try {
12859       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
12860     } CALL_CATCH_EXCEPTION(0);
12861   }
12862
12863   jresult = (unsigned long)result;
12864   return jresult;
12865 }
12866
12867
12868 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
12869   char * jresult ;
12870   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12871   size_t arg2 ;
12872   std::string result;
12873
12874   arg1 = (Dali::TypeInfo *)jarg1;
12875   arg2 = (size_t)jarg2;
12876   {
12877     try {
12878       result = (arg1)->GetSignalName(arg2);
12879     } CALL_CATCH_EXCEPTION(0);
12880   }
12881
12882   jresult = SWIG_csharp_string_callback((&result)->c_str());
12883   return jresult;
12884 }
12885
12886
12887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
12888   unsigned long jresult ;
12889   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12890   size_t result;
12891
12892   arg1 = (Dali::TypeInfo *)jarg1;
12893   {
12894     try {
12895       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
12896     } CALL_CATCH_EXCEPTION(0);
12897   }
12898
12899   jresult = (unsigned long)result;
12900   return jresult;
12901 }
12902
12903
12904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
12905   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12906   Dali::Property::IndexContainer *arg2 = 0 ;
12907
12908   arg1 = (Dali::TypeInfo *)jarg1;
12909   arg2 = (Dali::Property::IndexContainer *)jarg2;
12910   if (!arg2) {
12911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
12912     return ;
12913   }
12914   {
12915     try {
12916       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
12917     } CALL_CATCH_EXCEPTION();
12918   }
12919
12920 }
12921
12922
12923 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
12924   char * jresult ;
12925   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
12926   Dali::Property::Index arg2 ;
12927   std::string_view result;
12928
12929   arg1 = (Dali::TypeInfo *)jarg1;
12930   arg2 = (Dali::Property::Index)jarg2;
12931   {
12932     try {
12933       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
12934     } CALL_CATCH_EXCEPTION(0);
12935   }
12936
12937   jresult = SWIG_csharp_string_callback(result.data());
12938   return jresult;
12939 }
12940
12941
12942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
12943   void * jresult ;
12944   Dali::TypeRegistry result;
12945
12946   {
12947     try {
12948       result = Dali::TypeRegistry::Get();
12949     } CALL_CATCH_EXCEPTION(0);
12950   }
12951
12952   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
12953   return jresult;
12954 }
12955
12956
12957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
12958   void * jresult ;
12959   Dali::TypeRegistry *result = 0 ;
12960
12961   {
12962     try {
12963       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
12964     } CALL_CATCH_EXCEPTION(0);
12965   }
12966
12967   jresult = (void *)result;
12968   return jresult;
12969 }
12970
12971
12972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
12973   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
12974
12975   arg1 = (Dali::TypeRegistry *)jarg1;
12976   {
12977     try {
12978       delete arg1;
12979     } CALL_CATCH_EXCEPTION();
12980   }
12981
12982 }
12983
12984
12985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
12986   void * jresult ;
12987   Dali::TypeRegistry *arg1 = 0 ;
12988   Dali::TypeRegistry *result = 0 ;
12989
12990   arg1 = (Dali::TypeRegistry *)jarg1;
12991   if (!arg1) {
12992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
12993     return 0;
12994   }
12995   {
12996     try {
12997       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
12998     } CALL_CATCH_EXCEPTION(0);
12999   }
13000
13001   jresult = (void *)result;
13002   return jresult;
13003 }
13004
13005
13006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13007   void * jresult ;
13008   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13009   Dali::TypeRegistry *arg2 = 0 ;
13010   Dali::TypeRegistry *result = 0 ;
13011
13012   arg1 = (Dali::TypeRegistry *)jarg1;
13013   arg2 = (Dali::TypeRegistry *)jarg2;
13014   if (!arg2) {
13015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13016     return 0;
13017   }
13018   {
13019     try {
13020       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13021     } CALL_CATCH_EXCEPTION(0);
13022   }
13023
13024   jresult = (void *)result;
13025   return jresult;
13026 }
13027
13028
13029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13030   void * jresult ;
13031   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13032   std::string *arg2 = 0 ;
13033   Dali::TypeInfo result;
13034
13035   arg1 = (Dali::TypeRegistry *)jarg1;
13036   if (!jarg2) {
13037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13038     return 0;
13039   }
13040   std::string arg2_str(jarg2);
13041   arg2 = &arg2_str;
13042   {
13043     try {
13044       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13045     } CALL_CATCH_EXCEPTION(0);
13046   }
13047
13048   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13049
13050   //argout typemap for const std::string&
13051
13052   return jresult;
13053 }
13054
13055
13056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13057   void * jresult ;
13058   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13059   std::type_info *arg2 = 0 ;
13060   Dali::TypeInfo result;
13061
13062   arg1 = (Dali::TypeRegistry *)jarg1;
13063   arg2 = (std::type_info *)jarg2;
13064   if (!arg2) {
13065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13066     return 0;
13067   }
13068   {
13069     try {
13070       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13071     } CALL_CATCH_EXCEPTION(0);
13072   }
13073
13074   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13075   return jresult;
13076 }
13077
13078
13079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13080   unsigned long jresult ;
13081   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13082   size_t result;
13083
13084   arg1 = (Dali::TypeRegistry *)jarg1;
13085   {
13086     try {
13087       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13088     } CALL_CATCH_EXCEPTION(0);
13089   }
13090
13091   jresult = (unsigned long)result;
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13097   char * jresult ;
13098   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13099   size_t arg2 ;
13100   std::string result;
13101
13102   arg1 = (Dali::TypeRegistry *)jarg1;
13103   arg2 = (size_t)jarg2;
13104   {
13105     try {
13106       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13107     } CALL_CATCH_EXCEPTION(0);
13108   }
13109
13110   jresult = SWIG_csharp_string_callback((&result)->c_str());
13111   return jresult;
13112 }
13113
13114
13115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13116   void * jresult ;
13117   std::type_info *arg1 = 0 ;
13118   std::type_info *arg2 = 0 ;
13119   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13120   Dali::TypeRegistration *result = 0 ;
13121
13122   arg1 = (std::type_info *)jarg1;
13123   if (!arg1) {
13124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13125     return 0;
13126   }
13127   arg2 = (std::type_info *)jarg2;
13128   if (!arg2) {
13129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13130     return 0;
13131   }
13132   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13133   {
13134     try {
13135       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13136     } CALL_CATCH_EXCEPTION(0);
13137   }
13138
13139   jresult = (void *)result;
13140   return jresult;
13141 }
13142
13143
13144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
13145   void * jresult ;
13146   std::type_info *arg1 = 0 ;
13147   std::type_info *arg2 = 0 ;
13148   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13149   bool arg4 ;
13150   Dali::TypeRegistration *result = 0 ;
13151
13152   arg1 = (std::type_info *)jarg1;
13153   if (!arg1) {
13154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13155     return 0;
13156   }
13157   arg2 = (std::type_info *)jarg2;
13158   if (!arg2) {
13159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13160     return 0;
13161   }
13162   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13163   arg4 = jarg4 ? true : false;
13164   {
13165     try {
13166       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13167     } CALL_CATCH_EXCEPTION(0);
13168   }
13169
13170   jresult = (void *)result;
13171   return jresult;
13172 }
13173
13174
13175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13176   void * jresult ;
13177   std::string *arg1 = 0 ;
13178   std::type_info *arg2 = 0 ;
13179   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13180   Dali::TypeRegistration *result = 0 ;
13181
13182   if (!jarg1) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13184     return 0;
13185   }
13186   std::string arg1_str(jarg1);
13187   arg1 = &arg1_str;
13188   arg2 = (std::type_info *)jarg2;
13189   if (!arg2) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13191     return 0;
13192   }
13193   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13194   {
13195     try {
13196       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13197     } CALL_CATCH_EXCEPTION(0);
13198   }
13199
13200   jresult = (void *)result;
13201
13202   //argout typemap for const std::string&
13203
13204   return jresult;
13205 }
13206
13207
13208 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
13209   char * jresult ;
13210   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13211   std::string result;
13212
13213   arg1 = (Dali::TypeRegistration *)jarg1;
13214   {
13215     try {
13216       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
13217     } CALL_CATCH_EXCEPTION(0);
13218   }
13219
13220   jresult = SWIG_csharp_string_callback((&result)->c_str());
13221   return jresult;
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
13226   std::string *arg1 = 0 ;
13227   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13228
13229   if (!jarg1) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13231     return ;
13232   }
13233   std::string arg1_str(jarg1);
13234   arg1 = &arg1_str;
13235   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
13236   {
13237     try {
13238       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
13239     } CALL_CATCH_EXCEPTION();
13240   }
13241
13242
13243   //argout typemap for const std::string&
13244
13245 }
13246
13247
13248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13249   std::string *arg1 = 0 ;
13250   std::string *arg2 = 0 ;
13251   int arg3 ;
13252   Dali::Property::Type arg4 ;
13253   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
13254   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
13255
13256   if (!jarg1) {
13257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13258     return ;
13259   }
13260   std::string arg1_str(jarg1);
13261   arg1 = &arg1_str;
13262   if (!jarg2) {
13263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13264     return ;
13265   }
13266   std::string arg2_str(jarg2);
13267   arg2 = &arg2_str;
13268   arg3 = (int)jarg3;
13269   arg4 = (Dali::Property::Type)jarg4;
13270   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
13271   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
13272   {
13273     try {
13274       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13275     } CALL_CATCH_EXCEPTION();
13276   }
13277
13278
13279   //argout typemap for const std::string&
13280
13281
13282   //argout typemap for const std::string&
13283
13284 }
13285
13286
13287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
13288   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
13289
13290   arg1 = (Dali::TypeRegistration *)jarg1;
13291   {
13292     try {
13293       delete arg1;
13294     } CALL_CATCH_EXCEPTION();
13295   }
13296
13297 }
13298
13299
13300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
13301   void * jresult ;
13302   Dali::TypeRegistration *arg1 = 0 ;
13303   std::string *arg2 = 0 ;
13304   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
13305   Dali::SignalConnectorType *result = 0 ;
13306
13307   arg1 = (Dali::TypeRegistration *)jarg1;
13308   if (!arg1) {
13309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13310     return 0;
13311   }
13312   if (!jarg2) {
13313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13314     return 0;
13315   }
13316   std::string arg2_str(jarg2);
13317   arg2 = &arg2_str;
13318   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
13319   {
13320     try {
13321       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
13322     } CALL_CATCH_EXCEPTION(0);
13323   }
13324
13325   jresult = (void *)result;
13326
13327   //argout typemap for const std::string&
13328
13329   return jresult;
13330 }
13331
13332
13333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
13334   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
13335
13336   arg1 = (Dali::SignalConnectorType *)jarg1;
13337   {
13338     try {
13339       delete arg1;
13340     } CALL_CATCH_EXCEPTION();
13341   }
13342
13343 }
13344
13345
13346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
13347   void * jresult ;
13348   Dali::TypeRegistration *arg1 = 0 ;
13349   std::string *arg2 = 0 ;
13350   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
13351   Dali::TypeAction *result = 0 ;
13352
13353   arg1 = (Dali::TypeRegistration *)jarg1;
13354   if (!arg1) {
13355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13356     return 0;
13357   }
13358   if (!jarg2) {
13359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13360     return 0;
13361   }
13362   std::string arg2_str(jarg2);
13363   arg2 = &arg2_str;
13364   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
13365   {
13366     try {
13367       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
13368     } CALL_CATCH_EXCEPTION(0);
13369   }
13370
13371   jresult = (void *)result;
13372
13373   //argout typemap for const std::string&
13374
13375   return jresult;
13376 }
13377
13378
13379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
13380   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
13381
13382   arg1 = (Dali::TypeAction *)jarg1;
13383   {
13384     try {
13385       delete arg1;
13386     } CALL_CATCH_EXCEPTION();
13387   }
13388
13389 }
13390
13391
13392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13393   void * jresult ;
13394   Dali::TypeRegistration *arg1 = 0 ;
13395   std::string *arg2 = 0 ;
13396   Dali::Property::Index arg3 ;
13397   Dali::Property::Type arg4 ;
13398   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
13399   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
13400   Dali::PropertyRegistration *result = 0 ;
13401
13402   arg1 = (Dali::TypeRegistration *)jarg1;
13403   if (!arg1) {
13404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13405     return 0;
13406   }
13407   if (!jarg2) {
13408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13409     return 0;
13410   }
13411   std::string arg2_str(jarg2);
13412   arg2 = &arg2_str;
13413   arg3 = (Dali::Property::Index)jarg3;
13414   arg4 = (Dali::Property::Type)jarg4;
13415   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
13416   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
13417   {
13418     try {
13419       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13420     } CALL_CATCH_EXCEPTION(0);
13421   }
13422
13423   jresult = (void *)result;
13424
13425   //argout typemap for const std::string&
13426
13427   return jresult;
13428 }
13429
13430
13431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
13432   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
13433
13434   arg1 = (Dali::PropertyRegistration *)jarg1;
13435   {
13436     try {
13437       delete arg1;
13438     } CALL_CATCH_EXCEPTION();
13439   }
13440
13441 }
13442
13443
13444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13445   void * jresult ;
13446   Dali::TypeRegistration *arg1 = 0 ;
13447   std::string *arg2 = 0 ;
13448   Dali::Property::Index arg3 ;
13449   Dali::Property::Type arg4 ;
13450   Dali::AnimatablePropertyRegistration *result = 0 ;
13451
13452   arg1 = (Dali::TypeRegistration *)jarg1;
13453   if (!arg1) {
13454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13455     return 0;
13456   }
13457   if (!jarg2) {
13458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13459     return 0;
13460   }
13461   std::string arg2_str(jarg2);
13462   arg2 = &arg2_str;
13463   arg3 = (Dali::Property::Index)jarg3;
13464   arg4 = (Dali::Property::Type)jarg4;
13465   {
13466     try {
13467       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13468     } CALL_CATCH_EXCEPTION(0);
13469   }
13470
13471   jresult = (void *)result;
13472
13473   //argout typemap for const std::string&
13474
13475   return jresult;
13476 }
13477
13478
13479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
13480   void * jresult ;
13481   Dali::TypeRegistration *arg1 = 0 ;
13482   std::string *arg2 = 0 ;
13483   Dali::Property::Index arg3 ;
13484   Dali::Property::Value *arg4 = 0 ;
13485   Dali::AnimatablePropertyRegistration *result = 0 ;
13486
13487   arg1 = (Dali::TypeRegistration *)jarg1;
13488   if (!arg1) {
13489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13490     return 0;
13491   }
13492   if (!jarg2) {
13493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13494     return 0;
13495   }
13496   std::string arg2_str(jarg2);
13497   arg2 = &arg2_str;
13498   arg3 = (Dali::Property::Index)jarg3;
13499   arg4 = (Dali::Property::Value *)jarg4;
13500   if (!arg4) {
13501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13502     return 0;
13503   }
13504   {
13505     try {
13506       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
13507     } CALL_CATCH_EXCEPTION(0);
13508   }
13509
13510   jresult = (void *)result;
13511
13512   //argout typemap for const std::string&
13513
13514   return jresult;
13515 }
13516
13517
13518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
13519   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
13520
13521   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
13522   {
13523     try {
13524       delete arg1;
13525     } CALL_CATCH_EXCEPTION();
13526   }
13527
13528 }
13529
13530
13531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
13532   void * jresult ;
13533   Dali::TypeRegistration *arg1 = 0 ;
13534   std::string *arg2 = 0 ;
13535   Dali::Property::Index arg3 ;
13536   Dali::Property::Index arg4 ;
13537   unsigned int arg5 ;
13538   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
13539
13540   arg1 = (Dali::TypeRegistration *)jarg1;
13541   if (!arg1) {
13542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13543     return 0;
13544   }
13545   if (!jarg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13547     return 0;
13548   }
13549   std::string arg2_str(jarg2);
13550   arg2 = &arg2_str;
13551   arg3 = (Dali::Property::Index)jarg3;
13552   arg4 = (Dali::Property::Index)jarg4;
13553   arg5 = (unsigned int)jarg5;
13554   {
13555     try {
13556       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
13557     } CALL_CATCH_EXCEPTION(0);
13558   }
13559
13560   jresult = (void *)result;
13561
13562   //argout typemap for const std::string&
13563
13564   return jresult;
13565 }
13566
13567
13568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
13569   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
13570
13571   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
13572   {
13573     try {
13574       delete arg1;
13575     } CALL_CATCH_EXCEPTION();
13576   }
13577
13578 }
13579
13580
13581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
13582   void * jresult ;
13583   Dali::TypeRegistration *arg1 = 0 ;
13584   std::string *arg2 = 0 ;
13585   Dali::Property::Index arg3 ;
13586   Dali::Property::Type arg4 ;
13587   Dali::ChildPropertyRegistration *result = 0 ;
13588
13589   arg1 = (Dali::TypeRegistration *)jarg1;
13590   if (!arg1) {
13591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
13592     return 0;
13593   }
13594   if (!jarg2) {
13595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13596     return 0;
13597   }
13598   std::string arg2_str(jarg2);
13599   arg2 = &arg2_str;
13600   arg3 = (Dali::Property::Index)jarg3;
13601   arg4 = (Dali::Property::Type)jarg4;
13602   {
13603     try {
13604       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
13605     } CALL_CATCH_EXCEPTION(0);
13606   }
13607
13608   jresult = (void *)result;
13609
13610   //argout typemap for const std::string&
13611
13612   return jresult;
13613 }
13614
13615
13616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
13617   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
13618
13619   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
13620   {
13621     try {
13622       delete arg1;
13623     } CALL_CATCH_EXCEPTION();
13624   }
13625
13626 }
13627
13628
13629 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
13630   bool jresult ;
13631   std::string *arg1 = 0 ;
13632   std::type_info *arg2 = 0 ;
13633   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
13634   bool result;
13635
13636   if (!jarg1) {
13637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13638     return 0;
13639   }
13640   std::string arg1_str(jarg1);
13641   arg1 = &arg1_str;
13642   arg2 = (std::type_info *)jarg2;
13643   if (!arg2) {
13644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13645     return 0;
13646   }
13647   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
13648   {
13649     try {
13650       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13651     } CALL_CATCH_EXCEPTION(0);
13652   }
13653
13654   jresult = result;
13655
13656   //argout typemap for const std::string&
13657
13658   return jresult;
13659 }
13660
13661
13662 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
13663   bool jresult ;
13664   std::string *arg1 = 0 ;
13665   std::string *arg2 = 0 ;
13666   Dali::Property::Index arg3 ;
13667   Dali::Property::Type arg4 ;
13668   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
13669   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
13670   bool result;
13671
13672   if (!jarg1) {
13673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13674     return 0;
13675   }
13676   std::string arg1_str(jarg1);
13677   arg1 = &arg1_str;
13678   if (!jarg2) {
13679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13680     return 0;
13681   }
13682   std::string arg2_str(jarg2);
13683   arg2 = &arg2_str;
13684   arg3 = (Dali::Property::Index)jarg3;
13685   arg4 = (Dali::Property::Type)jarg4;
13686   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
13687   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
13688   {
13689     try {
13690       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
13691     } CALL_CATCH_EXCEPTION(0);
13692   }
13693
13694   jresult = result;
13695
13696   //argout typemap for const std::string&
13697
13698
13699   //argout typemap for const std::string&
13700
13701   return jresult;
13702 }
13703
13704
13705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
13706   float jresult ;
13707   float result;
13708
13709   result = (float)(float)Dali::ParentOrigin::TOP;
13710   jresult = result;
13711   return jresult;
13712 }
13713
13714
13715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
13716   float jresult ;
13717   float result;
13718
13719   result = (float)(float)Dali::ParentOrigin::BOTTOM;
13720   jresult = result;
13721   return jresult;
13722 }
13723
13724
13725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
13726   float jresult ;
13727   float result;
13728
13729   result = (float)(float)Dali::ParentOrigin::LEFT;
13730   jresult = result;
13731   return jresult;
13732 }
13733
13734
13735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
13736   float jresult ;
13737   float result;
13738
13739   result = (float)(float)Dali::ParentOrigin::RIGHT;
13740   jresult = result;
13741   return jresult;
13742 }
13743
13744
13745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
13746   float jresult ;
13747   float result;
13748
13749   result = (float)(float)Dali::ParentOrigin::MIDDLE;
13750   jresult = result;
13751   return jresult;
13752 }
13753
13754
13755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
13756   void * jresult ;
13757   Dali::Vector3 *result = 0 ;
13758
13759   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
13760   jresult = (void *)result;
13761   return jresult;
13762 }
13763
13764
13765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
13766   void * jresult ;
13767   Dali::Vector3 *result = 0 ;
13768
13769   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
13770   jresult = (void *)result;
13771   return jresult;
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
13776   void * jresult ;
13777   Dali::Vector3 *result = 0 ;
13778
13779   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
13780   jresult = (void *)result;
13781   return jresult;
13782 }
13783
13784
13785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
13786   void * jresult ;
13787   Dali::Vector3 *result = 0 ;
13788
13789   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
13790   jresult = (void *)result;
13791   return jresult;
13792 }
13793
13794
13795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
13796   void * jresult ;
13797   Dali::Vector3 *result = 0 ;
13798
13799   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
13806   void * jresult ;
13807   Dali::Vector3 *result = 0 ;
13808
13809   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
13810   jresult = (void *)result;
13811   return jresult;
13812 }
13813
13814
13815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
13816   void * jresult ;
13817   Dali::Vector3 *result = 0 ;
13818
13819   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
13820   jresult = (void *)result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
13826   void * jresult ;
13827   Dali::Vector3 *result = 0 ;
13828
13829   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
13830   jresult = (void *)result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
13836   void * jresult ;
13837   Dali::Vector3 *result = 0 ;
13838
13839   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
13840   jresult = (void *)result;
13841   return jresult;
13842 }
13843
13844
13845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
13846   float jresult ;
13847   float result;
13848
13849   result = (float)(float)Dali::AnchorPoint::TOP;
13850   jresult = result;
13851   return jresult;
13852 }
13853
13854
13855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
13856   float jresult ;
13857   float result;
13858
13859   result = (float)(float)Dali::AnchorPoint::BOTTOM;
13860   jresult = result;
13861   return jresult;
13862 }
13863
13864
13865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
13866   float jresult ;
13867   float result;
13868
13869   result = (float)(float)Dali::AnchorPoint::LEFT;
13870   jresult = result;
13871   return jresult;
13872 }
13873
13874
13875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
13876   float jresult ;
13877   float result;
13878
13879   result = (float)(float)Dali::AnchorPoint::RIGHT;
13880   jresult = result;
13881   return jresult;
13882 }
13883
13884
13885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
13886   float jresult ;
13887   float result;
13888
13889   result = (float)(float)Dali::AnchorPoint::MIDDLE;
13890   jresult = result;
13891   return jresult;
13892 }
13893
13894
13895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
13896   void * jresult ;
13897   Dali::Vector3 *result = 0 ;
13898
13899   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
13900   jresult = (void *)result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
13906   void * jresult ;
13907   Dali::Vector3 *result = 0 ;
13908
13909   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
13910   jresult = (void *)result;
13911   return jresult;
13912 }
13913
13914
13915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
13916   void * jresult ;
13917   Dali::Vector3 *result = 0 ;
13918
13919   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
13920   jresult = (void *)result;
13921   return jresult;
13922 }
13923
13924
13925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
13926   void * jresult ;
13927   Dali::Vector3 *result = 0 ;
13928
13929   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
13930   jresult = (void *)result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
13936   void * jresult ;
13937   Dali::Vector3 *result = 0 ;
13938
13939   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
13940   jresult = (void *)result;
13941   return jresult;
13942 }
13943
13944
13945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
13946   void * jresult ;
13947   Dali::Vector3 *result = 0 ;
13948
13949   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
13950   jresult = (void *)result;
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
13956   void * jresult ;
13957   Dali::Vector3 *result = 0 ;
13958
13959   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
13960   jresult = (void *)result;
13961   return jresult;
13962 }
13963
13964
13965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
13966   void * jresult ;
13967   Dali::Vector3 *result = 0 ;
13968
13969   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
13970   jresult = (void *)result;
13971   return jresult;
13972 }
13973
13974
13975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
13976   void * jresult ;
13977   Dali::Vector3 *result = 0 ;
13978
13979   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
13980   jresult = (void *)result;
13981   return jresult;
13982 }
13983
13984
13985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() {
13986   void * jresult;
13987   Dali::Vector4 *result = 0 ;
13988
13989   result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE;
13990   jresult = (void *)result;
13991   return jresult;
13992 }
13993
13994
13995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() {
13996   void * jresult;
13997   Dali::Vector4 *result = 0 ;
13998
13999   result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE;
14000   jresult = (void *)result;
14001   return jresult;
14002 }
14003
14004
14005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() {
14006   void * jresult;
14007   Dali::Vector4 *result = 0 ;
14008
14009   result = (Dali::Vector4 *)&Dali::Color::AQUA;
14010   jresult = (void *)result;
14011   return jresult;
14012 }
14013
14014
14015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() {
14016   void * jresult;
14017   Dali::Vector4 *result = 0 ;
14018
14019   result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE;
14020   jresult = (void *)result;
14021   return jresult;
14022 }
14023
14024
14025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() {
14026   void * jresult;
14027   Dali::Vector4 *result = 0 ;
14028
14029   result = (Dali::Vector4 *)&Dali::Color::AZURE;
14030   jresult = (void *)result;
14031   return jresult;
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() {
14036   void * jresult;
14037   Dali::Vector4 *result = 0 ;
14038
14039   result = (Dali::Vector4 *)&Dali::Color::BEIGE;
14040   jresult = (void *)result;
14041   return jresult;
14042 }
14043
14044
14045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() {
14046   void * jresult;
14047   Dali::Vector4 *result = 0 ;
14048
14049   result = (Dali::Vector4 *)&Dali::Color::BISQUE;
14050   jresult = (void *)result;
14051   return jresult;
14052 }
14053
14054
14055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14056   void * jresult;
14057   Dali::Vector4 *result = 0 ;
14058
14059   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14060   jresult = (void *)result;
14061   return jresult;
14062 }
14063
14064
14065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() {
14066   void * jresult;
14067   Dali::Vector4 *result = 0 ;
14068
14069   result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND;
14070   jresult = (void *)result;
14071   return jresult;
14072 }
14073
14074
14075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14076   void * jresult;
14077   Dali::Vector4 *result = 0 ;
14078
14079   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14080   jresult = (void *)result;
14081   return jresult;
14082 }
14083
14084
14085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() {
14086   void * jresult;
14087   Dali::Vector4 *result = 0 ;
14088
14089   result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET;
14090   jresult = (void *)result;
14091   return jresult;
14092 }
14093
14094
14095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() {
14096   void * jresult;
14097   Dali::Vector4 *result = 0 ;
14098
14099   result = (Dali::Vector4 *)&Dali::Color::BROWN;
14100   jresult = (void *)result;
14101   return jresult;
14102 }
14103
14104
14105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() {
14106   void * jresult;
14107   Dali::Vector4 *result = 0 ;
14108
14109   result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD;
14110   jresult = (void *)result;
14111   return jresult;
14112 }
14113
14114
14115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() {
14116   void * jresult;
14117   Dali::Vector4 *result = 0 ;
14118
14119   result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE;
14120   jresult = (void *)result;
14121   return jresult;
14122 }
14123
14124
14125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() {
14126   void * jresult;
14127   Dali::Vector4 *result = 0 ;
14128
14129   result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE;
14130   jresult = (void *)result;
14131   return jresult;
14132 }
14133
14134
14135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() {
14136   void * jresult;
14137   Dali::Vector4 *result = 0 ;
14138
14139   result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE;
14140   jresult = (void *)result;
14141   return jresult;
14142 }
14143
14144
14145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() {
14146   void * jresult;
14147   Dali::Vector4 *result = 0 ;
14148
14149   result = (Dali::Vector4 *)&Dali::Color::CORAL;
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() {
14156   void * jresult;
14157   Dali::Vector4 *result = 0 ;
14158
14159   result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE;
14160   jresult = (void *)result;
14161   return jresult;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() {
14166   void * jresult;
14167   Dali::Vector4 *result = 0 ;
14168
14169   result = (Dali::Vector4 *)&Dali::Color::CORNSILK;
14170   jresult = (void *)result;
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() {
14176   void * jresult;
14177   Dali::Vector4 *result = 0 ;
14178
14179   result = (Dali::Vector4 *)&Dali::Color::CRIMSON;
14180   jresult = (void *)result;
14181   return jresult;
14182 }
14183
14184
14185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14186   void * jresult;
14187   Dali::Vector4 *result = 0 ;
14188
14189   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14190   jresult = (void *)result;
14191   return jresult;
14192 }
14193
14194
14195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() {
14196   void * jresult;
14197   Dali::Vector4 *result = 0 ;
14198
14199   result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE;
14200   jresult = (void *)result;
14201   return jresult;
14202 }
14203
14204
14205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() {
14206   void * jresult;
14207   Dali::Vector4 *result = 0 ;
14208
14209   result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN;
14210   jresult = (void *)result;
14211   return jresult;
14212 }
14213
14214
14215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() {
14216   void * jresult;
14217   Dali::Vector4 *result = 0 ;
14218
14219   result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD;
14220   jresult = (void *)result;
14221   return jresult;
14222 }
14223
14224
14225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() {
14226   void * jresult;
14227   Dali::Vector4 *result = 0 ;
14228
14229   result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY;
14230   jresult = (void *)result;
14231   return jresult;
14232 }
14233
14234
14235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() {
14236   void * jresult;
14237   Dali::Vector4 *result = 0 ;
14238
14239   result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN;
14240   jresult = (void *)result;
14241   return jresult;
14242 }
14243
14244
14245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() {
14246   void * jresult;
14247   Dali::Vector4 *result = 0 ;
14248
14249   result = (Dali::Vector4 *)&Dali::Color::DARK_GREY;
14250   jresult = (void *)result;
14251   return jresult;
14252 }
14253
14254
14255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() {
14256   void * jresult;
14257   Dali::Vector4 *result = 0 ;
14258
14259   result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI;
14260   jresult = (void *)result;
14261   return jresult;
14262 }
14263
14264
14265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() {
14266   void * jresult;
14267   Dali::Vector4 *result = 0 ;
14268
14269   result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA;
14270   jresult = (void *)result;
14271   return jresult;
14272 }
14273
14274
14275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() {
14276   void * jresult;
14277   Dali::Vector4 *result = 0 ;
14278
14279   result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN;
14280   jresult = (void *)result;
14281   return jresult;
14282 }
14283
14284
14285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() {
14286   void * jresult;
14287   Dali::Vector4 *result = 0 ;
14288
14289   result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE;
14290   jresult = (void *)result;
14291   return jresult;
14292 }
14293
14294
14295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() {
14296   void * jresult;
14297   Dali::Vector4 *result = 0 ;
14298
14299   result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID;
14300   jresult = (void *)result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() {
14306   void * jresult;
14307   Dali::Vector4 *result = 0 ;
14308
14309   result = (Dali::Vector4 *)&Dali::Color::DARK_RED;
14310   jresult = (void *)result;
14311   return jresult;
14312 }
14313
14314
14315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() {
14316   void * jresult;
14317   Dali::Vector4 *result = 0 ;
14318
14319   result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON;
14320   jresult = (void *)result;
14321   return jresult;
14322 }
14323
14324
14325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() {
14326   void * jresult;
14327   Dali::Vector4 *result = 0 ;
14328
14329   result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN;
14330   jresult = (void *)result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() {
14336   void * jresult;
14337   Dali::Vector4 *result = 0 ;
14338
14339   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE;
14340   jresult = (void *)result;
14341   return jresult;
14342 }
14343
14344
14345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() {
14346   void * jresult;
14347   Dali::Vector4 *result = 0 ;
14348
14349   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY;
14350   jresult = (void *)result;
14351   return jresult;
14352 }
14353
14354
14355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() {
14356   void * jresult;
14357   Dali::Vector4 *result = 0 ;
14358
14359   result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY;
14360   jresult = (void *)result;
14361   return jresult;
14362 }
14363
14364
14365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() {
14366   void * jresult;
14367   Dali::Vector4 *result = 0 ;
14368
14369   result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE;
14370   jresult = (void *)result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() {
14376   void * jresult;
14377   Dali::Vector4 *result = 0 ;
14378
14379   result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET;
14380   jresult = (void *)result;
14381   return jresult;
14382 }
14383
14384
14385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() {
14386   void * jresult;
14387   Dali::Vector4 *result = 0 ;
14388
14389   result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK;
14390   jresult = (void *)result;
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() {
14396   void * jresult;
14397   Dali::Vector4 *result = 0 ;
14398
14399   result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE;
14400   jresult = (void *)result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() {
14406   void * jresult;
14407   Dali::Vector4 *result = 0 ;
14408
14409   result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY;
14410   jresult = (void *)result;
14411   return jresult;
14412 }
14413
14414
14415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() {
14416   void * jresult;
14417   Dali::Vector4 *result = 0 ;
14418
14419   result = (Dali::Vector4 *)&Dali::Color::DIM_GREY;
14420   jresult = (void *)result;
14421   return jresult;
14422 }
14423
14424
14425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() {
14426   void * jresult;
14427   Dali::Vector4 *result = 0 ;
14428
14429   result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE;
14430   jresult = (void *)result;
14431   return jresult;
14432 }
14433
14434
14435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() {
14436   void * jresult;
14437   Dali::Vector4 *result = 0 ;
14438
14439   result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK;
14440   jresult = (void *)result;
14441   return jresult;
14442 }
14443
14444
14445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() {
14446   void * jresult;
14447   Dali::Vector4 *result = 0 ;
14448
14449   result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE;
14450   jresult = (void *)result;
14451   return jresult;
14452 }
14453
14454
14455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() {
14456   void * jresult;
14457   Dali::Vector4 *result = 0 ;
14458
14459   result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN;
14460   jresult = (void *)result;
14461   return jresult;
14462 }
14463
14464
14465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() {
14466   void * jresult;
14467   Dali::Vector4 *result = 0 ;
14468
14469   result = (Dali::Vector4 *)&Dali::Color::FUCHSIA;
14470   jresult = (void *)result;
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() {
14476   void * jresult;
14477   Dali::Vector4 *result = 0 ;
14478
14479   result = (Dali::Vector4 *)&Dali::Color::GAINSBORO;
14480   jresult = (void *)result;
14481   return jresult;
14482 }
14483
14484
14485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() {
14486   void * jresult;
14487   Dali::Vector4 *result = 0 ;
14488
14489   result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE;
14490   jresult = (void *)result;
14491   return jresult;
14492 }
14493
14494
14495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() {
14496   void * jresult;
14497   Dali::Vector4 *result = 0 ;
14498
14499   result = (Dali::Vector4 *)&Dali::Color::GOLD;
14500   jresult = (void *)result;
14501   return jresult;
14502 }
14503
14504
14505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() {
14506   void * jresult;
14507   Dali::Vector4 *result = 0 ;
14508
14509   result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD;
14510   jresult = (void *)result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() {
14516   void * jresult;
14517   Dali::Vector4 *result = 0 ;
14518
14519   result = (Dali::Vector4 *)&Dali::Color::GRAY;
14520   jresult = (void *)result;
14521   return jresult;
14522 }
14523
14524
14525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14526   void * jresult;
14527   Dali::Vector4 *result = 0 ;
14528
14529   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14530   jresult = (void *)result;
14531   return jresult;
14532 }
14533
14534
14535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() {
14536   void * jresult;
14537   Dali::Vector4 *result = 0 ;
14538
14539   result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW;
14540   jresult = (void *)result;
14541   return jresult;
14542 }
14543
14544
14545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() {
14546   void * jresult;
14547   Dali::Vector4 *result = 0 ;
14548
14549   result = (Dali::Vector4 *)&Dali::Color::GREY;
14550   jresult = (void *)result;
14551   return jresult;
14552 }
14553
14554
14555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() {
14556   void * jresult;
14557   Dali::Vector4 *result = 0 ;
14558
14559   result = (Dali::Vector4 *)&Dali::Color::HONEYDEW;
14560   jresult = (void *)result;
14561   return jresult;
14562 }
14563
14564
14565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() {
14566   void * jresult;
14567   Dali::Vector4 *result = 0 ;
14568
14569   result = (Dali::Vector4 *)&Dali::Color::HOT_PINK;
14570   jresult = (void *)result;
14571   return jresult;
14572 }
14573
14574
14575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() {
14576   void * jresult;
14577   Dali::Vector4 *result = 0 ;
14578
14579   result = (Dali::Vector4 *)&Dali::Color::INDIANRED;
14580   jresult = (void *)result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() {
14586   void * jresult;
14587   Dali::Vector4 *result = 0 ;
14588
14589   result = (Dali::Vector4 *)&Dali::Color::INDIGO;
14590   jresult = (void *)result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() {
14596   void * jresult;
14597   Dali::Vector4 *result = 0 ;
14598
14599   result = (Dali::Vector4 *)&Dali::Color::IVORY;
14600   jresult = (void *)result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() {
14606   void * jresult;
14607   Dali::Vector4 *result = 0 ;
14608
14609   result = (Dali::Vector4 *)&Dali::Color::KHAKI;
14610   jresult = (void *)result;
14611   return jresult;
14612 }
14613
14614
14615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() {
14616   void * jresult;
14617   Dali::Vector4 *result = 0 ;
14618
14619   result = (Dali::Vector4 *)&Dali::Color::LAVENDER;
14620   jresult = (void *)result;
14621   return jresult;
14622 }
14623
14624
14625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() {
14626   void * jresult;
14627   Dali::Vector4 *result = 0 ;
14628
14629   result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH;
14630   jresult = (void *)result;
14631   return jresult;
14632 }
14633
14634
14635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() {
14636   void * jresult;
14637   Dali::Vector4 *result = 0 ;
14638
14639   result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN;
14640   jresult = (void *)result;
14641   return jresult;
14642 }
14643
14644
14645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() {
14646   void * jresult;
14647   Dali::Vector4 *result = 0 ;
14648
14649   result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON;
14650   jresult = (void *)result;
14651   return jresult;
14652 }
14653
14654
14655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() {
14656   void * jresult;
14657   Dali::Vector4 *result = 0 ;
14658
14659   result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE;
14660   jresult = (void *)result;
14661   return jresult;
14662 }
14663
14664
14665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() {
14666   void * jresult;
14667   Dali::Vector4 *result = 0 ;
14668
14669   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL;
14670   jresult = (void *)result;
14671   return jresult;
14672 }
14673
14674
14675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() {
14676   void * jresult;
14677   Dali::Vector4 *result = 0 ;
14678
14679   result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN;
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() {
14686   void * jresult;
14687   Dali::Vector4 *result = 0 ;
14688
14689   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW;
14690   jresult = (void *)result;
14691   return jresult;
14692 }
14693
14694
14695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() {
14696   void * jresult;
14697   Dali::Vector4 *result = 0 ;
14698
14699   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY;
14700   jresult = (void *)result;
14701   return jresult;
14702 }
14703
14704
14705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() {
14706   void * jresult;
14707   Dali::Vector4 *result = 0 ;
14708
14709   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN;
14710   jresult = (void *)result;
14711   return jresult;
14712 }
14713
14714
14715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() {
14716   void * jresult;
14717   Dali::Vector4 *result = 0 ;
14718
14719   result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY;
14720   jresult = (void *)result;
14721   return jresult;
14722 }
14723
14724
14725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() {
14726   void * jresult;
14727   Dali::Vector4 *result = 0 ;
14728
14729   result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK;
14730   jresult = (void *)result;
14731   return jresult;
14732 }
14733
14734
14735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() {
14736   void * jresult;
14737   Dali::Vector4 *result = 0 ;
14738
14739   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON;
14740   jresult = (void *)result;
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() {
14746   void * jresult;
14747   Dali::Vector4 *result = 0 ;
14748
14749   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN;
14750   jresult = (void *)result;
14751   return jresult;
14752 }
14753
14754
14755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() {
14756   void * jresult;
14757   Dali::Vector4 *result = 0 ;
14758
14759   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE;
14760   jresult = (void *)result;
14761   return jresult;
14762 }
14763
14764
14765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() {
14766   void * jresult;
14767   Dali::Vector4 *result = 0 ;
14768
14769   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY;
14770   jresult = (void *)result;
14771   return jresult;
14772 }
14773
14774
14775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() {
14776   void * jresult;
14777   Dali::Vector4 *result = 0 ;
14778
14779   result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY;
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() {
14786   void * jresult;
14787   Dali::Vector4 *result = 0 ;
14788
14789   result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE;
14790   jresult = (void *)result;
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() {
14796   void * jresult;
14797   Dali::Vector4 *result = 0 ;
14798
14799   result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW;
14800   jresult = (void *)result;
14801   return jresult;
14802 }
14803
14804
14805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() {
14806   void * jresult;
14807   Dali::Vector4 *result = 0 ;
14808
14809   result = (Dali::Vector4 *)&Dali::Color::LIME;
14810   jresult = (void *)result;
14811   return jresult;
14812 }
14813
14814
14815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() {
14816   void * jresult;
14817   Dali::Vector4 *result = 0 ;
14818
14819   result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN;
14820   jresult = (void *)result;
14821   return jresult;
14822 }
14823
14824
14825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() {
14826   void * jresult;
14827   Dali::Vector4 *result = 0 ;
14828
14829   result = (Dali::Vector4 *)&Dali::Color::LINEN;
14830   jresult = (void *)result;
14831   return jresult;
14832 }
14833
14834
14835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
14836   void * jresult;
14837   Dali::Vector4 *result = 0 ;
14838
14839   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
14840   jresult = (void *)result;
14841   return jresult;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() {
14846   void * jresult;
14847   Dali::Vector4 *result = 0 ;
14848
14849   result = (Dali::Vector4 *)&Dali::Color::MAROON;
14850   jresult = (void *)result;
14851   return jresult;
14852 }
14853
14854
14855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() {
14856   void * jresult;
14857   Dali::Vector4 *result = 0 ;
14858
14859   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE;
14860   jresult = (void *)result;
14861   return jresult;
14862 }
14863
14864
14865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() {
14866   void * jresult;
14867   Dali::Vector4 *result = 0 ;
14868
14869   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE;
14870   jresult = (void *)result;
14871   return jresult;
14872 }
14873
14874
14875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() {
14876   void * jresult;
14877   Dali::Vector4 *result = 0 ;
14878
14879   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID;
14880   jresult = (void *)result;
14881   return jresult;
14882 }
14883
14884
14885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() {
14886   void * jresult;
14887   Dali::Vector4 *result = 0 ;
14888
14889   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE;
14890   jresult = (void *)result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() {
14896   void * jresult;
14897   Dali::Vector4 *result = 0 ;
14898
14899   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN;
14900   jresult = (void *)result;
14901   return jresult;
14902 }
14903
14904
14905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() {
14906   void * jresult;
14907   Dali::Vector4 *result = 0 ;
14908
14909   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE;
14910   jresult = (void *)result;
14911   return jresult;
14912 }
14913
14914
14915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() {
14916   void * jresult;
14917   Dali::Vector4 *result = 0 ;
14918
14919   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN;
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() {
14926   void * jresult;
14927   Dali::Vector4 *result = 0 ;
14928
14929   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE;
14930   jresult = (void *)result;
14931   return jresult;
14932 }
14933
14934
14935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() {
14936   void * jresult;
14937   Dali::Vector4 *result = 0 ;
14938
14939   result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED;
14940   jresult = (void *)result;
14941   return jresult;
14942 }
14943
14944
14945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() {
14946   void * jresult;
14947   Dali::Vector4 *result = 0 ;
14948
14949   result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE;
14950   jresult = (void *)result;
14951   return jresult;
14952 }
14953
14954
14955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() {
14956   void * jresult;
14957   Dali::Vector4 *result = 0 ;
14958
14959   result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM;
14960   jresult = (void *)result;
14961   return jresult;
14962 }
14963
14964
14965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() {
14966   void * jresult;
14967   Dali::Vector4 *result = 0 ;
14968
14969   result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE;
14970   jresult = (void *)result;
14971   return jresult;
14972 }
14973
14974
14975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() {
14976   void * jresult;
14977   Dali::Vector4 *result = 0 ;
14978
14979   result = (Dali::Vector4 *)&Dali::Color::MOCCASIN;
14980   jresult = (void *)result;
14981   return jresult;
14982 }
14983
14984
14985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() {
14986   void * jresult;
14987   Dali::Vector4 *result = 0 ;
14988
14989   result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE;
14990   jresult = (void *)result;
14991   return jresult;
14992 }
14993
14994
14995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() {
14996   void * jresult;
14997   Dali::Vector4 *result = 0 ;
14998
14999   result = (Dali::Vector4 *)&Dali::Color::NAVY;
15000   jresult = (void *)result;
15001   return jresult;
15002 }
15003
15004
15005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() {
15006   void * jresult;
15007   Dali::Vector4 *result = 0 ;
15008
15009   result = (Dali::Vector4 *)&Dali::Color::OLD_LACE;
15010   jresult = (void *)result;
15011   return jresult;
15012 }
15013
15014
15015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() {
15016   void * jresult;
15017   Dali::Vector4 *result = 0 ;
15018
15019   result = (Dali::Vector4 *)&Dali::Color::OLIVE;
15020   jresult = (void *)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() {
15026   void * jresult;
15027   Dali::Vector4 *result = 0 ;
15028
15029   result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB;
15030   jresult = (void *)result;
15031   return jresult;
15032 }
15033
15034
15035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() {
15036   void * jresult;
15037   Dali::Vector4 *result = 0 ;
15038
15039   result = (Dali::Vector4 *)&Dali::Color::ORANGE;
15040   jresult = (void *)result;
15041   return jresult;
15042 }
15043
15044
15045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() {
15046   void * jresult;
15047   Dali::Vector4 *result = 0 ;
15048
15049   result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED;
15050   jresult = (void *)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() {
15056   void * jresult;
15057   Dali::Vector4 *result = 0 ;
15058
15059   result = (Dali::Vector4 *)&Dali::Color::ORCHID;
15060   jresult = (void *)result;
15061   return jresult;
15062 }
15063
15064
15065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() {
15066   void * jresult;
15067   Dali::Vector4 *result = 0 ;
15068
15069   result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD;
15070   jresult = (void *)result;
15071   return jresult;
15072 }
15073
15074
15075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() {
15076   void * jresult;
15077   Dali::Vector4 *result = 0 ;
15078
15079   result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN;
15080   jresult = (void *)result;
15081   return jresult;
15082 }
15083
15084
15085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() {
15086   void * jresult;
15087   Dali::Vector4 *result = 0 ;
15088
15089   result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE;
15090   jresult = (void *)result;
15091   return jresult;
15092 }
15093
15094
15095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() {
15096   void * jresult;
15097   Dali::Vector4 *result = 0 ;
15098
15099   result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED;
15100   jresult = (void *)result;
15101   return jresult;
15102 }
15103
15104
15105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() {
15106   void * jresult;
15107   Dali::Vector4 *result = 0 ;
15108
15109   result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP;
15110   jresult = (void *)result;
15111   return jresult;
15112 }
15113
15114
15115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() {
15116   void * jresult;
15117   Dali::Vector4 *result = 0 ;
15118
15119   result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF;
15120   jresult = (void *)result;
15121   return jresult;
15122 }
15123
15124
15125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() {
15126   void * jresult;
15127   Dali::Vector4 *result = 0 ;
15128
15129   result = (Dali::Vector4 *)&Dali::Color::PERU;
15130   jresult = (void *)result;
15131   return jresult;
15132 }
15133
15134
15135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() {
15136   void * jresult;
15137   Dali::Vector4 *result = 0 ;
15138
15139   result = (Dali::Vector4 *)&Dali::Color::PINK;
15140   jresult = (void *)result;
15141   return jresult;
15142 }
15143
15144
15145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() {
15146   void * jresult;
15147   Dali::Vector4 *result = 0 ;
15148
15149   result = (Dali::Vector4 *)&Dali::Color::PLUM;
15150   jresult = (void *)result;
15151   return jresult;
15152 }
15153
15154
15155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() {
15156   void * jresult;
15157   Dali::Vector4 *result = 0 ;
15158
15159   result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE;
15160   jresult = (void *)result;
15161   return jresult;
15162 }
15163
15164
15165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() {
15166   void * jresult;
15167   Dali::Vector4 *result = 0 ;
15168
15169   result = (Dali::Vector4 *)&Dali::Color::PURPLE;
15170   jresult = (void *)result;
15171   return jresult;
15172 }
15173
15174
15175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
15176   void * jresult;
15177   Dali::Vector4 *result = 0 ;
15178
15179   result = (Dali::Vector4 *)&Dali::Color::RED;
15180   jresult = (void *)result;
15181   return jresult;
15182 }
15183
15184
15185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() {
15186   void * jresult;
15187   Dali::Vector4 *result = 0 ;
15188
15189   result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN;
15190   jresult = (void *)result;
15191   return jresult;
15192 }
15193
15194
15195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() {
15196   void * jresult;
15197   Dali::Vector4 *result = 0 ;
15198
15199   result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE;
15200   jresult = (void *)result;
15201   return jresult;
15202 }
15203
15204
15205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() {
15206   void * jresult;
15207   Dali::Vector4 *result = 0 ;
15208
15209   result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN;
15210   jresult = (void *)result;
15211   return jresult;
15212 }
15213
15214
15215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() {
15216   void * jresult;
15217   Dali::Vector4 *result = 0 ;
15218
15219   result = (Dali::Vector4 *)&Dali::Color::SALMON;
15220   jresult = (void *)result;
15221   return jresult;
15222 }
15223
15224
15225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() {
15226   void * jresult;
15227   Dali::Vector4 *result = 0 ;
15228
15229   result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN;
15230   jresult = (void *)result;
15231   return jresult;
15232 }
15233
15234
15235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() {
15236   void * jresult;
15237   Dali::Vector4 *result = 0 ;
15238
15239   result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN;
15240   jresult = (void *)result;
15241   return jresult;
15242 }
15243
15244
15245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() {
15246   void * jresult;
15247   Dali::Vector4 *result = 0 ;
15248
15249   result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL;
15250   jresult = (void *)result;
15251   return jresult;
15252 }
15253
15254
15255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() {
15256   void * jresult;
15257   Dali::Vector4 *result = 0 ;
15258
15259   result = (Dali::Vector4 *)&Dali::Color::SIENNA;
15260   jresult = (void *)result;
15261   return jresult;
15262 }
15263
15264
15265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() {
15266   void * jresult;
15267   Dali::Vector4 *result = 0 ;
15268
15269   result = (Dali::Vector4 *)&Dali::Color::SILVER;
15270   jresult = (void *)result;
15271   return jresult;
15272 }
15273
15274
15275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() {
15276   void * jresult;
15277   Dali::Vector4 *result = 0 ;
15278
15279   result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE;
15280   jresult = (void *)result;
15281   return jresult;
15282 }
15283
15284
15285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() {
15286   void * jresult;
15287   Dali::Vector4 *result = 0 ;
15288
15289   result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE;
15290   jresult = (void *)result;
15291   return jresult;
15292 }
15293
15294
15295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() {
15296   void * jresult;
15297   Dali::Vector4 *result = 0 ;
15298
15299   result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY;
15300   jresult = (void *)result;
15301   return jresult;
15302 }
15303
15304
15305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() {
15306   void * jresult;
15307   Dali::Vector4 *result = 0 ;
15308
15309   result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY;
15310   jresult = (void *)result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() {
15316   void * jresult;
15317   Dali::Vector4 *result = 0 ;
15318
15319   result = (Dali::Vector4 *)&Dali::Color::SNOW;
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() {
15326   void * jresult;
15327   Dali::Vector4 *result = 0 ;
15328
15329   result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN;
15330   jresult = (void *)result;
15331   return jresult;
15332 }
15333
15334
15335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() {
15336   void * jresult;
15337   Dali::Vector4 *result = 0 ;
15338
15339   result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE;
15340   jresult = (void *)result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() {
15346   void * jresult;
15347   Dali::Vector4 *result = 0 ;
15348
15349   result = (Dali::Vector4 *)&Dali::Color::TAN;
15350   jresult = (void *)result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() {
15356   void * jresult;
15357   Dali::Vector4 *result = 0 ;
15358
15359   result = (Dali::Vector4 *)&Dali::Color::TEAL;
15360   jresult = (void *)result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() {
15366   void * jresult;
15367   Dali::Vector4 *result = 0 ;
15368
15369   result = (Dali::Vector4 *)&Dali::Color::THISTLE;
15370   jresult = (void *)result;
15371   return jresult;
15372 }
15373
15374
15375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() {
15376   void * jresult;
15377   Dali::Vector4 *result = 0 ;
15378
15379   result = (Dali::Vector4 *)&Dali::Color::TOMATO;
15380   jresult = (void *)result;
15381   return jresult;
15382 }
15383
15384
15385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
15386   void * jresult;
15387   Dali::Vector4 *result = 0 ;
15388
15389   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
15390   jresult = (void *)result;
15391   return jresult;
15392 }
15393
15394
15395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() {
15396   void * jresult;
15397   Dali::Vector4 *result = 0 ;
15398
15399   result = (Dali::Vector4 *)&Dali::Color::TURQUOISE;
15400   jresult = (void *)result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() {
15406   void * jresult;
15407   Dali::Vector4 *result = 0 ;
15408
15409   result = (Dali::Vector4 *)&Dali::Color::VIOLET;
15410   jresult = (void *)result;
15411   return jresult;
15412 }
15413
15414
15415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() {
15416   void * jresult;
15417   Dali::Vector4 *result = 0 ;
15418
15419   result = (Dali::Vector4 *)&Dali::Color::WHEAT;
15420   jresult = (void *)result;
15421   return jresult;
15422 }
15423
15424
15425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
15426   void * jresult;
15427   Dali::Vector4 *result = 0 ;
15428
15429   result = (Dali::Vector4 *)&Dali::Color::WHITE;
15430   jresult = (void *)result;
15431   return jresult;
15432 }
15433
15434
15435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() {
15436   void * jresult;
15437   Dali::Vector4 *result = 0 ;
15438
15439   result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE;
15440   jresult = (void *)result;
15441   return jresult;
15442 }
15443
15444
15445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
15446   void * jresult;
15447   Dali::Vector4 *result = 0 ;
15448
15449   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
15450   jresult = (void *)result;
15451   return jresult;
15452 }
15453
15454
15455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() {
15456   void * jresult;
15457   Dali::Vector4 *result = 0 ;
15458
15459   result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN;
15460   jresult = (void *)result;
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
15466   float jresult ;
15467   float result;
15468
15469   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
15470   jresult = result;
15471   return jresult;
15472 }
15473
15474
15475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
15476   float jresult ;
15477   float result;
15478
15479   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
15480   jresult = result;
15481   return jresult;
15482 }
15483
15484
15485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
15486   float jresult ;
15487   float result;
15488
15489   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
15490   jresult = result;
15491   return jresult;
15492 }
15493
15494
15495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
15496   float jresult ;
15497   float result;
15498
15499   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
15500   jresult = result;
15501   return jresult;
15502 }
15503
15504
15505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
15506   float jresult ;
15507   float result;
15508
15509   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
15510   jresult = result;
15511   return jresult;
15512 }
15513
15514
15515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
15516   float jresult ;
15517   float result;
15518
15519   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
15520   jresult = result;
15521   return jresult;
15522 }
15523
15524
15525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
15526   float jresult ;
15527   float result;
15528
15529   result = (float)(float)Dali::Math::PI;
15530   jresult = result;
15531   return jresult;
15532 }
15533
15534
15535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
15536   float jresult ;
15537   float result;
15538
15539   result = (float)(float)Dali::Math::PI_2;
15540   jresult = result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
15546   float jresult ;
15547   float result;
15548
15549   result = (float)(float)Dali::Math::PI_4;
15550   jresult = result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
15556   float jresult ;
15557   float result;
15558
15559   result = (float)(float)Dali::Math::PI_OVER_180;
15560   jresult = result;
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
15566   float jresult ;
15567   float result;
15568
15569   result = (float)(float)Dali::Math::ONE80_OVER_PI;
15570   jresult = result;
15571   return jresult;
15572 }
15573
15574
15575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
15576   int jresult ;
15577   Dali::ResizePolicy::Type result;
15578
15579   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
15580   jresult = (int)result;
15581   return jresult;
15582 }
15583
15584
15585 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
15586   unsigned long jresult ;
15587   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15588   Dali::VectorBase::SizeType result;
15589
15590   arg1 = (Dali::VectorBase *)jarg1;
15591   {
15592     try {
15593       result = ((Dali::VectorBase const *)arg1)->Count();
15594     } CALL_CATCH_EXCEPTION(0);
15595   }
15596
15597   jresult = (unsigned long)result;
15598   return jresult;
15599 }
15600
15601
15602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15603   unsigned long jresult ;
15604   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15605   Dali::VectorBase::SizeType result;
15606
15607   arg1 = (Dali::VectorBase *)jarg1;
15608   {
15609     try {
15610       result = ((Dali::VectorBase const *)arg1)->Size();
15611     } CALL_CATCH_EXCEPTION(0);
15612   }
15613
15614   jresult = (unsigned long)result;
15615   return jresult;
15616 }
15617
15618
15619 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15620   bool jresult ;
15621   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15622   bool result;
15623
15624   arg1 = (Dali::VectorBase *)jarg1;
15625   {
15626     try {
15627       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15628     } CALL_CATCH_EXCEPTION(0);
15629   }
15630
15631   jresult = result;
15632   return jresult;
15633 }
15634
15635
15636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15637   unsigned long jresult ;
15638   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15639   Dali::VectorBase::SizeType result;
15640
15641   arg1 = (Dali::VectorBase *)jarg1;
15642   {
15643     try {
15644       result = ((Dali::VectorBase const *)arg1)->Capacity();
15645     } CALL_CATCH_EXCEPTION(0);
15646   }
15647
15648   jresult = (unsigned long)result;
15649   return jresult;
15650 }
15651
15652
15653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15654   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15655
15656   arg1 = (Dali::VectorBase *)jarg1;
15657   {
15658     try {
15659       (arg1)->Release();
15660     } CALL_CATCH_EXCEPTION();
15661   }
15662
15663 }
15664
15665
15666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15667   int jresult ;
15668   Dali::Pixel::Format result;
15669
15670   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15671   jresult = (int)result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15677   int jresult ;
15678   Dali::Pixel::Format result;
15679
15680   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15681   jresult = (int)result;
15682   return jresult;
15683 }
15684
15685
15686 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15687   bool jresult ;
15688   Dali::Pixel::Format arg1 ;
15689   bool result;
15690
15691   arg1 = (Dali::Pixel::Format)jarg1;
15692   {
15693     try {
15694       result = (bool)Dali::Pixel::HasAlpha(arg1);
15695     } CALL_CATCH_EXCEPTION(0);
15696   }
15697
15698   jresult = result;
15699   return jresult;
15700 }
15701
15702
15703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15704   unsigned int jresult ;
15705   Dali::Pixel::Format arg1 ;
15706   unsigned int result;
15707
15708   arg1 = (Dali::Pixel::Format)jarg1;
15709   {
15710     try {
15711       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15712     } CALL_CATCH_EXCEPTION(0);
15713   }
15714
15715   jresult = result;
15716   return jresult;
15717 }
15718
15719
15720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15721   Dali::Pixel::Format arg1 ;
15722   int *arg2 = 0 ;
15723   int *arg3 = 0 ;
15724
15725   arg1 = (Dali::Pixel::Format)jarg1;
15726   arg2 = (int *)jarg2;
15727   if (!arg2) {
15728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15729     return ;
15730   }
15731   arg3 = (int *)jarg3;
15732   if (!arg3) {
15733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15734     return ;
15735   }
15736   {
15737     try {
15738       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15739     } CALL_CATCH_EXCEPTION();
15740   }
15741
15742 }
15743
15744
15745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
15746   void * jresult ;
15747   Dali::PixelData result;
15748
15749   {
15750     unsigned char* copiedBuffer;
15751     try
15752     {
15753       copiedBuffer = new unsigned char[nuiBufferSize];
15754     } CALL_CATCH_EXCEPTION(0);
15755
15756     try
15757     {
15758       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
15759       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
15760       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
15761     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
15762   }
15763
15764   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15765
15766   return jresult;
15767 }
15768
15769
15770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15771   void * jresult ;
15772   Dali::PixelData *result = 0 ;
15773
15774   {
15775     try {
15776       result = (Dali::PixelData *)new Dali::PixelData();
15777     } CALL_CATCH_EXCEPTION(0);
15778   }
15779
15780   jresult = (void *)result;
15781   return jresult;
15782 }
15783
15784
15785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
15786   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
15787
15788   pixelData = (Dali::PixelData *)nuiHandle;
15789   {
15790     try {
15791       delete pixelData;
15792     } CALL_CATCH_EXCEPTION();
15793   }
15794
15795 }
15796
15797
15798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
15799   void * jresult ;
15800   Dali::PixelData *pixelData = 0 ;
15801   Dali::PixelData *result = 0 ;
15802
15803   pixelData = (Dali::PixelData *)nuiHandle;
15804   if (!pixelData) {
15805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15806     return 0;
15807   }
15808   {
15809     try {
15810       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
15811     } CALL_CATCH_EXCEPTION(0);
15812   }
15813
15814   jresult = (void *)result;
15815   return jresult;
15816 }
15817
15818
15819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
15820   void * jresult ;
15821   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
15822   Dali::PixelData *pixelDataSource = 0 ;
15823   Dali::PixelData *result = 0 ;
15824
15825   pixelData = (Dali::PixelData *)nuiHandle;
15826   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
15827   if (!pixelDataSource) {
15828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15829     return 0;
15830   }
15831   {
15832     try {
15833       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
15834     } CALL_CATCH_EXCEPTION(0);
15835   }
15836
15837   jresult = (void *)result;
15838   return jresult;
15839 }
15840
15841
15842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
15843   unsigned int jresult ;
15844   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
15845   unsigned int result;
15846
15847   pixelData = (Dali::PixelData *)nuiHandle;
15848   {
15849     try {
15850       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
15851     } CALL_CATCH_EXCEPTION(0);
15852   }
15853
15854   jresult = result;
15855   return jresult;
15856 }
15857
15858
15859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
15860   unsigned int jresult ;
15861   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
15862   unsigned int result;
15863
15864   pixelData = (Dali::PixelData *)nuiHandle;
15865   {
15866     try {
15867       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
15868     } CALL_CATCH_EXCEPTION(0);
15869   }
15870
15871   jresult = result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
15877   int jresult ;
15878   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
15879   Dali::Pixel::Format result;
15880
15881   pixelData = (Dali::PixelData *)nuiHandle;
15882   {
15883     try {
15884       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
15885     } CALL_CATCH_EXCEPTION(0);
15886   }
15887
15888   jresult = (int)result;
15889   return jresult;
15890 }
15891
15892 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
15893 {
15894   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
15895   Dali::Toolkit::ImageUrl result;
15896   void *jresult;
15897
15898   if (!pixelData)
15899   {
15900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
15901     return 0;
15902   }
15903   {
15904     try
15905     {
15906       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
15907     } CALL_CATCH_EXCEPTION(0);
15908   }
15909
15910   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
15911   return jresult;
15912 }
15913
15914
15915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
15916   unsigned int jresult ;
15917   unsigned int result;
15918
15919   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
15920   jresult = result;
15921   return jresult;
15922 }
15923
15924
15925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
15926   unsigned int jresult ;
15927   unsigned int result;
15928
15929   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
15930   jresult = result;
15931   return jresult;
15932 }
15933
15934
15935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
15936   unsigned int jresult ;
15937   unsigned int result;
15938
15939   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
15940   jresult = result;
15941   return jresult;
15942 }
15943
15944
15945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
15946   unsigned int jresult ;
15947   unsigned int result;
15948
15949   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
15950   jresult = result;
15951   return jresult;
15952 }
15953
15954
15955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
15956   unsigned int jresult ;
15957   unsigned int result;
15958
15959   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
15960   jresult = result;
15961   return jresult;
15962 }
15963
15964
15965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
15966   unsigned int jresult ;
15967   unsigned int result;
15968
15969   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
15970   jresult = result;
15971   return jresult;
15972 }
15973
15974
15975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
15976   void * jresult ;
15977   Dali::TextureType::Type arg1 ;
15978   Dali::Pixel::Format arg2 ;
15979   unsigned int arg3 ;
15980   unsigned int arg4 ;
15981   Dali::Texture result;
15982
15983   arg1 = (Dali::TextureType::Type)jarg1;
15984   arg2 = (Dali::Pixel::Format)jarg2;
15985   arg3 = (unsigned int)jarg3;
15986   arg4 = (unsigned int)jarg4;
15987   {
15988     try {
15989       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
15990     } CALL_CATCH_EXCEPTION(0);
15991   }
15992
15993   jresult = new Dali::Texture((const Dali::Texture &)result);
15994   return jresult;
15995 }
15996
15997
15998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
15999   void * jresult ;
16000   NativeImageInterface *arg1 = 0 ;
16001   Dali::Texture result;
16002
16003   arg1 = (NativeImageInterface *)jarg1;
16004   if (!arg1) {
16005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
16006     return 0;
16007   }
16008   {
16009     try {
16010       result = Dali::Texture::New(*arg1);
16011     } CALL_CATCH_EXCEPTION(0);
16012   }
16013
16014   jresult = new Dali::Texture((const Dali::Texture &)result);
16015   return jresult;
16016 }
16017
16018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
16019   void * jresult ;
16020   Dali::Texture *result = 0 ;
16021
16022   {
16023     try {
16024       result = (Dali::Texture *)new Dali::Texture();
16025     } CALL_CATCH_EXCEPTION(0);
16026   }
16027
16028   jresult = (void *)result;
16029   return jresult;
16030 }
16031
16032
16033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
16034   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16035
16036   arg1 = (Dali::Texture *)jarg1;
16037   {
16038     try {
16039       delete arg1;
16040     } CALL_CATCH_EXCEPTION();
16041   }
16042
16043 }
16044
16045
16046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
16047   void * jresult ;
16048   Dali::Texture *arg1 = 0 ;
16049   Dali::Texture *result = 0 ;
16050
16051   arg1 = (Dali::Texture *)jarg1;
16052   if (!arg1) {
16053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16054     return 0;
16055   }
16056   {
16057     try {
16058       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
16059     } CALL_CATCH_EXCEPTION(0);
16060   }
16061
16062   jresult = (void *)result;
16063   return jresult;
16064 }
16065
16066
16067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
16068   void * jresult ;
16069   Dali::BaseHandle arg1 ;
16070   Dali::BaseHandle *argp1 ;
16071   Dali::Texture result;
16072
16073   argp1 = (Dali::BaseHandle *)jarg1;
16074   if (!argp1) {
16075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16076     return 0;
16077   }
16078   arg1 = *argp1;
16079   {
16080     try {
16081       result = Dali::Texture::DownCast(arg1);
16082     } CALL_CATCH_EXCEPTION(0);
16083   }
16084
16085   jresult = new Dali::Texture((const Dali::Texture &)result);
16086   return jresult;
16087 }
16088
16089
16090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
16091   void * jresult ;
16092   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16093   Dali::Texture *arg2 = 0 ;
16094   Dali::Texture *result = 0 ;
16095
16096   arg1 = (Dali::Texture *)jarg1;
16097   arg2 = (Dali::Texture *)jarg2;
16098   if (!arg2) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
16105     } CALL_CATCH_EXCEPTION(0);
16106   }
16107
16108   jresult = (void *)result;
16109   return jresult;
16110 }
16111
16112
16113 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
16114   bool jresult ;
16115   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16116   Dali::PixelData arg2 ;
16117   Dali::PixelData *argp2 ;
16118   bool result;
16119
16120   arg1 = (Dali::Texture *)jarg1;
16121   argp2 = (Dali::PixelData *)jarg2;
16122   if (!argp2) {
16123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16124     return 0;
16125   }
16126   arg2 = *argp2;
16127   {
16128     try {
16129       result = (bool)(arg1)->Upload(arg2);
16130     } CALL_CATCH_EXCEPTION(0);
16131   }
16132
16133   jresult = result;
16134   return jresult;
16135 }
16136
16137
16138 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) {
16139   bool jresult ;
16140   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16141   Dali::PixelData arg2 ;
16142   unsigned int arg3 ;
16143   unsigned int arg4 ;
16144   unsigned int arg5 ;
16145   unsigned int arg6 ;
16146   unsigned int arg7 ;
16147   unsigned int arg8 ;
16148   Dali::PixelData *argp2 ;
16149   bool result;
16150
16151   arg1 = (Dali::Texture *)jarg1;
16152   argp2 = (Dali::PixelData *)jarg2;
16153   if (!argp2) {
16154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
16155     return 0;
16156   }
16157   arg2 = *argp2;
16158   arg3 = (unsigned int)jarg3;
16159   arg4 = (unsigned int)jarg4;
16160   arg5 = (unsigned int)jarg5;
16161   arg6 = (unsigned int)jarg6;
16162   arg7 = (unsigned int)jarg7;
16163   arg8 = (unsigned int)jarg8;
16164   {
16165     try {
16166       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16167     } CALL_CATCH_EXCEPTION(0);
16168   }
16169
16170   jresult = result;
16171   return jresult;
16172 }
16173
16174
16175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
16176   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16177
16178   arg1 = (Dali::Texture *)jarg1;
16179   {
16180     try {
16181       (arg1)->GenerateMipmaps();
16182     } CALL_CATCH_EXCEPTION();
16183   }
16184
16185 }
16186
16187
16188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
16189   unsigned int jresult ;
16190   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16191   unsigned int result;
16192
16193   arg1 = (Dali::Texture *)jarg1;
16194   {
16195     try {
16196       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
16197     } CALL_CATCH_EXCEPTION(0);
16198   }
16199
16200   jresult = result;
16201   return jresult;
16202 }
16203
16204
16205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
16206   unsigned int jresult ;
16207   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
16208   unsigned int result;
16209
16210   arg1 = (Dali::Texture *)jarg1;
16211   {
16212     try {
16213       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
16214     } CALL_CATCH_EXCEPTION(0);
16215   }
16216
16217   jresult = result;
16218   return jresult;
16219 }
16220
16221
16222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
16223   void * jresult ;
16224   Dali::Sampler result;
16225
16226   {
16227     try {
16228       result = Dali::Sampler::New();
16229     } CALL_CATCH_EXCEPTION(0);
16230   }
16231
16232   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16233   return jresult;
16234 }
16235
16236
16237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
16238   void * jresult ;
16239   Dali::Sampler *result = 0 ;
16240
16241   {
16242     try {
16243       result = (Dali::Sampler *)new Dali::Sampler();
16244     } CALL_CATCH_EXCEPTION(0);
16245   }
16246
16247   jresult = (void *)result;
16248   return jresult;
16249 }
16250
16251
16252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
16253   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16254
16255   arg1 = (Dali::Sampler *)jarg1;
16256   {
16257     try {
16258       delete arg1;
16259     } CALL_CATCH_EXCEPTION();
16260   }
16261
16262 }
16263
16264
16265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
16266   void * jresult ;
16267   Dali::Sampler *arg1 = 0 ;
16268   Dali::Sampler *result = 0 ;
16269
16270   arg1 = (Dali::Sampler *)jarg1;
16271   if (!arg1) {
16272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16273     return 0;
16274   }
16275   {
16276     try {
16277       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
16278     } CALL_CATCH_EXCEPTION(0);
16279   }
16280
16281   jresult = (void *)result;
16282   return jresult;
16283 }
16284
16285
16286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
16287   void * jresult ;
16288   Dali::BaseHandle arg1 ;
16289   Dali::BaseHandle *argp1 ;
16290   Dali::Sampler result;
16291
16292   argp1 = (Dali::BaseHandle *)jarg1;
16293   if (!argp1) {
16294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16295     return 0;
16296   }
16297   arg1 = *argp1;
16298   {
16299     try {
16300       result = Dali::Sampler::DownCast(arg1);
16301     } CALL_CATCH_EXCEPTION(0);
16302   }
16303
16304   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16305   return jresult;
16306 }
16307
16308
16309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
16310   void * jresult ;
16311   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16312   Dali::Sampler *arg2 = 0 ;
16313   Dali::Sampler *result = 0 ;
16314
16315   arg1 = (Dali::Sampler *)jarg1;
16316   arg2 = (Dali::Sampler *)jarg2;
16317   if (!arg2) {
16318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
16319     return 0;
16320   }
16321   {
16322     try {
16323       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
16324     } CALL_CATCH_EXCEPTION(0);
16325   }
16326
16327   jresult = (void *)result;
16328   return jresult;
16329 }
16330
16331
16332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
16333   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16334   Dali::FilterMode::Type arg2 ;
16335   Dali::FilterMode::Type arg3 ;
16336
16337   arg1 = (Dali::Sampler *)jarg1;
16338   arg2 = (Dali::FilterMode::Type)jarg2;
16339   arg3 = (Dali::FilterMode::Type)jarg3;
16340   {
16341     try {
16342       (arg1)->SetFilterMode(arg2,arg3);
16343     } CALL_CATCH_EXCEPTION();
16344   }
16345
16346 }
16347
16348
16349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
16350   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16351   Dali::WrapMode::Type arg2 ;
16352   Dali::WrapMode::Type arg3 ;
16353
16354   arg1 = (Dali::Sampler *)jarg1;
16355   arg2 = (Dali::WrapMode::Type)jarg2;
16356   arg3 = (Dali::WrapMode::Type)jarg3;
16357   {
16358     try {
16359       (arg1)->SetWrapMode(arg2,arg3);
16360     } CALL_CATCH_EXCEPTION();
16361   }
16362
16363 }
16364
16365
16366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
16367   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
16368   Dali::WrapMode::Type arg2 ;
16369   Dali::WrapMode::Type arg3 ;
16370   Dali::WrapMode::Type arg4 ;
16371
16372   arg1 = (Dali::Sampler *)jarg1;
16373   arg2 = (Dali::WrapMode::Type)jarg2;
16374   arg3 = (Dali::WrapMode::Type)jarg3;
16375   arg4 = (Dali::WrapMode::Type)jarg4;
16376   {
16377     try {
16378       (arg1)->SetWrapMode(arg2,arg3,arg4);
16379     } CALL_CATCH_EXCEPTION();
16380   }
16381
16382 }
16383
16384
16385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
16386   void * jresult ;
16387   Dali::TextureSet result;
16388
16389   {
16390     try {
16391       result = Dali::TextureSet::New();
16392     } CALL_CATCH_EXCEPTION(0);
16393   }
16394
16395   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16396   return jresult;
16397 }
16398
16399
16400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
16401   void * jresult ;
16402   Dali::TextureSet *result = 0 ;
16403
16404   {
16405     try {
16406       result = (Dali::TextureSet *)new Dali::TextureSet();
16407     } CALL_CATCH_EXCEPTION(0);
16408   }
16409
16410   jresult = (void *)result;
16411   return jresult;
16412 }
16413
16414
16415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
16416   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16417
16418   arg1 = (Dali::TextureSet *)jarg1;
16419   {
16420     try {
16421       delete arg1;
16422     } CALL_CATCH_EXCEPTION();
16423   }
16424
16425 }
16426
16427
16428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
16429   void * jresult ;
16430   Dali::TextureSet *arg1 = 0 ;
16431   Dali::TextureSet *result = 0 ;
16432
16433   arg1 = (Dali::TextureSet *)jarg1;
16434   if (!arg1) {
16435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16436     return 0;
16437   }
16438   {
16439     try {
16440       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
16441     } CALL_CATCH_EXCEPTION(0);
16442   }
16443
16444   jresult = (void *)result;
16445   return jresult;
16446 }
16447
16448
16449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
16450   void * jresult ;
16451   Dali::BaseHandle arg1 ;
16452   Dali::BaseHandle *argp1 ;
16453   Dali::TextureSet result;
16454
16455   argp1 = (Dali::BaseHandle *)jarg1;
16456   if (!argp1) {
16457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16458     return 0;
16459   }
16460   arg1 = *argp1;
16461   {
16462     try {
16463       result = Dali::TextureSet::DownCast(arg1);
16464     } CALL_CATCH_EXCEPTION(0);
16465   }
16466
16467   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
16468   return jresult;
16469 }
16470
16471
16472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
16473   void * jresult ;
16474   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16475   Dali::TextureSet *arg2 = 0 ;
16476   Dali::TextureSet *result = 0 ;
16477
16478   arg1 = (Dali::TextureSet *)jarg1;
16479   arg2 = (Dali::TextureSet *)jarg2;
16480   if (!arg2) {
16481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
16482     return 0;
16483   }
16484   {
16485     try {
16486       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
16487     } CALL_CATCH_EXCEPTION(0);
16488   }
16489
16490   jresult = (void *)result;
16491   return jresult;
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
16496   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16497   size_t arg2 ;
16498   Dali::Texture arg3 ;
16499   Dali::Texture *argp3 ;
16500
16501   arg1 = (Dali::TextureSet *)jarg1;
16502   arg2 = (size_t)jarg2;
16503   argp3 = (Dali::Texture *)jarg3;
16504   if (!argp3) {
16505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
16506     return ;
16507   }
16508   arg3 = *argp3;
16509   {
16510     try {
16511       (arg1)->SetTexture(arg2,arg3);
16512     } CALL_CATCH_EXCEPTION();
16513   }
16514
16515 }
16516
16517
16518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
16519   void * jresult ;
16520   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16521   size_t arg2 ;
16522   Dali::Texture result;
16523
16524   arg1 = (Dali::TextureSet *)jarg1;
16525   arg2 = (size_t)jarg2;
16526   {
16527     try {
16528       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
16529     } CALL_CATCH_EXCEPTION(0);
16530   }
16531
16532   jresult = new Dali::Texture((const Dali::Texture &)result);
16533   return jresult;
16534 }
16535
16536
16537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
16538   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16539   size_t arg2 ;
16540   Dali::Sampler arg3 ;
16541   Dali::Sampler *argp3 ;
16542
16543   arg1 = (Dali::TextureSet *)jarg1;
16544   arg2 = (size_t)jarg2;
16545   argp3 = (Dali::Sampler *)jarg3;
16546   if (!argp3) {
16547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
16548     return ;
16549   }
16550   arg3 = *argp3;
16551   {
16552     try {
16553       (arg1)->SetSampler(arg2,arg3);
16554     } CALL_CATCH_EXCEPTION();
16555   }
16556
16557 }
16558
16559
16560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
16561   void * jresult ;
16562   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16563   size_t arg2 ;
16564   Dali::Sampler result;
16565
16566   arg1 = (Dali::TextureSet *)jarg1;
16567   arg2 = (size_t)jarg2;
16568   {
16569     try {
16570       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
16571     } CALL_CATCH_EXCEPTION(0);
16572   }
16573
16574   jresult = new Dali::Sampler((const Dali::Sampler &)result);
16575   return jresult;
16576 }
16577
16578
16579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
16580   unsigned long jresult ;
16581   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
16582   size_t result;
16583
16584   arg1 = (Dali::TextureSet *)jarg1;
16585   {
16586     try {
16587       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
16588     } CALL_CATCH_EXCEPTION(0);
16589   }
16590
16591   jresult = (unsigned long)result;
16592   return jresult;
16593 }
16594
16595
16596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
16597   void * jresult ;
16598   Dali::Property::Map *arg1 = 0 ;
16599   Dali::VertexBuffer result;
16600
16601   arg1 = (Dali::Property::Map *)jarg1;
16602   if (!arg1) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
16604     return 0;
16605   }
16606   {
16607     try {
16608       result = Dali::VertexBuffer::New(*arg1);
16609     } CALL_CATCH_EXCEPTION(0);
16610   }
16611
16612   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16613   return jresult;
16614 }
16615
16616
16617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16618   void * jresult ;
16619   Dali::VertexBuffer *result = 0 ;
16620
16621   {
16622     try {
16623       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16624     } CALL_CATCH_EXCEPTION(0);
16625   }
16626
16627   jresult = (void *)result;
16628   return jresult;
16629 }
16630
16631
16632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16633   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16634
16635   arg1 = (Dali::VertexBuffer *)jarg1;
16636   {
16637     try {
16638       delete arg1;
16639     } CALL_CATCH_EXCEPTION();
16640   }
16641
16642 }
16643
16644
16645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16646   void * jresult ;
16647   Dali::VertexBuffer *arg1 = 0 ;
16648   Dali::VertexBuffer *result = 0 ;
16649
16650   arg1 = (Dali::VertexBuffer *)jarg1;
16651   if (!arg1) {
16652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16653     return 0;
16654   }
16655   {
16656     try {
16657       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16658     } CALL_CATCH_EXCEPTION(0);
16659   }
16660
16661   jresult = (void *)result;
16662   return jresult;
16663 }
16664
16665
16666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16667   void * jresult ;
16668   Dali::BaseHandle arg1 ;
16669   Dali::BaseHandle *argp1 ;
16670   Dali::VertexBuffer result;
16671
16672   argp1 = (Dali::BaseHandle *)jarg1;
16673   if (!argp1) {
16674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16675     return 0;
16676   }
16677   arg1 = *argp1;
16678   {
16679     try {
16680       result = Dali::VertexBuffer::DownCast(arg1);
16681     } CALL_CATCH_EXCEPTION(0);
16682   }
16683
16684   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16685   return jresult;
16686 }
16687
16688
16689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16690   void * jresult ;
16691   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16692   Dali::VertexBuffer *arg2 = 0 ;
16693   Dali::VertexBuffer *result = 0 ;
16694
16695   arg1 = (Dali::VertexBuffer *)jarg1;
16696   arg2 = (Dali::VertexBuffer *)jarg2;
16697   if (!arg2) {
16698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16699     return 0;
16700   }
16701   {
16702     try {
16703       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16704     } CALL_CATCH_EXCEPTION(0);
16705   }
16706
16707   jresult = (void *)result;
16708   return jresult;
16709 }
16710
16711
16712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16713   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16714   void *arg2 = (void *) 0 ;
16715   std::size_t arg3 ;
16716
16717   arg1 = (Dali::VertexBuffer *)jarg1;
16718   arg2 = jarg2;
16719   arg3 = (std::size_t)jarg3;
16720   {
16721     try {
16722       (arg1)->SetData((void const *)arg2,arg3);
16723     } CALL_CATCH_EXCEPTION();
16724   }
16725
16726 }
16727
16728
16729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16730   unsigned long jresult ;
16731   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16732   std::size_t result;
16733
16734   arg1 = (Dali::VertexBuffer *)jarg1;
16735   {
16736     try {
16737       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16738     } CALL_CATCH_EXCEPTION(0);
16739   }
16740
16741   jresult = (unsigned long)result;
16742   return jresult;
16743 }
16744
16745
16746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16747   void * jresult ;
16748   Dali::Geometry result;
16749
16750   {
16751     try {
16752       result = Dali::Geometry::New();
16753     } CALL_CATCH_EXCEPTION(0);
16754   }
16755
16756   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16757   return jresult;
16758 }
16759
16760
16761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16762   void * jresult ;
16763   Dali::Geometry *result = 0 ;
16764
16765   {
16766     try {
16767       result = (Dali::Geometry *)new Dali::Geometry();
16768     } CALL_CATCH_EXCEPTION(0);
16769   }
16770
16771   jresult = (void *)result;
16772   return jresult;
16773 }
16774
16775
16776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16777   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16778
16779   arg1 = (Dali::Geometry *)jarg1;
16780   {
16781     try {
16782       delete arg1;
16783     } CALL_CATCH_EXCEPTION();
16784   }
16785
16786 }
16787
16788
16789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
16790   void * jresult ;
16791   Dali::Geometry *arg1 = 0 ;
16792   Dali::Geometry *result = 0 ;
16793
16794   arg1 = (Dali::Geometry *)jarg1;
16795   if (!arg1) {
16796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16797     return 0;
16798   }
16799   {
16800     try {
16801       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
16802     } CALL_CATCH_EXCEPTION(0);
16803   }
16804
16805   jresult = (void *)result;
16806   return jresult;
16807 }
16808
16809
16810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
16811   void * jresult ;
16812   Dali::BaseHandle arg1 ;
16813   Dali::BaseHandle *argp1 ;
16814   Dali::Geometry result;
16815
16816   argp1 = (Dali::BaseHandle *)jarg1;
16817   if (!argp1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16819     return 0;
16820   }
16821   arg1 = *argp1;
16822   {
16823     try {
16824       result = Dali::Geometry::DownCast(arg1);
16825     } CALL_CATCH_EXCEPTION(0);
16826   }
16827
16828   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16829   return jresult;
16830 }
16831
16832
16833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
16834   void * jresult ;
16835   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16836   Dali::Geometry *arg2 = 0 ;
16837   Dali::Geometry *result = 0 ;
16838
16839   arg1 = (Dali::Geometry *)jarg1;
16840   arg2 = (Dali::Geometry *)jarg2;
16841   if (!arg2) {
16842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16843     return 0;
16844   }
16845   {
16846     try {
16847       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
16848     } CALL_CATCH_EXCEPTION(0);
16849   }
16850
16851   jresult = (void *)result;
16852   return jresult;
16853 }
16854
16855
16856 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
16857   unsigned long jresult ;
16858   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16859   Dali::VertexBuffer *arg2 = 0 ;
16860   std::size_t result;
16861
16862   arg1 = (Dali::Geometry *)jarg1;
16863   arg2 = (Dali::VertexBuffer *)jarg2;
16864   if (!arg2) {
16865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
16866     return 0;
16867   }
16868   {
16869     try {
16870       result = (arg1)->AddVertexBuffer(*arg2);
16871     } CALL_CATCH_EXCEPTION(0);
16872   }
16873
16874   jresult = (unsigned long)result;
16875   return jresult;
16876 }
16877
16878
16879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
16880   unsigned long jresult ;
16881   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16882   std::size_t result;
16883
16884   arg1 = (Dali::Geometry *)jarg1;
16885   {
16886     try {
16887       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
16888     } CALL_CATCH_EXCEPTION(0);
16889   }
16890
16891   jresult = (unsigned long)result;
16892   return jresult;
16893 }
16894
16895
16896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
16897   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16898   std::size_t arg2 ;
16899
16900   arg1 = (Dali::Geometry *)jarg1;
16901   arg2 = (std::size_t)jarg2;
16902   {
16903     try {
16904       (arg1)->RemoveVertexBuffer(arg2);
16905     } CALL_CATCH_EXCEPTION();
16906   }
16907
16908 }
16909
16910
16911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
16912   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16913   unsigned short *arg2 = (unsigned short *) 0 ;
16914   size_t arg3 ;
16915
16916   arg1 = (Dali::Geometry *)jarg1;
16917   arg2 = jarg2;
16918   arg3 = (size_t)jarg3;
16919   {
16920     try {
16921       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
16922     } CALL_CATCH_EXCEPTION();
16923   }
16924
16925
16926
16927 }
16928
16929
16930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
16931   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16932   Dali::Geometry::Type arg2 ;
16933
16934   arg1 = (Dali::Geometry *)jarg1;
16935   arg2 = (Dali::Geometry::Type)jarg2;
16936   {
16937     try {
16938       (arg1)->SetType(arg2);
16939     } CALL_CATCH_EXCEPTION();
16940   }
16941
16942 }
16943
16944
16945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
16946   int jresult ;
16947   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16948   Dali::Geometry::Type result;
16949
16950   arg1 = (Dali::Geometry *)jarg1;
16951   {
16952     try {
16953       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
16954     } CALL_CATCH_EXCEPTION(0);
16955   }
16956
16957   jresult = (int)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
16963   void * jresult ;
16964   Dali::Shader::Hint *result = 0 ;
16965
16966   {
16967     try {
16968       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
16969     } CALL_CATCH_EXCEPTION(0);
16970   }
16971
16972   jresult = (void *)result;
16973   return jresult;
16974 }
16975
16976
16977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
16978   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
16979
16980   arg1 = (Dali::Shader::Hint *)jarg1;
16981   {
16982     try {
16983       delete arg1;
16984     } CALL_CATCH_EXCEPTION();
16985   }
16986
16987 }
16988
16989
16990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
16991   int jresult ;
16992   int result;
16993
16994   result = (int)Dali::Shader::Property::PROGRAM;
16995   jresult = (int)result;
16996   return jresult;
16997 }
16998
16999
17000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
17001   void * jresult ;
17002   Dali::Shader::Property *result = 0 ;
17003
17004   {
17005     try {
17006       result = (Dali::Shader::Property *)new Dali::Shader::Property();
17007     } CALL_CATCH_EXCEPTION(0);
17008   }
17009
17010   jresult = (void *)result;
17011   return jresult;
17012 }
17013
17014
17015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
17016   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
17017
17018   arg1 = (Dali::Shader::Property *)jarg1;
17019   {
17020     try {
17021       delete arg1;
17022     } CALL_CATCH_EXCEPTION();
17023   }
17024
17025 }
17026
17027
17028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
17029   void * jresult ;
17030   std::string *arg1 = 0 ;
17031   std::string *arg2 = 0 ;
17032   Dali::Shader::Hint::Value arg3 ;
17033   Dali::Shader result;
17034
17035   if (!jarg1) {
17036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17037     return 0;
17038   }
17039   std::string arg1_str(jarg1);
17040   arg1 = &arg1_str;
17041   if (!jarg2) {
17042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17043     return 0;
17044   }
17045   std::string arg2_str(jarg2);
17046   arg2 = &arg2_str;
17047   arg3 = (Dali::Shader::Hint::Value)jarg3;
17048   {
17049     try {
17050       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
17051     } CALL_CATCH_EXCEPTION(0);
17052   }
17053
17054   jresult = new Dali::Shader((const Dali::Shader &)result);
17055
17056   //argout typemap for const std::string&
17057
17058
17059   //argout typemap for const std::string&
17060
17061   return jresult;
17062 }
17063
17064
17065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
17066   void * jresult ;
17067   std::string *arg1 = 0 ;
17068   std::string *arg2 = 0 ;
17069   Dali::Shader result;
17070
17071   if (!jarg1) {
17072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17073     return 0;
17074   }
17075   std::string arg1_str(jarg1);
17076   arg1 = &arg1_str;
17077   if (!jarg2) {
17078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17079     return 0;
17080   }
17081   std::string arg2_str(jarg2);
17082   arg2 = &arg2_str;
17083   {
17084     try {
17085       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
17086     } CALL_CATCH_EXCEPTION(0);
17087   }
17088
17089   jresult = new Dali::Shader((const Dali::Shader &)result);
17090
17091   //argout typemap for const std::string&
17092
17093
17094   //argout typemap for const std::string&
17095
17096   return jresult;
17097 }
17098
17099
17100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
17101   void * jresult ;
17102   Dali::Shader *result = 0 ;
17103
17104   {
17105     try {
17106       result = (Dali::Shader *)new Dali::Shader();
17107     } CALL_CATCH_EXCEPTION(0);
17108   }
17109
17110   jresult = (void *)result;
17111   return jresult;
17112 }
17113
17114
17115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
17116   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17117
17118   arg1 = (Dali::Shader *)jarg1;
17119   {
17120     try {
17121       delete arg1;
17122     } CALL_CATCH_EXCEPTION();
17123   }
17124
17125 }
17126
17127
17128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
17129   void * jresult ;
17130   Dali::Shader *arg1 = 0 ;
17131   Dali::Shader *result = 0 ;
17132
17133   arg1 = (Dali::Shader *)jarg1;
17134   if (!arg1) {
17135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17136     return 0;
17137   }
17138   {
17139     try {
17140       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
17141     } CALL_CATCH_EXCEPTION(0);
17142   }
17143
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
17150   void * jresult ;
17151   Dali::BaseHandle arg1 ;
17152   Dali::BaseHandle *argp1 ;
17153   Dali::Shader result;
17154
17155   argp1 = (Dali::BaseHandle *)jarg1;
17156   if (!argp1) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17158     return 0;
17159   }
17160   arg1 = *argp1;
17161   {
17162     try {
17163       result = Dali::Shader::DownCast(arg1);
17164     } CALL_CATCH_EXCEPTION(0);
17165   }
17166
17167   jresult = new Dali::Shader((const Dali::Shader &)result);
17168   return jresult;
17169 }
17170
17171
17172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
17173   void * jresult ;
17174   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
17175   Dali::Shader *arg2 = 0 ;
17176   Dali::Shader *result = 0 ;
17177
17178   arg1 = (Dali::Shader *)jarg1;
17179   arg2 = (Dali::Shader *)jarg2;
17180   if (!arg2) {
17181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
17182     return 0;
17183   }
17184   {
17185     try {
17186       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
17187     } CALL_CATCH_EXCEPTION(0);
17188   }
17189
17190   jresult = (void *)result;
17191   return jresult;
17192 }
17193
17194
17195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
17196   int jresult ;
17197   int result;
17198
17199   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
17200   jresult = (int)result;
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
17206   int jresult ;
17207   int result;
17208
17209   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
17210   jresult = (int)result;
17211   return jresult;
17212 }
17213
17214
17215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
17216   int jresult ;
17217   int result;
17218
17219   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
17220   jresult = (int)result;
17221   return jresult;
17222 }
17223
17224
17225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
17226   int jresult ;
17227   int result;
17228
17229   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
17230   jresult = (int)result;
17231   return jresult;
17232 }
17233
17234
17235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
17236   int jresult ;
17237   int result;
17238
17239   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
17240   jresult = (int)result;
17241   return jresult;
17242 }
17243
17244
17245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
17246   int jresult ;
17247   int result;
17248
17249   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
17250   jresult = (int)result;
17251   return jresult;
17252 }
17253
17254
17255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
17256   int jresult ;
17257   int result;
17258
17259   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
17260   jresult = (int)result;
17261   return jresult;
17262 }
17263
17264
17265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
17266   int jresult ;
17267   int result;
17268
17269   result = (int)Dali::Renderer::Property::BLEND_MODE;
17270   jresult = (int)result;
17271   return jresult;
17272 }
17273
17274
17275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
17276   int jresult ;
17277   int result;
17278
17279   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
17280   jresult = (int)result;
17281   return jresult;
17282 }
17283
17284
17285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
17286   int jresult ;
17287   int result;
17288
17289   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
17290   jresult = (int)result;
17291   return jresult;
17292 }
17293
17294
17295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
17296   int jresult ;
17297   int result;
17298
17299   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
17300   jresult = (int)result;
17301   return jresult;
17302 }
17303
17304
17305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
17306   int jresult ;
17307   int result;
17308
17309   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
17310   jresult = (int)result;
17311   return jresult;
17312 }
17313
17314
17315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
17316   int jresult ;
17317   int result;
17318
17319   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
17320   jresult = (int)result;
17321   return jresult;
17322 }
17323
17324
17325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
17326   int jresult ;
17327   int result;
17328
17329   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
17330   jresult = (int)result;
17331   return jresult;
17332 }
17333
17334
17335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
17336   int jresult ;
17337   int result;
17338
17339   result = (int)Dali::Renderer::Property::BLEND_COLOR;
17340   jresult = (int)result;
17341   return jresult;
17342 }
17343
17344
17345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
17346   int jresult ;
17347   int result;
17348
17349   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
17350   jresult = (int)result;
17351   return jresult;
17352 }
17353
17354
17355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
17356   int jresult ;
17357   int result;
17358
17359   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
17360   jresult = (int)result;
17361   return jresult;
17362 }
17363
17364
17365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
17366   int jresult ;
17367   int result;
17368
17369   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
17370   jresult = (int)result;
17371   return jresult;
17372 }
17373
17374
17375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
17376   int jresult ;
17377   int result;
17378
17379   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
17380   jresult = (int)result;
17381   return jresult;
17382 }
17383
17384
17385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
17386   int jresult ;
17387   int result;
17388
17389   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
17390   jresult = (int)result;
17391   return jresult;
17392 }
17393
17394
17395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
17396   int jresult ;
17397   int result;
17398
17399   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
17400   jresult = (int)result;
17401   return jresult;
17402 }
17403
17404
17405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
17406   int jresult ;
17407   int result;
17408
17409   result = (int)Dali::Renderer::Property::RENDER_MODE;
17410   jresult = (int)result;
17411   return jresult;
17412 }
17413
17414
17415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
17416   int jresult ;
17417   int result;
17418
17419   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
17420   jresult = (int)result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
17426   int jresult ;
17427   int result;
17428
17429   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
17430   jresult = (int)result;
17431   return jresult;
17432 }
17433
17434
17435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
17436   int jresult ;
17437   int result;
17438
17439   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
17440   jresult = (int)result;
17441   return jresult;
17442 }
17443
17444
17445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
17446   int jresult ;
17447   int result;
17448
17449   result = (int)Dali::Renderer::Property::STENCIL_MASK;
17450   jresult = (int)result;
17451   return jresult;
17452 }
17453
17454
17455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
17456   int jresult ;
17457   int result;
17458
17459   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
17460   jresult = (int)result;
17461   return jresult;
17462 }
17463
17464
17465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
17466   int jresult ;
17467   int result;
17468
17469   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
17470   jresult = (int)result;
17471   return jresult;
17472 }
17473
17474
17475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
17476   int jresult ;
17477   int result;
17478
17479   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
17480   jresult = (int)result;
17481   return jresult;
17482 }
17483
17484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() {
17485   return Dali::Actor::Property::CULLED;
17486 }
17487
17488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
17489   void * jresult ;
17490   Dali::Renderer::Property *result = 0 ;
17491
17492   {
17493     try {
17494       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
17495     } CALL_CATCH_EXCEPTION(0);
17496   }
17497
17498   jresult = (void *)result;
17499   return jresult;
17500 }
17501
17502
17503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
17504   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
17505
17506   arg1 = (Dali::Renderer::Property *)jarg1;
17507   {
17508     try {
17509       delete arg1;
17510     } CALL_CATCH_EXCEPTION();
17511   }
17512
17513 }
17514
17515
17516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
17517   void * jresult ;
17518   Dali::Geometry *arg1 = 0 ;
17519   Dali::Shader *arg2 = 0 ;
17520   Dali::Renderer result;
17521
17522   arg1 = (Dali::Geometry *)jarg1;
17523   if (!arg1) {
17524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17525     return 0;
17526   }
17527   arg2 = (Dali::Shader *)jarg2;
17528   if (!arg2) {
17529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17530     return 0;
17531   }
17532   {
17533     try {
17534       result = Dali::Renderer::New(*arg1,*arg2);
17535     } CALL_CATCH_EXCEPTION(0);
17536   }
17537
17538   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17539   return jresult;
17540 }
17541
17542
17543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
17544   void * jresult ;
17545   Dali::Renderer *result = 0 ;
17546
17547   {
17548     try {
17549       result = (Dali::Renderer *)new Dali::Renderer();
17550     } CALL_CATCH_EXCEPTION(0);
17551   }
17552
17553   jresult = (void *)result;
17554   return jresult;
17555 }
17556
17557
17558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
17559   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17560
17561   arg1 = (Dali::Renderer *)jarg1;
17562   {
17563     try {
17564       delete arg1;
17565     } CALL_CATCH_EXCEPTION();
17566   }
17567
17568 }
17569
17570
17571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
17572   void * jresult ;
17573   Dali::Renderer *arg1 = 0 ;
17574   Dali::Renderer *result = 0 ;
17575
17576   arg1 = (Dali::Renderer *)jarg1;
17577   if (!arg1) {
17578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17579     return 0;
17580   }
17581   {
17582     try {
17583       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
17584     } CALL_CATCH_EXCEPTION(0);
17585   }
17586
17587   jresult = (void *)result;
17588   return jresult;
17589 }
17590
17591
17592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
17593   void * jresult ;
17594   Dali::BaseHandle arg1 ;
17595   Dali::BaseHandle *argp1 ;
17596   Dali::Renderer result;
17597
17598   argp1 = (Dali::BaseHandle *)jarg1;
17599   if (!argp1) {
17600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17601     return 0;
17602   }
17603   arg1 = *argp1;
17604   {
17605     try {
17606       result = Dali::Renderer::DownCast(arg1);
17607     } CALL_CATCH_EXCEPTION(0);
17608   }
17609
17610   jresult = new Dali::Renderer((const Dali::Renderer &)result);
17611   return jresult;
17612 }
17613
17614
17615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17616   void * jresult ;
17617   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17618   Dali::Renderer *arg2 = 0 ;
17619   Dali::Renderer *result = 0 ;
17620
17621   arg1 = (Dali::Renderer *)jarg1;
17622   arg2 = (Dali::Renderer *)jarg2;
17623   if (!arg2) {
17624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17625     return 0;
17626   }
17627   {
17628     try {
17629       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17630     } CALL_CATCH_EXCEPTION(0);
17631   }
17632
17633   jresult = (void *)result;
17634   return jresult;
17635 }
17636
17637
17638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17639   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17640   Dali::Geometry *arg2 = 0 ;
17641
17642   arg1 = (Dali::Renderer *)jarg1;
17643   arg2 = (Dali::Geometry *)jarg2;
17644   if (!arg2) {
17645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17646     return ;
17647   }
17648   {
17649     try {
17650       (arg1)->SetGeometry(*arg2);
17651     } CALL_CATCH_EXCEPTION();
17652   }
17653
17654 }
17655
17656
17657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17658   void * jresult ;
17659   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17660   Dali::Geometry result;
17661
17662   arg1 = (Dali::Renderer *)jarg1;
17663   {
17664     try {
17665       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17666     } CALL_CATCH_EXCEPTION(0);
17667   }
17668
17669   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17670   return jresult;
17671 }
17672
17673
17674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17675   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17676   int arg2 ;
17677   int arg3 ;
17678
17679   arg1 = (Dali::Renderer *)jarg1;
17680   arg2 = (int)jarg2;
17681   arg3 = (int)jarg3;
17682   {
17683     try {
17684       (arg1)->SetIndexRange(arg2,arg3);
17685     } CALL_CATCH_EXCEPTION();
17686   }
17687
17688 }
17689
17690
17691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17692   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17693   Dali::TextureSet *arg2 = 0 ;
17694
17695   arg1 = (Dali::Renderer *)jarg1;
17696   arg2 = (Dali::TextureSet *)jarg2;
17697   if (!arg2) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17699     return ;
17700   }
17701   {
17702     try {
17703       (arg1)->SetTextures(*arg2);
17704     } CALL_CATCH_EXCEPTION();
17705   }
17706
17707 }
17708
17709
17710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17711   void * jresult ;
17712   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17713   Dali::TextureSet result;
17714
17715   arg1 = (Dali::Renderer *)jarg1;
17716   {
17717     try {
17718       result = ((Dali::Renderer const *)arg1)->GetTextures();
17719     } CALL_CATCH_EXCEPTION(0);
17720   }
17721
17722   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17728   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17729   Dali::Shader *arg2 = 0 ;
17730
17731   arg1 = (Dali::Renderer *)jarg1;
17732   arg2 = (Dali::Shader *)jarg2;
17733   if (!arg2) {
17734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17735     return ;
17736   }
17737   {
17738     try {
17739       (arg1)->SetShader(*arg2);
17740     } CALL_CATCH_EXCEPTION();
17741   }
17742
17743 }
17744
17745
17746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17747   void * jresult ;
17748   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17749   Dali::Shader result;
17750
17751   arg1 = (Dali::Renderer *)jarg1;
17752   {
17753     try {
17754       result = ((Dali::Renderer const *)arg1)->GetShader();
17755     } CALL_CATCH_EXCEPTION(0);
17756   }
17757
17758   jresult = new Dali::Shader((const Dali::Shader &)result);
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17764   void * jresult ;
17765   Dali::FrameBuffer::Attachment *result = 0 ;
17766
17767   {
17768     try {
17769       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17770     } CALL_CATCH_EXCEPTION(0);
17771   }
17772
17773   jresult = (void *)result;
17774   return jresult;
17775 }
17776
17777
17778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17779   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17780
17781   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17782   {
17783     try {
17784       delete arg1;
17785     } CALL_CATCH_EXCEPTION();
17786   }
17787
17788 }
17789
17790
17791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
17792   void * jresult ;
17793   unsigned int arg1 ;
17794   unsigned int arg2 ;
17795   unsigned int arg3 ;
17796   Dali::FrameBuffer result;
17797
17798   arg1 = (unsigned int)jarg1;
17799   arg2 = (unsigned int)jarg2;
17800   arg3 = (unsigned int)jarg3;
17801   {
17802     try {
17803       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
17804     } CALL_CATCH_EXCEPTION(0);
17805   }
17806
17807   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17808   return jresult;
17809 }
17810
17811
17812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
17813   void * jresult ;
17814   Dali::FrameBuffer *result = 0 ;
17815
17816   {
17817     try {
17818       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
17819     } CALL_CATCH_EXCEPTION(0);
17820   }
17821
17822   jresult = (void *)result;
17823   return jresult;
17824 }
17825
17826
17827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
17828   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17829
17830   arg1 = (Dali::FrameBuffer *)jarg1;
17831   {
17832     try {
17833       delete arg1;
17834     } CALL_CATCH_EXCEPTION();
17835   }
17836
17837 }
17838
17839
17840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
17841   void * jresult ;
17842   Dali::FrameBuffer *arg1 = 0 ;
17843   Dali::FrameBuffer *result = 0 ;
17844
17845   arg1 = (Dali::FrameBuffer *)jarg1;
17846   if (!arg1) {
17847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17848     return 0;
17849   }
17850   {
17851     try {
17852       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
17853     } CALL_CATCH_EXCEPTION(0);
17854   }
17855
17856   jresult = (void *)result;
17857   return jresult;
17858 }
17859
17860
17861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
17862   void * jresult ;
17863   Dali::BaseHandle arg1 ;
17864   Dali::BaseHandle *argp1 ;
17865   Dali::FrameBuffer result;
17866
17867   argp1 = (Dali::BaseHandle *)jarg1;
17868   if (!argp1) {
17869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17870     return 0;
17871   }
17872   arg1 = *argp1;
17873   {
17874     try {
17875       result = Dali::FrameBuffer::DownCast(arg1);
17876     } CALL_CATCH_EXCEPTION(0);
17877   }
17878
17879   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17880   return jresult;
17881 }
17882
17883
17884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
17885   void * jresult ;
17886   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17887   Dali::FrameBuffer *arg2 = 0 ;
17888   Dali::FrameBuffer *result = 0 ;
17889
17890   arg1 = (Dali::FrameBuffer *)jarg1;
17891   arg2 = (Dali::FrameBuffer *)jarg2;
17892   if (!arg2) {
17893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17894     return 0;
17895   }
17896   {
17897     try {
17898       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
17899     } CALL_CATCH_EXCEPTION(0);
17900   }
17901
17902   jresult = (void *)result;
17903   return jresult;
17904 }
17905
17906
17907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
17908   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17909   Dali::Texture *arg2 = 0 ;
17910
17911   arg1 = (Dali::FrameBuffer *)jarg1;
17912   arg2 = (Dali::Texture *)jarg2;
17913   if (!arg2) {
17914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17915     return ;
17916   }
17917   {
17918     try {
17919       (arg1)->AttachColorTexture(*arg2);
17920     } CALL_CATCH_EXCEPTION();
17921   }
17922
17923 }
17924
17925
17926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
17927   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17928   Dali::Texture *arg2 = 0 ;
17929   unsigned int arg3 ;
17930   unsigned int arg4 ;
17931
17932   arg1 = (Dali::FrameBuffer *)jarg1;
17933   arg2 = (Dali::Texture *)jarg2;
17934   if (!arg2) {
17935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17936     return ;
17937   }
17938   arg3 = (unsigned int)jarg3;
17939   arg4 = (unsigned int)jarg4;
17940   {
17941     try {
17942       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
17943     } CALL_CATCH_EXCEPTION();
17944   }
17945
17946 }
17947
17948
17949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
17950   void * jresult ;
17951   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17952   Dali::Texture result;
17953
17954   arg1 = (Dali::FrameBuffer *)jarg1;
17955   {
17956     try {
17957       result = (arg1)->GetColorTexture();
17958     } CALL_CATCH_EXCEPTION(0);
17959   }
17960
17961   jresult = new Dali::Texture((const Dali::Texture &)result);
17962   return jresult;
17963 }
17964
17965
17966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
17967   void * jresult ;
17968   Dali::RenderTaskList *result = 0 ;
17969
17970   {
17971     try {
17972       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
17973     } CALL_CATCH_EXCEPTION(0);
17974   }
17975
17976   jresult = (void *)result;
17977   return jresult;
17978 }
17979
17980
17981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
17982   void * jresult ;
17983   Dali::BaseHandle arg1 ;
17984   Dali::BaseHandle *argp1 ;
17985   Dali::RenderTaskList result;
17986
17987   argp1 = (Dali::BaseHandle *)jarg1;
17988   if (!argp1) {
17989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17990     return 0;
17991   }
17992   arg1 = *argp1;
17993   {
17994     try {
17995       result = Dali::RenderTaskList::DownCast(arg1);
17996     } CALL_CATCH_EXCEPTION(0);
17997   }
17998
17999   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
18000   return jresult;
18001 }
18002
18003
18004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
18005   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18006
18007   arg1 = (Dali::RenderTaskList *)jarg1;
18008   {
18009     try {
18010       delete arg1;
18011     } CALL_CATCH_EXCEPTION();
18012   }
18013
18014 }
18015
18016
18017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
18018   void * jresult ;
18019   Dali::RenderTaskList *arg1 = 0 ;
18020   Dali::RenderTaskList *result = 0 ;
18021
18022   arg1 = (Dali::RenderTaskList *)jarg1;
18023   if (!arg1) {
18024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18025     return 0;
18026   }
18027   {
18028     try {
18029       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
18030     } CALL_CATCH_EXCEPTION(0);
18031   }
18032
18033   jresult = (void *)result;
18034   return jresult;
18035 }
18036
18037
18038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
18039   void * jresult ;
18040   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18041   Dali::RenderTaskList *arg2 = 0 ;
18042   Dali::RenderTaskList *result = 0 ;
18043
18044   arg1 = (Dali::RenderTaskList *)jarg1;
18045   arg2 = (Dali::RenderTaskList *)jarg2;
18046   if (!arg2) {
18047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
18048     return 0;
18049   }
18050   {
18051     try {
18052       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
18053     } CALL_CATCH_EXCEPTION(0);
18054   }
18055
18056   jresult = (void *)result;
18057   return jresult;
18058 }
18059
18060
18061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
18062   void * jresult ;
18063   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18064   Dali::RenderTask result;
18065
18066   arg1 = (Dali::RenderTaskList *)jarg1;
18067   {
18068     try {
18069       result = (arg1)->CreateTask();
18070     } CALL_CATCH_EXCEPTION(0);
18071   }
18072
18073   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18074   return jresult;
18075 }
18076
18077
18078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
18079   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18080   Dali::RenderTask arg2 ;
18081   Dali::RenderTask *argp2 ;
18082
18083   arg1 = (Dali::RenderTaskList *)jarg1;
18084   argp2 = (Dali::RenderTask *)jarg2;
18085   if (!argp2) {
18086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
18087     return ;
18088   }
18089   arg2 = *argp2;
18090   {
18091     try {
18092       (arg1)->RemoveTask(arg2);
18093     } CALL_CATCH_EXCEPTION();
18094   }
18095
18096 }
18097
18098
18099 //// ===============================================end part 1 =================
18100
18101 //// ========================= part 2 ===============================
18102
18103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
18104   unsigned int jresult ;
18105   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18106   unsigned int result;
18107
18108   arg1 = (Dali::RenderTaskList *)jarg1;
18109   {
18110     try {
18111       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
18112     } CALL_CATCH_EXCEPTION(0);
18113   }
18114
18115   jresult = result;
18116   return jresult;
18117 }
18118
18119
18120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
18121   void * jresult ;
18122   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
18123   unsigned int arg2 ;
18124   Dali::RenderTask result;
18125
18126   arg1 = (Dali::RenderTaskList *)jarg1;
18127   arg2 = (unsigned int)jarg2;
18128   {
18129     try {
18130       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
18131     } CALL_CATCH_EXCEPTION(0);
18132   }
18133
18134   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18135   return jresult;
18136 }
18137
18138
18139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
18140   int jresult ;
18141   int result;
18142
18143   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
18144   jresult = (int)result;
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
18150   int jresult ;
18151   int result;
18152
18153   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
18154   jresult = (int)result;
18155   return jresult;
18156 }
18157
18158
18159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
18160   int jresult ;
18161   int result;
18162
18163   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
18164   jresult = (int)result;
18165   return jresult;
18166 }
18167
18168
18169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
18170   int jresult ;
18171   int result;
18172
18173   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
18174   jresult = (int)result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
18180   void * jresult ;
18181   Dali::RenderTask::Property *result = 0 ;
18182
18183   {
18184     try {
18185       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
18186     } CALL_CATCH_EXCEPTION(0);
18187   }
18188
18189   jresult = (void *)result;
18190   return jresult;
18191 }
18192
18193
18194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
18195   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
18196
18197   arg1 = (Dali::RenderTask::Property *)jarg1;
18198   {
18199     try {
18200       delete arg1;
18201     } CALL_CATCH_EXCEPTION();
18202   }
18203
18204 }
18205
18206
18207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
18208   void * jresult ;
18209   bool (*result)(Dali::Vector2 &) = 0 ;
18210
18211   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
18212   jresult = (void *)result;
18213   return jresult;
18214 }
18215
18216
18217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
18218   void * jresult ;
18219   bool (*result)(Dali::Vector2 &) = 0 ;
18220
18221   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
18222   jresult = (void *)result;
18223   return jresult;
18224 }
18225
18226
18227 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
18228   bool jresult ;
18229   bool result;
18230
18231   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
18232   jresult = result;
18233   return jresult;
18234 }
18235
18236
18237 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
18238   bool jresult ;
18239   bool result;
18240
18241   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
18242   jresult = result;
18243   return jresult;
18244 }
18245
18246
18247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
18248   void * jresult ;
18249   Dali::Vector4 *result = 0 ;
18250
18251   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
18252   jresult = (void *)result;
18253   return jresult;
18254 }
18255
18256
18257 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
18258   bool jresult ;
18259   bool result;
18260
18261   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
18262   jresult = result;
18263   return jresult;
18264 }
18265
18266
18267 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
18268   bool jresult ;
18269   bool result;
18270
18271   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
18272   jresult = result;
18273   return jresult;
18274 }
18275
18276
18277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
18278   unsigned int jresult ;
18279   unsigned int result;
18280
18281   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
18282   jresult = result;
18283   return jresult;
18284 }
18285
18286
18287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
18288   void * jresult ;
18289   Dali::RenderTask *result = 0 ;
18290
18291   {
18292     try {
18293       result = (Dali::RenderTask *)new Dali::RenderTask();
18294     } CALL_CATCH_EXCEPTION(0);
18295   }
18296
18297   jresult = (void *)result;
18298   return jresult;
18299 }
18300
18301
18302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
18303   void * jresult ;
18304   Dali::BaseHandle arg1 ;
18305   Dali::BaseHandle *argp1 ;
18306   Dali::RenderTask result;
18307
18308   argp1 = (Dali::BaseHandle *)jarg1;
18309   if (!argp1) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18311     return 0;
18312   }
18313   arg1 = *argp1;
18314   {
18315     try {
18316       result = Dali::RenderTask::DownCast(arg1);
18317     } CALL_CATCH_EXCEPTION(0);
18318   }
18319
18320   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
18321   return jresult;
18322 }
18323
18324
18325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
18326   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18327
18328   arg1 = (Dali::RenderTask *)jarg1;
18329   {
18330     try {
18331       delete arg1;
18332     } CALL_CATCH_EXCEPTION();
18333   }
18334
18335 }
18336
18337
18338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
18339   void * jresult ;
18340   Dali::RenderTask *arg1 = 0 ;
18341   Dali::RenderTask *result = 0 ;
18342
18343   arg1 = (Dali::RenderTask *)jarg1;
18344   if (!arg1) {
18345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18346     return 0;
18347   }
18348   {
18349     try {
18350       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
18351     } CALL_CATCH_EXCEPTION(0);
18352   }
18353
18354   jresult = (void *)result;
18355   return jresult;
18356 }
18357
18358
18359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
18360   void * jresult ;
18361   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18362   Dali::RenderTask *arg2 = 0 ;
18363   Dali::RenderTask *result = 0 ;
18364
18365   arg1 = (Dali::RenderTask *)jarg1;
18366   arg2 = (Dali::RenderTask *)jarg2;
18367   if (!arg2) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
18369     return 0;
18370   }
18371   {
18372     try {
18373       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
18374     } CALL_CATCH_EXCEPTION(0);
18375   }
18376
18377   jresult = (void *)result;
18378   return jresult;
18379 }
18380
18381
18382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
18383   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18384   Dali::Actor arg2 ;
18385   Dali::Actor *argp2 ;
18386
18387   arg1 = (Dali::RenderTask *)jarg1;
18388   argp2 = (Dali::Actor *)jarg2;
18389   if (!argp2) {
18390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18391     return ;
18392   }
18393   arg2 = *argp2;
18394   {
18395     try {
18396       (arg1)->SetSourceActor(arg2);
18397     } CALL_CATCH_EXCEPTION();
18398   }
18399
18400 }
18401
18402
18403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
18404   void * jresult ;
18405   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18406   Dali::Actor result;
18407
18408   arg1 = (Dali::RenderTask *)jarg1;
18409   {
18410     try {
18411       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
18412     } CALL_CATCH_EXCEPTION(0);
18413   }
18414
18415   jresult = new Dali::Actor((const Dali::Actor &)result);
18416   return jresult;
18417 }
18418
18419
18420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
18421   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18422   bool arg2 ;
18423
18424   arg1 = (Dali::RenderTask *)jarg1;
18425   arg2 = jarg2 ? true : false;
18426   {
18427     try {
18428       (arg1)->SetExclusive(arg2);
18429     } CALL_CATCH_EXCEPTION();
18430   }
18431
18432 }
18433
18434
18435 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
18436   bool jresult ;
18437   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18438   bool result;
18439
18440   arg1 = (Dali::RenderTask *)jarg1;
18441   {
18442     try {
18443       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
18444     } CALL_CATCH_EXCEPTION(0);
18445   }
18446
18447   jresult = result;
18448   return jresult;
18449 }
18450
18451
18452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
18453   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18454   bool arg2 ;
18455
18456   arg1 = (Dali::RenderTask *)jarg1;
18457   arg2 = jarg2 ? true : false;
18458   {
18459     try {
18460       (arg1)->SetInputEnabled(arg2);
18461     } CALL_CATCH_EXCEPTION();
18462   }
18463
18464 }
18465
18466
18467 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
18468   bool jresult ;
18469   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18470   bool result;
18471
18472   arg1 = (Dali::RenderTask *)jarg1;
18473   {
18474     try {
18475       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
18476     } CALL_CATCH_EXCEPTION(0);
18477   }
18478
18479   jresult = result;
18480   return jresult;
18481 }
18482
18483
18484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
18485   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18486   Dali::CameraActor arg2 ;
18487   Dali::CameraActor *argp2 ;
18488
18489   arg1 = (Dali::RenderTask *)jarg1;
18490   argp2 = (Dali::CameraActor *)jarg2;
18491   if (!argp2) {
18492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
18493     return ;
18494   }
18495   arg2 = *argp2;
18496   {
18497     try {
18498       (arg1)->SetCameraActor(arg2);
18499     } CALL_CATCH_EXCEPTION();
18500   }
18501
18502 }
18503
18504
18505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
18506   void * jresult ;
18507   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18508   Dali::CameraActor result;
18509
18510   arg1 = (Dali::RenderTask *)jarg1;
18511   {
18512     try {
18513       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
18514     } CALL_CATCH_EXCEPTION(0);
18515   }
18516
18517   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
18518   return jresult;
18519 }
18520
18521
18522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
18523   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18524   Dali::FrameBuffer arg2 ;
18525   Dali::FrameBuffer *argp2 ;
18526
18527   arg1 = (Dali::RenderTask *)jarg1;
18528   argp2 = (Dali::FrameBuffer *)jarg2;
18529   if (!argp2) {
18530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
18531     return ;
18532   }
18533   arg2 = *argp2;
18534   {
18535     try {
18536       (arg1)->SetFrameBuffer(arg2);
18537     } CALL_CATCH_EXCEPTION();
18538   }
18539
18540 }
18541
18542
18543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
18544   void * jresult ;
18545   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18546   Dali::FrameBuffer result;
18547
18548   arg1 = (Dali::RenderTask *)jarg1;
18549   {
18550     try {
18551       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
18552     } CALL_CATCH_EXCEPTION(0);
18553   }
18554
18555   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
18556   return jresult;
18557 }
18558
18559
18560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
18561   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18562   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
18563
18564   arg1 = (Dali::RenderTask *)jarg1;
18565   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
18566   {
18567     try {
18568       (arg1)->SetScreenToFrameBufferFunction(arg2);
18569     } CALL_CATCH_EXCEPTION();
18570   }
18571
18572 }
18573
18574
18575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
18576   void * jresult ;
18577   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18578   Dali::RenderTask::ScreenToFrameBufferFunction result;
18579
18580   arg1 = (Dali::RenderTask *)jarg1;
18581   {
18582     try {
18583       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
18584     } CALL_CATCH_EXCEPTION(0);
18585   }
18586
18587   jresult = (void *)result;
18588   return jresult;
18589 }
18590
18591
18592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
18593   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18594   Dali::Actor arg2 ;
18595   Dali::Actor *argp2 ;
18596
18597   arg1 = (Dali::RenderTask *)jarg1;
18598   argp2 = (Dali::Actor *)jarg2;
18599   if (!argp2) {
18600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18601     return ;
18602   }
18603   arg2 = *argp2;
18604   {
18605     try {
18606       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
18607     } CALL_CATCH_EXCEPTION();
18608   }
18609
18610 }
18611
18612
18613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18614   void * jresult ;
18615   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18616   Dali::Actor result;
18617
18618   arg1 = (Dali::RenderTask *)jarg1;
18619   {
18620     try {
18621       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18622     } CALL_CATCH_EXCEPTION(0);
18623   }
18624
18625   jresult = new Dali::Actor((const Dali::Actor &)result);
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18631   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18632   Dali::Vector2 arg2 ;
18633   Dali::Vector2 *argp2 ;
18634
18635   arg1 = (Dali::RenderTask *)jarg1;
18636   argp2 = (Dali::Vector2 *)jarg2;
18637   if (!argp2) {
18638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18639     return ;
18640   }
18641   arg2 = *argp2;
18642   {
18643     try {
18644       (arg1)->SetViewportPosition(arg2);
18645     } CALL_CATCH_EXCEPTION();
18646   }
18647
18648 }
18649
18650
18651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18652   void * jresult ;
18653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18654   Dali::Vector2 result;
18655
18656   arg1 = (Dali::RenderTask *)jarg1;
18657   {
18658     try {
18659       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18660     } CALL_CATCH_EXCEPTION(0);
18661   }
18662
18663   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18664   return jresult;
18665 }
18666
18667
18668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18669   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18670   Dali::Vector2 arg2 ;
18671   Dali::Vector2 *argp2 ;
18672
18673   arg1 = (Dali::RenderTask *)jarg1;
18674   argp2 = (Dali::Vector2 *)jarg2;
18675   if (!argp2) {
18676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18677     return ;
18678   }
18679   arg2 = *argp2;
18680   {
18681     try {
18682       (arg1)->SetViewportSize(arg2);
18683     } CALL_CATCH_EXCEPTION();
18684   }
18685
18686 }
18687
18688
18689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18690   void * jresult ;
18691   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18692   Dali::Vector2 result;
18693
18694   arg1 = (Dali::RenderTask *)jarg1;
18695   {
18696     try {
18697       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18698     } CALL_CATCH_EXCEPTION(0);
18699   }
18700
18701   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18702   return jresult;
18703 }
18704
18705
18706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18708   Dali::Viewport arg2 ;
18709   Dali::Viewport *argp2 ;
18710
18711   arg1 = (Dali::RenderTask *)jarg1;
18712   argp2 = (Dali::Viewport *)jarg2;
18713   if (!argp2) {
18714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18715     return ;
18716   }
18717   arg2 = *argp2;
18718   {
18719     try {
18720       (arg1)->SetViewport(arg2);
18721     } CALL_CATCH_EXCEPTION();
18722   }
18723
18724 }
18725
18726
18727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18728   void * jresult ;
18729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18730   Dali::Viewport result;
18731
18732   arg1 = (Dali::RenderTask *)jarg1;
18733   {
18734     try {
18735       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18736     } CALL_CATCH_EXCEPTION(0);
18737   }
18738
18739   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18740   return jresult;
18741 }
18742
18743
18744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18746   Dali::Vector4 *arg2 = 0 ;
18747
18748   arg1 = (Dali::RenderTask *)jarg1;
18749   arg2 = (Dali::Vector4 *)jarg2;
18750   if (!arg2) {
18751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18752     return ;
18753   }
18754   {
18755     try {
18756       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18757     } CALL_CATCH_EXCEPTION();
18758   }
18759
18760 }
18761
18762
18763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
18764   void * jresult ;
18765   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18766   Dali::Vector4 result;
18767
18768   arg1 = (Dali::RenderTask *)jarg1;
18769   {
18770     try {
18771       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
18772     } CALL_CATCH_EXCEPTION(0);
18773   }
18774
18775   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18776   return jresult;
18777 }
18778
18779
18780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
18781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18782   bool arg2 ;
18783
18784   arg1 = (Dali::RenderTask *)jarg1;
18785   arg2 = jarg2 ? true : false;
18786   {
18787     try {
18788       (arg1)->SetClearEnabled(arg2);
18789     } CALL_CATCH_EXCEPTION();
18790   }
18791
18792 }
18793
18794
18795 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
18796   bool jresult ;
18797   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18798   bool result;
18799
18800   arg1 = (Dali::RenderTask *)jarg1;
18801   {
18802     try {
18803       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
18804     } CALL_CATCH_EXCEPTION(0);
18805   }
18806
18807   jresult = result;
18808   return jresult;
18809 }
18810
18811
18812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
18813   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18814   bool arg2 ;
18815
18816   arg1 = (Dali::RenderTask *)jarg1;
18817   arg2 = jarg2 ? true : false;
18818   {
18819     try {
18820       (arg1)->SetCullMode(arg2);
18821     } CALL_CATCH_EXCEPTION();
18822   }
18823
18824 }
18825
18826
18827 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
18828   bool jresult ;
18829   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18830   bool result;
18831
18832   arg1 = (Dali::RenderTask *)jarg1;
18833   {
18834     try {
18835       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
18836     } CALL_CATCH_EXCEPTION(0);
18837   }
18838
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
18845   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18846   unsigned int arg2 ;
18847
18848   arg1 = (Dali::RenderTask *)jarg1;
18849   arg2 = (unsigned int)jarg2;
18850   {
18851     try {
18852       (arg1)->SetRefreshRate(arg2);
18853     } CALL_CATCH_EXCEPTION();
18854   }
18855
18856 }
18857
18858
18859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
18860   unsigned int jresult ;
18861   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18862   unsigned int result;
18863
18864   arg1 = (Dali::RenderTask *)jarg1;
18865   {
18866     try {
18867       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
18868     } CALL_CATCH_EXCEPTION(0);
18869   }
18870
18871   jresult = result;
18872   return jresult;
18873 }
18874
18875
18876 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
18877   bool jresult ;
18878   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18879   Dali::Vector3 *arg2 = 0 ;
18880   float *arg3 = 0 ;
18881   float *arg4 = 0 ;
18882   bool result;
18883
18884   arg1 = (Dali::RenderTask *)jarg1;
18885   arg2 = (Dali::Vector3 *)jarg2;
18886   if (!arg2) {
18887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
18888     return 0;
18889   }
18890   arg3 = (float *)jarg3;
18891   arg4 = (float *)jarg4;
18892   {
18893     try {
18894       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
18895     } CALL_CATCH_EXCEPTION(0);
18896   }
18897
18898   jresult = result;
18899   return jresult;
18900 }
18901
18902
18903 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
18904   bool jresult ;
18905   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18906   Dali::Actor arg2 ;
18907   float arg3 ;
18908   float arg4 ;
18909   float *arg5 = 0 ;
18910   float *arg6 = 0 ;
18911   Dali::Actor *argp2 ;
18912   bool result;
18913
18914   arg1 = (Dali::RenderTask *)jarg1;
18915   argp2 = (Dali::Actor *)jarg2;
18916   if (!argp2) {
18917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18918     return 0;
18919   }
18920   arg2 = *argp2;
18921   arg3 = (float)jarg3;
18922   arg4 = (float)jarg4;
18923   arg5 = (float *)jarg5;
18924   arg6 = (float *)jarg6;
18925   {
18926     try {
18927       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
18928     } CALL_CATCH_EXCEPTION(0);
18929   }
18930
18931   jresult = result;
18932   return jresult;
18933 }
18934
18935
18936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
18937   void * jresult ;
18938   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18939   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
18940
18941   arg1 = (Dali::RenderTask *)jarg1;
18942   {
18943     try {
18944       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
18945     } CALL_CATCH_EXCEPTION(0);
18946   }
18947
18948   jresult = (void *)result;
18949   return jresult;
18950 }
18951
18952
18953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
18954   void * jresult ;
18955   int arg1 ;
18956   Dali::PointState::Type arg2 ;
18957   float arg3 ;
18958   float arg4 ;
18959   Dali::TouchPoint *result = 0 ;
18960
18961   arg1 = (int)jarg1;
18962   arg2 = (Dali::PointState::Type)jarg2;
18963   arg3 = (float)jarg3;
18964   arg4 = (float)jarg4;
18965   {
18966     try {
18967       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
18968     } CALL_CATCH_EXCEPTION(0);
18969   }
18970
18971   jresult = (void *)result;
18972   return jresult;
18973 }
18974
18975
18976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
18977   void * jresult ;
18978   int arg1 ;
18979   Dali::PointState::Type arg2 ;
18980   float arg3 ;
18981   float arg4 ;
18982   float arg5 ;
18983   float arg6 ;
18984   Dali::TouchPoint *result = 0 ;
18985
18986   arg1 = (int)jarg1;
18987   arg2 = (Dali::PointState::Type)jarg2;
18988   arg3 = (float)jarg3;
18989   arg4 = (float)jarg4;
18990   arg5 = (float)jarg5;
18991   arg6 = (float)jarg6;
18992   {
18993     try {
18994       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
18995     } CALL_CATCH_EXCEPTION(0);
18996   }
18997
18998   jresult = (void *)result;
18999   return jresult;
19000 }
19001
19002
19003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
19004   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19005
19006   arg1 = (Dali::TouchPoint *)jarg1;
19007   {
19008     try {
19009       delete arg1;
19010     } CALL_CATCH_EXCEPTION();
19011   }
19012
19013 }
19014
19015
19016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
19017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19018   int arg2 ;
19019
19020   arg1 = (Dali::TouchPoint *)jarg1;
19021   arg2 = (int)jarg2;
19022   if (arg1) (arg1)->deviceId = arg2;
19023 }
19024
19025
19026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
19027   int jresult ;
19028   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19029   int result;
19030
19031   arg1 = (Dali::TouchPoint *)jarg1;
19032   result = (int) ((arg1)->deviceId);
19033   jresult = result;
19034   return jresult;
19035 }
19036
19037
19038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
19039   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19040   Dali::PointState::Type arg2 ;
19041
19042   arg1 = (Dali::TouchPoint *)jarg1;
19043   arg2 = (Dali::PointState::Type)jarg2;
19044   if (arg1) (arg1)->state = arg2;
19045 }
19046
19047
19048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
19049   int jresult ;
19050   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19051   Dali::PointState::Type result;
19052
19053   arg1 = (Dali::TouchPoint *)jarg1;
19054   result = (Dali::PointState::Type) ((arg1)->state);
19055   jresult = (int)result;
19056   return jresult;
19057 }
19058
19059
19060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
19061   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19062   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
19063
19064   arg1 = (Dali::TouchPoint *)jarg1;
19065   arg2 = (Dali::Actor *)jarg2;
19066   if (arg1) (arg1)->hitActor = *arg2;
19067 }
19068
19069
19070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
19071   void * jresult ;
19072   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19073   Dali::Actor *result = 0 ;
19074
19075   arg1 = (Dali::TouchPoint *)jarg1;
19076   result = (Dali::Actor *)& ((arg1)->hitActor);
19077   jresult = (void *)result;
19078   return jresult;
19079 }
19080
19081
19082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
19083   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19084   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19085
19086   arg1 = (Dali::TouchPoint *)jarg1;
19087   arg2 = (Dali::Vector2 *)jarg2;
19088   if (arg1) (arg1)->local = *arg2;
19089 }
19090
19091
19092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
19093   void * jresult ;
19094   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19095   Dali::Vector2 *result = 0 ;
19096
19097   arg1 = (Dali::TouchPoint *)jarg1;
19098   result = (Dali::Vector2 *)& ((arg1)->local);
19099   jresult = (void *)result;
19100   return jresult;
19101 }
19102
19103
19104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
19105   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19106   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
19107
19108   arg1 = (Dali::TouchPoint *)jarg1;
19109   arg2 = (Dali::Vector2 *)jarg2;
19110   if (arg1) (arg1)->screen = *arg2;
19111 }
19112
19113
19114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
19115   void * jresult ;
19116   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
19117   Dali::Vector2 *result = 0 ;
19118
19119   arg1 = (Dali::TouchPoint *)jarg1;
19120   result = (Dali::Vector2 *)& ((arg1)->screen);
19121   jresult = (void *)result;
19122   return jresult;
19123 }
19124
19125
19126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
19127   void * jresult ;
19128   Dali::TouchEvent *result = 0 ;
19129
19130   {
19131     try {
19132       result = (Dali::TouchEvent *)new Dali::TouchEvent();
19133     } CALL_CATCH_EXCEPTION(0);
19134   }
19135
19136   jresult = (void *)result;
19137   return jresult;
19138 }
19139
19140
19141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
19142   void * jresult ;
19143   Dali::TouchEvent *arg1 = 0 ;
19144   Dali::TouchEvent *result = 0 ;
19145
19146   arg1 = (Dali::TouchEvent *)jarg1;
19147   if (!arg1) {
19148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19149     return 0;
19150   }
19151   {
19152     try {
19153       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
19154     } CALL_CATCH_EXCEPTION(0);
19155   }
19156
19157   jresult = (void *)result;
19158   return jresult;
19159 }
19160
19161
19162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
19163   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19164
19165   arg1 = (Dali::TouchEvent *)jarg1;
19166   {
19167     try {
19168       delete arg1;
19169     } CALL_CATCH_EXCEPTION();
19170   }
19171
19172 }
19173
19174
19175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
19176   void * jresult ;
19177   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19178   Dali::TouchEvent *arg2 = 0 ;
19179   Dali::TouchEvent *result = 0 ;
19180
19181   arg1 = (Dali::TouchEvent *)jarg1;
19182   arg2 = (Dali::TouchEvent *)jarg2;
19183   if (!arg2) {
19184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
19185     return 0;
19186   }
19187   {
19188     try {
19189       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
19190     } CALL_CATCH_EXCEPTION(0);
19191   }
19192
19193   jresult = (void *)result;
19194   return jresult;
19195 }
19196
19197
19198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
19199   unsigned long jresult ;
19200   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19201   unsigned long result;
19202
19203   arg1 = (Dali::TouchEvent *)jarg1;
19204   {
19205     try {
19206       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
19207     } CALL_CATCH_EXCEPTION(0);
19208   }
19209
19210   jresult = (unsigned long)result;
19211   return jresult;
19212 }
19213
19214
19215 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
19216   unsigned long jresult ;
19217   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19218   std::size_t result;
19219
19220   arg1 = (Dali::TouchEvent *)jarg1;
19221   {
19222     try {
19223       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
19224     } CALL_CATCH_EXCEPTION(0);
19225   }
19226
19227   jresult = (unsigned long)result;
19228   return jresult;
19229 }
19230
19231
19232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
19233   int jresult ;
19234   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19235   std::size_t arg2 ;
19236   int32_t result;
19237
19238   arg1 = (Dali::TouchEvent *)jarg1;
19239   arg2 = (std::size_t)jarg2;
19240   {
19241     try {
19242       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
19243     } CALL_CATCH_EXCEPTION(0);
19244   }
19245
19246   jresult = result;
19247   return jresult;
19248 }
19249
19250
19251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
19252   int jresult ;
19253   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19254   std::size_t arg2 ;
19255   Dali::PointState::Type result;
19256
19257   arg1 = (Dali::TouchEvent *)jarg1;
19258   arg2 = (std::size_t)jarg2;
19259   {
19260     try {
19261       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
19262     } CALL_CATCH_EXCEPTION(0);
19263   }
19264
19265   jresult = (int)result;
19266   return jresult;
19267 }
19268
19269
19270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
19271   void * jresult ;
19272   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19273   std::size_t arg2 ;
19274   Dali::Actor result;
19275
19276   arg1 = (Dali::TouchEvent *)jarg1;
19277   arg2 = (std::size_t)jarg2;
19278   {
19279     try {
19280       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
19281     } CALL_CATCH_EXCEPTION(0);
19282   }
19283
19284   jresult = new Dali::Actor((const Dali::Actor &)result);
19285   return jresult;
19286 }
19287
19288
19289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19290   void * jresult ;
19291   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19292   std::size_t arg2 ;
19293   Dali::Vector2 *result = 0 ;
19294
19295   arg1 = (Dali::TouchEvent *)jarg1;
19296   arg2 = (std::size_t)jarg2;
19297   {
19298     try {
19299       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
19300     } CALL_CATCH_EXCEPTION(0);
19301   }
19302
19303   jresult = (void *)result;
19304   return jresult;
19305 }
19306
19307
19308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19309   void * jresult ;
19310   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19311   std::size_t arg2 ;
19312   Dali::Vector2 *result = 0 ;
19313
19314   arg1 = (Dali::TouchEvent *)jarg1;
19315   arg2 = (std::size_t)jarg2;
19316   {
19317     try {
19318       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
19319     } CALL_CATCH_EXCEPTION(0);
19320   }
19321
19322   jresult = (void *)result;
19323   return jresult;
19324 }
19325
19326
19327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
19328   float jresult ;
19329   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19330   std::size_t arg2 ;
19331   float result;
19332
19333   arg1 = (Dali::TouchEvent *)jarg1;
19334   arg2 = (std::size_t)jarg2;
19335   {
19336     try {
19337       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
19338     } CALL_CATCH_EXCEPTION(0);
19339   }
19340
19341   jresult = result;
19342   return jresult;
19343 }
19344
19345
19346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
19347   void * jresult ;
19348   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19349   std::size_t arg2 ;
19350   Dali::Vector2 *result = 0 ;
19351
19352   arg1 = (Dali::TouchEvent *)jarg1;
19353   arg2 = (std::size_t)jarg2;
19354   {
19355     try {
19356       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
19357     } CALL_CATCH_EXCEPTION(0);
19358   }
19359
19360   jresult = (void *)result;
19361   return jresult;
19362 }
19363
19364
19365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
19366   float jresult ;
19367   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19368   std::size_t arg2 ;
19369   float result;
19370
19371   arg1 = (Dali::TouchEvent *)jarg1;
19372   arg2 = (std::size_t)jarg2;
19373   {
19374     try {
19375       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
19376     } CALL_CATCH_EXCEPTION(0);
19377   }
19378
19379   jresult = result;
19380   return jresult;
19381 }
19382
19383
19384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
19385   void * jresult ;
19386   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19387   std::size_t arg2 ;
19388   Dali::Degree result;
19389
19390   arg1 = (Dali::TouchEvent *)jarg1;
19391   arg2 = (std::size_t)jarg2;
19392   {
19393     try {
19394       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
19395     } CALL_CATCH_EXCEPTION(0);
19396   }
19397
19398   jresult = new Dali::Degree((const Dali::Degree &)result);
19399   return jresult;
19400 }
19401
19402
19403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
19404   int jresult ;
19405   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
19406   std::size_t arg2 ;
19407   Dali::MouseButton::Type result;
19408
19409   arg1 = (Dali::TouchEvent *)jarg1;
19410   arg2 = (std::size_t)jarg2;
19411   {
19412     try {
19413       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
19414     } CALL_CATCH_EXCEPTION(0);
19415   }
19416
19417   jresult = static_cast< int >(result);
19418   return jresult;
19419 }
19420
19421
19422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
19423   void * jresult ;
19424   Dali::GestureDetector *result = 0 ;
19425
19426   {
19427     try {
19428       result = (Dali::GestureDetector *)new Dali::GestureDetector();
19429     } CALL_CATCH_EXCEPTION(0);
19430   }
19431
19432   jresult = (void *)result;
19433   return jresult;
19434 }
19435
19436
19437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
19438   void * jresult ;
19439   Dali::BaseHandle arg1 ;
19440   Dali::BaseHandle *argp1 ;
19441   Dali::GestureDetector result;
19442
19443   argp1 = (Dali::BaseHandle *)jarg1;
19444   if (!argp1) {
19445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19446     return 0;
19447   }
19448   arg1 = *argp1;
19449   {
19450     try {
19451       result = Dali::GestureDetector::DownCast(arg1);
19452     } CALL_CATCH_EXCEPTION(0);
19453   }
19454
19455   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
19456   return jresult;
19457 }
19458
19459
19460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
19461   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19462
19463   arg1 = (Dali::GestureDetector *)jarg1;
19464   {
19465     try {
19466       delete arg1;
19467     } CALL_CATCH_EXCEPTION();
19468   }
19469
19470 }
19471
19472
19473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
19474   void * jresult ;
19475   Dali::GestureDetector *arg1 = 0 ;
19476   Dali::GestureDetector *result = 0 ;
19477
19478   arg1 = (Dali::GestureDetector *)jarg1;
19479   if (!arg1) {
19480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19481     return 0;
19482   }
19483   {
19484     try {
19485       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
19486     } CALL_CATCH_EXCEPTION(0);
19487   }
19488
19489   jresult = (void *)result;
19490   return jresult;
19491 }
19492
19493
19494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
19495   void * jresult ;
19496   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19497   Dali::GestureDetector *arg2 = 0 ;
19498   Dali::GestureDetector *result = 0 ;
19499
19500   arg1 = (Dali::GestureDetector *)jarg1;
19501   arg2 = (Dali::GestureDetector *)jarg2;
19502   if (!arg2) {
19503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
19504     return 0;
19505   }
19506   {
19507     try {
19508       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
19509     } CALL_CATCH_EXCEPTION(0);
19510   }
19511
19512   jresult = (void *)result;
19513   return jresult;
19514 }
19515
19516
19517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
19518   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19519   Dali::Actor arg2 ;
19520   Dali::Actor *argp2 ;
19521
19522   arg1 = (Dali::GestureDetector *)jarg1;
19523   argp2 = (Dali::Actor *)jarg2;
19524   if (!argp2) {
19525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19526     return ;
19527   }
19528   arg2 = *argp2;
19529   {
19530     try {
19531       (arg1)->Attach(arg2);
19532     } CALL_CATCH_EXCEPTION();
19533   }
19534
19535 }
19536
19537
19538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
19539   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19540   Dali::Actor arg2 ;
19541   Dali::Actor *argp2 ;
19542
19543   arg1 = (Dali::GestureDetector *)jarg1;
19544   argp2 = (Dali::Actor *)jarg2;
19545   if (!argp2) {
19546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
19547     return ;
19548   }
19549   arg2 = *argp2;
19550   {
19551     try {
19552       (arg1)->Detach(arg2);
19553     } CALL_CATCH_EXCEPTION();
19554   }
19555
19556 }
19557
19558
19559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
19560   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19561
19562   arg1 = (Dali::GestureDetector *)jarg1;
19563   {
19564     try {
19565       (arg1)->DetachAll();
19566     } CALL_CATCH_EXCEPTION();
19567   }
19568
19569 }
19570
19571
19572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
19573   unsigned long jresult ;
19574   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19575   size_t result;
19576
19577   arg1 = (Dali::GestureDetector *)jarg1;
19578   {
19579     try {
19580       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
19581     } CALL_CATCH_EXCEPTION(0);
19582   }
19583
19584   jresult = (unsigned long)result;
19585   return jresult;
19586 }
19587
19588
19589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
19590   void * jresult ;
19591   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
19592   size_t arg2 ;
19593   Dali::Actor result;
19594
19595   arg1 = (Dali::GestureDetector *)jarg1;
19596   arg2 = (size_t)jarg2;
19597   {
19598     try {
19599       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
19600     } CALL_CATCH_EXCEPTION(0);
19601   }
19602
19603   jresult = new Dali::Actor((const Dali::Actor &)result);
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
19609   void * jresult ;
19610   Dali::Gesture *arg1 = 0 ;
19611   Dali::Gesture *result = 0 ;
19612
19613   arg1 = (Dali::Gesture *)jarg1;
19614   if (!arg1) {
19615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19616     return 0;
19617   }
19618   {
19619     try {
19620       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19621     } CALL_CATCH_EXCEPTION(0);
19622   }
19623
19624   jresult = (void *)result;
19625   return jresult;
19626 }
19627
19628
19629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19630   void * jresult ;
19631   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19632   Dali::Gesture *arg2 = 0 ;
19633   Dali::Gesture *result = 0 ;
19634
19635   arg1 = (Dali::Gesture *)jarg1;
19636   arg2 = (Dali::Gesture *)jarg2;
19637   if (!arg2) {
19638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19639     return 0;
19640   }
19641   {
19642     try {
19643       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19644     } CALL_CATCH_EXCEPTION(0);
19645   }
19646
19647   jresult = (void *)result;
19648   return jresult;
19649 }
19650
19651
19652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19653   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19654
19655   arg1 = (Dali::Gesture *)jarg1;
19656   {
19657     try {
19658       delete arg1;
19659     } CALL_CATCH_EXCEPTION();
19660   }
19661
19662 }
19663
19664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19665   int jresult ;
19666   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19667   Dali::GestureType::Value result;
19668
19669   arg1 = (Dali::Gesture *)jarg1;
19670   result = (Dali::GestureType::Value) ((arg1)->GetType());
19671   jresult = (int)result;
19672   return jresult;
19673 }
19674
19675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19676   int jresult ;
19677   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19678   Dali::GestureState result;
19679
19680   arg1 = (Dali::Gesture *)jarg1;
19681   result = (Dali::GestureState) ((arg1)->GetState());
19682   jresult = (int)result;
19683   return jresult;
19684 }
19685
19686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19687   unsigned int jresult ;
19688   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19689   unsigned int result;
19690
19691   arg1 = (Dali::Gesture *)jarg1;
19692   result = (unsigned int) ((arg1)->GetTime());
19693   jresult = result;
19694   return jresult;
19695 }
19696
19697
19698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19699   void * jresult ;
19700   Dali::HoverEvent *result = 0 ;
19701
19702   {
19703     try {
19704       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19705     } CALL_CATCH_EXCEPTION(0);
19706   }
19707
19708   jresult = (void *)result;
19709   return jresult;
19710 }
19711
19712
19713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19714   void * jresult ;
19715   Dali::HoverEvent *arg1 = 0 ;
19716   Dali::HoverEvent *result = 0 ;
19717
19718   arg1 = (Dali::HoverEvent *)jarg1;
19719   if (!arg1) {
19720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19721     return 0;
19722   }
19723   {
19724     try {
19725       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
19726     } CALL_CATCH_EXCEPTION(0);
19727   }
19728
19729   jresult = (void *)result;
19730   return jresult;
19731 }
19732
19733
19734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
19735   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19736
19737   arg1 = (Dali::HoverEvent *)jarg1;
19738   {
19739     try {
19740       delete arg1;
19741     } CALL_CATCH_EXCEPTION();
19742   }
19743
19744 }
19745
19746
19747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
19748   void * jresult ;
19749   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19750   Dali::HoverEvent *arg2 = 0 ;
19751   Dali::HoverEvent *result = 0 ;
19752
19753   arg1 = (Dali::HoverEvent *)jarg1;
19754   arg2 = (Dali::HoverEvent *)jarg2;
19755   if (!arg2) {
19756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19757     return 0;
19758   }
19759   {
19760     try {
19761       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
19762     } catch (std::out_of_range& e) {
19763       {
19764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (std::exception& e) {
19767       {
19768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19769       };
19770     } catch (Dali::DaliException e) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19773       };
19774     } catch (...) {
19775       {
19776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19777       };
19778     }
19779   }
19780
19781   jresult = (void *)result;
19782   return jresult;
19783 }
19784
19785
19786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
19787   void * jresult ;
19788   unsigned int arg1 ;
19789   Dali::HoverEvent result;
19790
19791   arg1 = (unsigned int)jarg1;
19792   {
19793     try {
19794       result = DevelHoverEvent::New(arg1);
19795     } CALL_CATCH_EXCEPTION(0);
19796   }
19797
19798   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
19799   return jresult;
19800 }
19801
19802
19803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19804   unsigned long jresult ;
19805   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19806   unsigned long result;
19807
19808   arg1 = (Dali::HoverEvent *)jarg1;
19809   {
19810     try {
19811       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19812     } catch (std::out_of_range& e) {
19813       {
19814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19815       };
19816     } catch (std::exception& e) {
19817       {
19818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19819       };
19820     } catch (Dali::DaliException e) {
19821       {
19822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19823       };
19824     } catch (...) {
19825       {
19826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19827       };
19828     }
19829   }
19830
19831   jresult = (unsigned long)result;
19832   return jresult;
19833 }
19834
19835
19836 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19837   unsigned long jresult ;
19838   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19839   std::size_t result;
19840
19841   arg1 = (Dali::HoverEvent *)jarg1;
19842   {
19843     try {
19844       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19845     } catch (std::out_of_range& e) {
19846       {
19847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19848       };
19849     } catch (std::exception& e) {
19850       {
19851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19852       };
19853     } catch (Dali::DaliException e) {
19854       {
19855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19856       };
19857     } catch (...) {
19858       {
19859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19860       };
19861     }
19862   }
19863
19864   jresult = (unsigned long)result;
19865   return jresult;
19866 }
19867
19868
19869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19870   int jresult ;
19871   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19872   std::size_t arg2 ;
19873   int32_t result;
19874
19875   arg1 = (Dali::HoverEvent *)jarg1;
19876   arg2 = (std::size_t)jarg2;
19877   {
19878     try {
19879       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19887       };
19888     } catch (Dali::DaliException e) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19891       };
19892     } catch (...) {
19893       {
19894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19895       };
19896     }
19897   }
19898
19899   jresult = result;
19900   return jresult;
19901 }
19902
19903
19904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19905   int jresult ;
19906   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19907   std::size_t arg2 ;
19908   Dali::PointState::Type result;
19909
19910   arg1 = (Dali::HoverEvent *)jarg1;
19911   arg2 = (std::size_t)jarg2;
19912   {
19913     try {
19914       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19915     } CALL_CATCH_EXCEPTION(0);
19916   }
19917
19918   jresult = (int)result;
19919   return jresult;
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19924   void * jresult ;
19925   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19926   std::size_t arg2 ;
19927   Dali::Actor result;
19928
19929   arg1 = (Dali::HoverEvent *)jarg1;
19930   arg2 = (std::size_t)jarg2;
19931   {
19932     try {
19933       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = new Dali::Actor((const Dali::Actor &)result);
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19959   void * jresult ;
19960   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19961   std::size_t arg2 ;
19962   Dali::Vector2 *result = 0 ;
19963
19964   arg1 = (Dali::HoverEvent *)jarg1;
19965   arg2 = (std::size_t)jarg2;
19966   {
19967     try {
19968       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19969     } catch (std::out_of_range& e) {
19970       {
19971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19972       };
19973     } catch (std::exception& e) {
19974       {
19975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (Dali::DaliException e) {
19978       {
19979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19980       };
19981     } catch (...) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19984       };
19985     }
19986   }
19987
19988   jresult = (void *)result;
19989   return jresult;
19990 }
19991
19992
19993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19994   void * jresult ;
19995   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19996   std::size_t arg2 ;
19997   Dali::Vector2 *result = 0 ;
19998
19999   arg1 = (Dali::HoverEvent *)jarg1;
20000   arg2 = (std::size_t)jarg2;
20001   {
20002     try {
20003       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
20004     } CALL_CATCH_EXCEPTION(0);
20005   }
20006
20007   jresult = (void *)result;
20008   return jresult;
20009 }
20010
20011
20012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
20013   void * jresult ;
20014   Dali::KeyEvent *result = 0 ;
20015
20016   {
20017     try {
20018       result = (Dali::KeyEvent *)new Dali::KeyEvent();
20019     } CALL_CATCH_EXCEPTION(0);
20020   }
20021
20022   jresult = (void *)result;
20023   return jresult;
20024 }
20025
20026
20027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
20028   void * jresult ;
20029   Dali::KeyEvent *arg1 = 0 ;
20030   Dali::KeyEvent *result = 0 ;
20031
20032   arg1 = (Dali::KeyEvent *)jarg1;
20033   if (!arg1) {
20034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20035     return 0;
20036   }
20037   {
20038     try {
20039       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
20040     } CALL_CATCH_EXCEPTION(0);
20041   }
20042
20043   jresult = (void *)result;
20044   return jresult;
20045 }
20046
20047
20048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
20049   void * jresult ;
20050   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20051   Dali::KeyEvent *arg2 = 0 ;
20052   Dali::KeyEvent *result = 0 ;
20053
20054   arg1 = (Dali::KeyEvent *)jarg1;
20055   arg2 = (Dali::KeyEvent *)jarg2;
20056   if (!arg2) {
20057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20058     return 0;
20059   }
20060   {
20061     try {
20062       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
20063     } CALL_CATCH_EXCEPTION(0);
20064   }
20065
20066   jresult = (void *)result;
20067   return jresult;
20068 }
20069
20070
20071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
20072   void * jresult ;
20073   std::string *arg1 = 0 ;
20074   std::string *arg2 = 0 ;
20075   int arg3 ;
20076   int arg4 ;
20077   unsigned long arg5 ;
20078   Dali::KeyEvent::State *arg6 = 0 ;
20079   Dali::KeyEvent::State temp6 ;
20080   Dali::KeyEvent result;
20081
20082   if (!jarg1) {
20083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20084     return 0;
20085   }
20086   std::string arg1_str(jarg1);
20087   arg1 = &arg1_str;
20088   if (!jarg2) {
20089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20090     return 0;
20091   }
20092   std::string arg2_str(jarg2);
20093   arg2 = &arg2_str;
20094   arg3 = (int)jarg3;
20095   arg4 = (int)jarg4;
20096   arg5 = (unsigned long)jarg5;
20097   temp6 = (Dali::KeyEvent::State)jarg6;
20098   arg6 = &temp6;
20099   {
20100     try {
20101       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);
20102     } CALL_CATCH_EXCEPTION(0);
20103   }
20104
20105   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
20106
20107   //argout typemap for const std::string&
20108
20109
20110   //argout typemap for const std::string&
20111
20112   return jresult;
20113 }
20114
20115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
20116   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20117
20118   arg1 = (Dali::KeyEvent *)jarg1;
20119   {
20120     try {
20121       delete arg1;
20122     } CALL_CATCH_EXCEPTION();
20123   }
20124
20125 }
20126
20127
20128 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
20129   bool jresult ;
20130   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20131   bool result;
20132
20133   arg1 = (Dali::KeyEvent *)jarg1;
20134   {
20135     try {
20136       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
20137     } CALL_CATCH_EXCEPTION(0);
20138   }
20139
20140   jresult = result;
20141   return jresult;
20142 }
20143
20144
20145 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
20146   bool jresult ;
20147   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20148   bool result;
20149
20150   arg1 = (Dali::KeyEvent *)jarg1;
20151   {
20152     try {
20153       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
20154     } CALL_CATCH_EXCEPTION(0);
20155   }
20156
20157   jresult = result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
20163   bool jresult ;
20164   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
20165   bool result;
20166
20167   arg1 = (Dali::KeyEvent *)jarg1;
20168   {
20169     try {
20170       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
20171     } CALL_CATCH_EXCEPTION(0);
20172   }
20173
20174   jresult = result;
20175   return jresult;
20176 }
20177
20178
20179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
20180   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20181   std::string *arg2 = 0 ;
20182
20183   argp1 = (Dali::KeyEvent *) jarg1;
20184   if (!argp1) {
20185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20186     return ;
20187   }
20188
20189   Dali::KeyEvent arg1 = *argp1;
20190   if (!jarg2) {
20191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20192     return ;
20193   }
20194   std::string arg2_str(jarg2);
20195   arg2 = &arg2_str;
20196
20197   {
20198     try {
20199       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
20200     } catch (std::out_of_range& e) {
20201       {
20202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20203       };
20204     } catch (std::exception& e) {
20205       {
20206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20207       };
20208     } catch (Dali::DaliException e) {
20209       {
20210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20211       };
20212     } catch (...) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20215       };
20216     }
20217   }
20218 }
20219
20220
20221 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
20222   char * jresult ;
20223
20224   if( jarg1 == NULL )
20225   {
20226     jresult = SWIG_csharp_string_callback( "" );
20227   }
20228   else
20229   {
20230     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20231     std::string *result = 0;
20232     std::string str = "";
20233
20234     arg1 = ( Dali::KeyEvent * )jarg1;
20235     {
20236       try {
20237         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
20238         result = (std::string *) &str;
20239         jresult = SWIG_csharp_string_callback(result->c_str());
20240       } catch (std::out_of_range& e) {
20241         {
20242           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20243         };
20244       } catch (std::exception& e) {
20245         {
20246           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20247         };
20248       } catch (Dali::DaliException e) {
20249         {
20250           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20251         };
20252       } catch (...) {
20253         {
20254           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20255         };
20256       }
20257     }
20258
20259   }
20260
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
20266   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20267   std::string *arg2 = 0 ;
20268
20269   argp1 = (Dali::KeyEvent *) jarg1;
20270   if (!argp1) {
20271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20272     return ;
20273   }
20274
20275   Dali::KeyEvent arg1 = *argp1;
20276   if (!jarg2) {
20277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20278     return ;
20279   }
20280   std::string arg2_str(jarg2);
20281   arg2 = &arg2_str;
20282
20283   {
20284     try {
20285       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
20286     } catch (std::out_of_range& e) {
20287       {
20288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20289       };
20290     } catch (std::exception& e) {
20291       {
20292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20293       };
20294     } catch (Dali::DaliException e) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20297       };
20298     } catch (...) {
20299       {
20300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20301       };
20302     }
20303   }
20304 }
20305
20306
20307 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
20308   char * jresult ;
20309
20310   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20311   std::string *result = 0;
20312   std::string str = "";
20313   arg1 = ( Dali::KeyEvent * )jarg1;
20314   {
20315     try {
20316       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
20317       result = (std::string *) &str;
20318       jresult = SWIG_csharp_string_callback(result->c_str());
20319     } catch (std::out_of_range& e) {
20320       {
20321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20322       };
20323     } catch (std::exception& e) {
20324       {
20325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20326       };
20327     } catch (Dali::DaliException e) {
20328       {
20329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20330       };
20331     } catch (...) {
20332       {
20333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20334       };
20335     }
20336   }
20337
20338   return jresult;
20339 }
20340
20341
20342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
20343   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20344   int arg2 ;
20345
20346   argp1 = (Dali::KeyEvent *) jarg1;
20347   if (!argp1) {
20348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20349     return ;
20350   }
20351
20352   Dali::KeyEvent arg1 = *argp1;
20353   arg2 = (int)jarg2;
20354   {
20355     try {
20356       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
20357     } catch (std::out_of_range& e) {
20358       {
20359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20360       };
20361     } catch (std::exception& e) {
20362       {
20363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20364       };
20365     } catch (Dali::DaliException e) {
20366       {
20367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20368       };
20369     } catch (...) {
20370       {
20371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20372       };
20373     }
20374   }
20375 }
20376
20377
20378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
20379   int jresult ;
20380   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20381   int result;
20382
20383   arg1 = (Dali::KeyEvent *)jarg1;
20384   {
20385     try {
20386       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
20387     } catch (std::out_of_range& e) {
20388       {
20389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20390       };
20391     } catch (std::exception& e) {
20392       {
20393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20394       };
20395     } catch (Dali::DaliException e) {
20396       {
20397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20398       };
20399     } catch (...) {
20400       {
20401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20402       };
20403     }
20404   }
20405
20406   jresult = result;
20407   return jresult;
20408 }
20409
20410
20411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
20412   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20413   int arg2 ;
20414
20415   argp1 = (Dali::KeyEvent *) jarg1;
20416   if (!argp1) {
20417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20418     return ;
20419   }
20420
20421   Dali::KeyEvent arg1 = *argp1;
20422   arg2 = (int)jarg2;
20423   {
20424     try {
20425       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
20426     } catch (std::out_of_range& e) {
20427       {
20428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20429       };
20430     } catch (std::exception& e) {
20431       {
20432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20433       };
20434     } catch (Dali::DaliException e) {
20435       {
20436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20437       };
20438     } catch (...) {
20439       {
20440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20441       };
20442     }
20443   }
20444 }
20445
20446
20447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
20448   int jresult ;
20449   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20450   int result;
20451
20452   arg1 = (Dali::KeyEvent *)jarg1;
20453   {
20454     try {
20455       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
20456     } catch (std::out_of_range& e) {
20457       {
20458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20459       };
20460     } catch (std::exception& e) {
20461       {
20462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20463       };
20464     } catch (Dali::DaliException e) {
20465       {
20466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20467       };
20468     } catch (...) {
20469       {
20470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20471       };
20472     }
20473   }
20474
20475   jresult = result;
20476   return jresult;
20477 }
20478
20479
20480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
20481   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
20482   unsigned long arg2 ;
20483
20484   argp1 = (Dali::KeyEvent *) jarg1;
20485   if (!argp1) {
20486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20487     return ;
20488   }
20489
20490   Dali::KeyEvent arg1 = *argp1;
20491   arg2 = (int)jarg2;
20492   {
20493     try {
20494       Dali::DevelKeyEvent::SetTime(arg1, arg2);
20495     } catch (std::out_of_range& e) {
20496       {
20497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20498       };
20499     } catch (std::exception& e) {
20500       {
20501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20502       };
20503     } catch (Dali::DaliException e) {
20504       {
20505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20506       };
20507     } catch (...) {
20508       {
20509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20510       };
20511     }
20512   }
20513 }
20514
20515
20516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
20517   unsigned long jresult ;
20518   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20519   unsigned long result;
20520
20521   arg1 = (Dali::KeyEvent *)jarg1;
20522   {
20523     try {
20524       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
20525     } catch (std::out_of_range& e) {
20526       {
20527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20528       };
20529     } catch (std::exception& e) {
20530       {
20531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20532       };
20533     } catch (Dali::DaliException e) {
20534       {
20535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20536       };
20537     } catch (...) {
20538       {
20539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20540       };
20541     }
20542   }
20543
20544   jresult = result;
20545   return jresult;
20546 }
20547
20548
20549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
20550   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
20551   Dali::KeyEvent::State arg2;
20552
20553   argp1 = (Dali::KeyEvent *) jarg1;
20554   if (!argp1) {
20555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
20556     return ;
20557   }
20558
20559   Dali::KeyEvent arg1 = *argp1;
20560   arg2 = (Dali::KeyEvent::State)jarg2;
20561   {
20562     try {
20563       Dali::DevelKeyEvent::SetState(arg1, arg2);
20564     } catch (std::out_of_range& e) {
20565       {
20566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20567       };
20568     } catch (std::exception& e) {
20569       {
20570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20571       };
20572     } catch (Dali::DaliException e) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20575       };
20576     } catch (...) {
20577       {
20578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20579       };
20580     }
20581   }
20582 }
20583
20584
20585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
20586   int jresult ;
20587   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20588   Dali::KeyEvent::State result;
20589
20590   arg1 = (Dali::KeyEvent *)jarg1;
20591   {
20592     try {
20593       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
20594     } catch (std::out_of_range& e) {
20595       {
20596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20597       };
20598     } catch (std::exception& e) {
20599       {
20600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20601       };
20602     } catch (Dali::DaliException e) {
20603       {
20604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20605       };
20606     } catch (...) {
20607       {
20608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20609       };
20610     }
20611   }
20612
20613   jresult = (int)result;
20614   return jresult;
20615
20616 }
20617
20618 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
20619   char * jresult ;
20620
20621   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
20622   std::string *result = 0;
20623   std::string str = "";
20624
20625   arg1 = ( Dali::KeyEvent * )jarg1;
20626   {
20627     try {
20628       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
20629       result = (std::string *) &str;
20630       jresult = SWIG_csharp_string_callback(result->c_str());
20631     } CALL_CATCH_EXCEPTION(0);
20632   }
20633
20634   return jresult;
20635 }
20636
20637
20638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
20639   void * jresult ;
20640   Dali::LongPressGestureDetector *result = 0 ;
20641
20642   {
20643     try {
20644       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
20645     } CALL_CATCH_EXCEPTION(0);
20646   }
20647
20648   jresult = (void *)result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20654   void * jresult ;
20655   Dali::LongPressGestureDetector result;
20656
20657   {
20658     try {
20659       result = Dali::LongPressGestureDetector::New();
20660     } CALL_CATCH_EXCEPTION(0);
20661   }
20662
20663   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20669   void * jresult ;
20670   unsigned int arg1 ;
20671   Dali::LongPressGestureDetector result;
20672
20673   arg1 = (unsigned int)jarg1;
20674   {
20675     try {
20676       result = Dali::LongPressGestureDetector::New(arg1);
20677     } CALL_CATCH_EXCEPTION(0);
20678   }
20679
20680   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20686   void * jresult ;
20687   unsigned int arg1 ;
20688   unsigned int arg2 ;
20689   Dali::LongPressGestureDetector result;
20690
20691   arg1 = (unsigned int)jarg1;
20692   arg2 = (unsigned int)jarg2;
20693   {
20694     try {
20695       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20696     } CALL_CATCH_EXCEPTION(0);
20697   }
20698
20699   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20700   return jresult;
20701 }
20702
20703
20704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20705   void * jresult ;
20706   Dali::BaseHandle arg1 ;
20707   Dali::BaseHandle *argp1 ;
20708   Dali::LongPressGestureDetector result;
20709
20710   argp1 = (Dali::BaseHandle *)jarg1;
20711   if (!argp1) {
20712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20713     return 0;
20714   }
20715   arg1 = *argp1;
20716   {
20717     try {
20718       result = Dali::LongPressGestureDetector::DownCast(arg1);
20719     } CALL_CATCH_EXCEPTION(0);
20720   }
20721
20722   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20723   return jresult;
20724 }
20725
20726
20727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20728   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20729
20730   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20731   {
20732     try {
20733       delete arg1;
20734     } CALL_CATCH_EXCEPTION();
20735   }
20736
20737 }
20738
20739
20740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20741   void * jresult ;
20742   Dali::LongPressGestureDetector *arg1 = 0 ;
20743   Dali::LongPressGestureDetector *result = 0 ;
20744
20745   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20746   if (!arg1) {
20747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20748     return 0;
20749   }
20750   {
20751     try {
20752       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20753     } CALL_CATCH_EXCEPTION(0);
20754   }
20755
20756   jresult = (void *)result;
20757   return jresult;
20758 }
20759
20760
20761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20762   void * jresult ;
20763   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20764   Dali::LongPressGestureDetector *arg2 = 0 ;
20765   Dali::LongPressGestureDetector *result = 0 ;
20766
20767   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20768   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20769   if (!arg2) {
20770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20771     return 0;
20772   }
20773   {
20774     try {
20775       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20776     } CALL_CATCH_EXCEPTION(0);
20777   }
20778
20779   jresult = (void *)result;
20780   return jresult;
20781 }
20782
20783
20784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20785   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20786   unsigned int arg2 ;
20787
20788   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20789   arg2 = (unsigned int)jarg2;
20790   {
20791     try {
20792       (arg1)->SetTouchesRequired(arg2);
20793     } CALL_CATCH_EXCEPTION();
20794   }
20795
20796 }
20797
20798
20799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20800   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20801   unsigned int arg2 ;
20802   unsigned int arg3 ;
20803
20804   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20805   arg2 = (unsigned int)jarg2;
20806   arg3 = (unsigned int)jarg3;
20807   {
20808     try {
20809       (arg1)->SetTouchesRequired(arg2,arg3);
20810     } CALL_CATCH_EXCEPTION();
20811   }
20812
20813 }
20814
20815
20816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20817   unsigned int jresult ;
20818   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20819   unsigned int result;
20820
20821   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20822   {
20823     try {
20824       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20825     } CALL_CATCH_EXCEPTION(0);
20826   }
20827
20828   jresult = result;
20829   return jresult;
20830 }
20831
20832
20833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20834   unsigned int jresult ;
20835   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20836   unsigned int result;
20837
20838   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20839   {
20840     try {
20841       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20842     } CALL_CATCH_EXCEPTION(0);
20843   }
20844
20845   jresult = result;
20846   return jresult;
20847 }
20848
20849
20850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20851   void * jresult ;
20852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20853   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20854
20855   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20856   {
20857     try {
20858       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20859     } CALL_CATCH_EXCEPTION(0);
20860   }
20861
20862   jresult = (void *)result;
20863   return jresult;
20864 }
20865
20866
20867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
20868   void * jresult ;
20869   Dali::LongPressGesture *result = 0 ;
20870
20871   {
20872     try {
20873       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
20874     } CALL_CATCH_EXCEPTION(0);
20875   }
20876
20877   jresult = (void *)result;
20878   return jresult;
20879 }
20880
20881
20882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
20883   void * jresult ;
20884   Dali::GestureState arg1 ;
20885   Dali::LongPressGesture result;
20886
20887   arg1 = (Dali::GestureState)jarg1;
20888   {
20889     try {
20890       result = DevelLongPressGesture::New(arg1);
20891     } CALL_CATCH_EXCEPTION(0);
20892   }
20893
20894   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
20895   return jresult;
20896 }
20897
20898
20899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20900   void * jresult ;
20901   Dali::LongPressGesture *arg1 = 0 ;
20902   Dali::LongPressGesture *result = 0 ;
20903
20904   arg1 = (Dali::LongPressGesture *)jarg1;
20905   if (!arg1) {
20906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20907     return 0;
20908   }
20909   {
20910     try {
20911       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20912     } CALL_CATCH_EXCEPTION(0);
20913   }
20914
20915   jresult = (void *)result;
20916   return jresult;
20917 }
20918
20919
20920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20921   void * jresult ;
20922   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20923   Dali::LongPressGesture *arg2 = 0 ;
20924   Dali::LongPressGesture *result = 0 ;
20925
20926   arg1 = (Dali::LongPressGesture *)jarg1;
20927   arg2 = (Dali::LongPressGesture *)jarg2;
20928   if (!arg2) {
20929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20930     return 0;
20931   }
20932   {
20933     try {
20934       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20935     } CALL_CATCH_EXCEPTION(0);
20936   }
20937
20938   jresult = (void *)result;
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20944   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20945
20946   arg1 = (Dali::LongPressGesture *)jarg1;
20947   {
20948     try {
20949       delete arg1;
20950     } CALL_CATCH_EXCEPTION();
20951   }
20952
20953 }
20954
20955
20956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20957   unsigned int jresult ;
20958   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20959   unsigned int result;
20960
20961   arg1 = (Dali::LongPressGesture *)jarg1;
20962   result = (unsigned int) ((arg1)->GetNumberOfTouches());
20963   jresult = result;
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20969   void * jresult ;
20970   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20971   Dali::Vector2 result;
20972
20973   arg1 = (Dali::LongPressGesture *)jarg1;
20974   {
20975     try {
20976       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
20977     } catch (std::out_of_range& e) {
20978       {
20979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20980       };
20981     } catch (std::exception& e) {
20982       {
20983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20984       };
20985     } catch (Dali::DaliException e) {
20986       {
20987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20988       };
20989     } catch (...) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20992       };
20993     }
20994   }
20995   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20996   return jresult;
20997 }
20998
20999
21000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
21001   void * jresult ;
21002   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
21003   Dali::Vector2 result;
21004
21005   arg1 = (Dali::LongPressGesture *)jarg1;
21006   {
21007     try {
21008       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
21009     } catch (std::out_of_range& e) {
21010       {
21011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21012       };
21013     } catch (std::exception& e) {
21014       {
21015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21016       };
21017     } catch (Dali::DaliException e) {
21018       {
21019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21020       };
21021     } catch (...) {
21022       {
21023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21024       };
21025     }
21026   }
21027   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
21028   return jresult;
21029 }
21030
21031
21032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
21033   void * jresult ;
21034   Dali::WheelEvent *result = 0 ;
21035
21036   {
21037     try {
21038       result = (Dali::WheelEvent *)new Dali::WheelEvent();
21039     } CALL_CATCH_EXCEPTION(0);
21040   }
21041
21042   jresult = (void *)result;
21043   return jresult;
21044 }
21045
21046
21047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
21048   void * jresult ;
21049   Dali::WheelEvent *arg1 = 0 ;
21050   Dali::WheelEvent *result = 0 ;
21051
21052   arg1 = (Dali::WheelEvent *)jarg1;
21053   if (!arg1) {
21054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21055     return 0;
21056   }
21057   {
21058     try {
21059       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
21060     } catch (std::out_of_range& e) {
21061       {
21062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (std::exception& e) {
21065       {
21066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21067       };
21068     } catch (Dali::DaliException e) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21071       };
21072     } catch (...) {
21073       {
21074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21075       };
21076     }
21077   }
21078
21079   jresult = (void *)result;
21080   return jresult;
21081 }
21082
21083
21084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
21085   void * jresult ;
21086   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21087   Dali::WheelEvent *arg2 = 0 ;
21088   Dali::WheelEvent *result = 0 ;
21089
21090   arg1 = (Dali::WheelEvent *)jarg1;
21091   arg2 = (Dali::WheelEvent *)jarg2;
21092   if (!arg2) {
21093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
21094     return 0;
21095   }
21096   {
21097     try {
21098       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
21099     } catch (std::out_of_range& e) {
21100       {
21101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21102       };
21103     } catch (std::exception& e) {
21104       {
21105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21106       };
21107     } catch (Dali::DaliException e) {
21108       {
21109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21110       };
21111     } catch (...) {
21112       {
21113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21114       };
21115     }
21116   }
21117
21118   jresult = (void *)result;
21119   return jresult;
21120 }
21121
21122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
21123   void * jresult ;
21124   Dali::WheelEvent::Type arg1 ;
21125   int arg2 ;
21126   unsigned int arg3 ;
21127   Dali::Vector2 arg4 ;
21128   int arg5 ;
21129   unsigned int arg6 ;
21130   Dali::Vector2 *argp4 ;
21131   Dali::WheelEvent result;
21132
21133   arg1 = (Dali::WheelEvent::Type)jarg1;
21134   arg2 = (int)jarg2;
21135   arg3 = (unsigned int)jarg3;
21136   argp4 = (Dali::Vector2 *)jarg4;
21137   if (!argp4) {
21138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
21139     return 0;
21140   }
21141   arg4 = *argp4;
21142   arg5 = (int)jarg5;
21143   arg6 = (unsigned int)jarg6;
21144   {
21145     try {
21146       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
21147     } CALL_CATCH_EXCEPTION(0);
21148   }
21149
21150   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
21151   return jresult;
21152 }
21153
21154
21155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
21156   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21157
21158   arg1 = (Dali::WheelEvent *)jarg1;
21159   {
21160     try {
21161       delete arg1;
21162     } CALL_CATCH_EXCEPTION();
21163   }
21164
21165 }
21166
21167
21168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
21169   bool jresult ;
21170   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21171   bool result;
21172
21173   arg1 = (Dali::WheelEvent *)jarg1;
21174   {
21175     try {
21176       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
21177     } CALL_CATCH_EXCEPTION(0);
21178   }
21179
21180   jresult = result;
21181   return jresult;
21182 }
21183
21184
21185 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
21186   bool jresult ;
21187   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21188   bool result;
21189
21190   arg1 = (Dali::WheelEvent *)jarg1;
21191   {
21192     try {
21193       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
21194     } catch (std::out_of_range& e) {
21195       {
21196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21197       };
21198     } catch (std::exception& e) {
21199       {
21200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21201       };
21202     } catch (Dali::DaliException e) {
21203       {
21204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21205       };
21206     } catch (...) {
21207       {
21208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21209       };
21210     }
21211   }
21212
21213   jresult = result;
21214   return jresult;
21215 }
21216
21217
21218 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
21219   bool jresult ;
21220   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21221   bool result;
21222
21223   arg1 = (Dali::WheelEvent *)jarg1;
21224   {
21225     try {
21226       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
21227     } catch (std::out_of_range& e) {
21228       {
21229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21230       };
21231     } catch (std::exception& e) {
21232       {
21233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21234       };
21235     } catch (Dali::DaliException e) {
21236       {
21237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21238       };
21239     } catch (...) {
21240       {
21241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21242       };
21243     }
21244   }
21245
21246   jresult = result;
21247   return jresult;
21248 }
21249
21250
21251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
21252   int jresult ;
21253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21254   Dali::WheelEvent::Type result;
21255
21256   arg1 = (Dali::WheelEvent *)jarg1;
21257   {
21258     try {
21259       result = ((Dali::WheelEvent const *)arg1)->GetType();
21260     } catch (std::out_of_range& e) {
21261       {
21262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21263       };
21264     } catch (std::exception& e) {
21265       {
21266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21267       };
21268     } catch (Dali::DaliException e) {
21269       {
21270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21271       };
21272     } catch (...) {
21273       {
21274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21275       };
21276     }
21277   }
21278
21279   jresult = (int)result;
21280   return jresult;
21281 }
21282
21283
21284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
21285   int jresult ;
21286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21287   int result;
21288
21289   arg1 = (Dali::WheelEvent *)jarg1;
21290   {
21291     try {
21292       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
21293     } catch (std::out_of_range& e) {
21294       {
21295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21296       };
21297     } catch (std::exception& e) {
21298       {
21299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21300       };
21301     } catch (Dali::DaliException e) {
21302       {
21303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21304       };
21305     } catch (...) {
21306       {
21307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21308       };
21309     }
21310   }
21311
21312   jresult = result;
21313   return jresult;
21314 }
21315
21316
21317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
21318   unsigned int jresult ;
21319   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21320   unsigned int result;
21321
21322   arg1 = (Dali::WheelEvent *)jarg1;
21323   {
21324     try {
21325       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
21326     } CALL_CATCH_EXCEPTION(0);
21327   }
21328
21329   jresult = result;
21330   return jresult;
21331 }
21332
21333
21334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
21335   void * jresult ;
21336   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21337   Dali::Vector2 *result = 0 ;
21338
21339   arg1 = (Dali::WheelEvent *)jarg1;
21340   {
21341     try {
21342       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
21343     } CALL_CATCH_EXCEPTION(0);
21344   }
21345
21346   jresult = (void *)result;
21347   return jresult;
21348 }
21349
21350
21351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
21352   int jresult ;
21353   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21354   int result;
21355
21356   arg1 = (Dali::WheelEvent *)jarg1;
21357   {
21358     try {
21359       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
21360     } catch (std::out_of_range& e) {
21361       {
21362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (std::exception& e) {
21365       {
21366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21367       };
21368     } catch (Dali::DaliException e) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21371       };
21372     } catch (...) {
21373       {
21374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21375       };
21376     }
21377   }
21378
21379   jresult = result;
21380   return jresult;
21381 }
21382
21383
21384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
21385   unsigned int jresult ;
21386   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
21387   unsigned int result;
21388
21389   arg1 = (Dali::WheelEvent *)jarg1;
21390   {
21391     try {
21392       result = ((Dali::WheelEvent const *)arg1)->GetTime();
21393     } catch (std::out_of_range& e) {
21394       {
21395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (std::exception& e) {
21398       {
21399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21400       };
21401     } catch (Dali::DaliException e) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21404       };
21405     } catch (...) {
21406       {
21407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21408       };
21409     }
21410   }
21411
21412   jresult = result;
21413   return jresult;
21414 }
21415
21416 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
21417   char * jresult ;
21418   Dali::KeyEvent *arg1 = 0 ;
21419   std::string result;
21420
21421   arg1 = (Dali::KeyEvent *)jarg1;
21422   if (!arg1) {
21423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21424     return 0;
21425   }
21426   {
21427     try {
21428       result = arg1->GetDeviceName();
21429     } CALL_CATCH_EXCEPTION(0);
21430   }
21431
21432   jresult = SWIG_csharp_string_callback((&result)->c_str());
21433   return jresult;
21434 }
21435
21436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
21437   int jresult ;
21438   Dali::KeyEvent *arg1 = 0 ;
21439   Dali::Device::Class::Type result;
21440
21441   arg1 = (Dali::KeyEvent *)jarg1;
21442   if (!arg1) {
21443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21444     return 0;
21445   }
21446   {
21447     try {
21448       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
21449     } CALL_CATCH_EXCEPTION(0);
21450   }
21451
21452   jresult = (int)result;
21453   return jresult;
21454 }
21455
21456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
21457   int jresult ;
21458   Dali::KeyEvent *arg1 = 0 ;
21459   Dali::Device::Subclass::Type result;
21460
21461   arg1 = (Dali::KeyEvent *)jarg1;
21462   if (!arg1) {
21463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
21464     return 0;
21465   }
21466   {
21467     try {
21468       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
21469     } CALL_CATCH_EXCEPTION(0);
21470   }
21471
21472   jresult = (int)result;
21473   return jresult;
21474 }
21475
21476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
21477   Dali::Actor arg1 ;
21478   Dali::Actor *argp1 ;
21479
21480   argp1 = (Dali::Actor *)jarg1;
21481   if (!argp1) {
21482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21483     return ;
21484   }
21485   arg1 = *argp1;
21486   {
21487     try {
21488       arg1.Raise();
21489     } CALL_CATCH_EXCEPTION();
21490   }
21491
21492 }
21493
21494
21495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
21496   Dali::Actor arg1 ;
21497   Dali::Actor *argp1 ;
21498
21499   argp1 = (Dali::Actor *)jarg1;
21500   if (!argp1) {
21501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21502     return ;
21503   }
21504   arg1 = *argp1;
21505   {
21506     try {
21507       arg1.Lower();
21508     } CALL_CATCH_EXCEPTION();
21509   }
21510
21511 }
21512
21513
21514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
21515   Dali::Actor arg1 ;
21516   Dali::Actor *argp1 ;
21517
21518   argp1 = (Dali::Actor *)jarg1;
21519   if (!argp1) {
21520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21521     return ;
21522   }
21523   arg1 = *argp1;
21524   {
21525     try {
21526       arg1.RaiseToTop();
21527     } CALL_CATCH_EXCEPTION();
21528   }
21529
21530 }
21531
21532
21533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
21534   Dali::Actor arg1 ;
21535   Dali::Actor *argp1 ;
21536
21537   argp1 = (Dali::Actor *)jarg1;
21538   if (!argp1) {
21539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21540     return ;
21541   }
21542   arg1 = *argp1;
21543   {
21544     try {
21545       arg1.LowerToBottom();
21546     } CALL_CATCH_EXCEPTION();
21547   }
21548
21549 }
21550
21551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
21552   Dali::Actor arg1 ;
21553   Dali::Actor arg2 ;
21554   Dali::Actor *argp1 ;
21555   Dali::Actor *argp2 ;
21556
21557   argp1 = (Dali::Actor *)jarg1;
21558   if (!argp1) {
21559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21560     return ;
21561   }
21562   arg1 = *argp1;
21563   argp2 = (Dali::Actor *)jarg2;
21564   if (!argp2) {
21565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21566     return ;
21567   }
21568   arg2 = *argp2;
21569   {
21570     try {
21571       arg1.RaiseAbove(arg2);
21572     } CALL_CATCH_EXCEPTION();
21573   }
21574
21575 }
21576
21577
21578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
21579   Dali::Actor arg1 ;
21580   Dali::Actor arg2 ;
21581   Dali::Actor *argp1 ;
21582   Dali::Actor *argp2 ;
21583
21584   argp1 = (Dali::Actor *)jarg1;
21585   if (!argp1) {
21586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21587     return ;
21588   }
21589   arg1 = *argp1;
21590   argp2 = (Dali::Actor *)jarg2;
21591   if (!argp2) {
21592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21593     return ;
21594   }
21595   arg2 = *argp2;
21596   {
21597     try {
21598       arg1.LowerBelow(arg2);
21599     } CALL_CATCH_EXCEPTION();
21600   }
21601
21602 }
21603
21604
21605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
21606   void * jresult ;
21607   Dali::Actor arg1 ;
21608   Dali::Actor *argp1 ;
21609   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
21610
21611   argp1 = (Dali::Actor *)jarg1;
21612   if (!argp1) {
21613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21614     return 0;
21615   }
21616   arg1 = *argp1;
21617   {
21618     try {
21619       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
21620     } CALL_CATCH_EXCEPTION(0);
21621   }
21622
21623   jresult = (void *)result;
21624   return jresult;
21625 }
21626
21627
21628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
21629   void * jresult ;
21630   Dali::Actor *arg1 ;
21631   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
21632
21633   arg1 = (Dali::Actor *)jarg1;
21634   {
21635     try {
21636       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
21637     } CALL_CATCH_EXCEPTION(0);
21638   }
21639
21640   jresult = (void *)result;
21641   return jresult;
21642 }
21643
21644
21645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
21646   int jresult ;
21647   int result;
21648
21649   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
21650   jresult = (int)result;
21651   return jresult;
21652 }
21653
21654
21655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
21656   int jresult ;
21657   int result;
21658
21659   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
21660   jresult = (int)result;
21661   return jresult;
21662 }
21663
21664
21665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
21666   int jresult ;
21667   int result;
21668
21669   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
21670   jresult = (int)result;
21671   return jresult;
21672 }
21673
21674
21675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
21676   int jresult ;
21677   int result;
21678
21679   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
21680   jresult = (int)result;
21681   return jresult;
21682 }
21683
21684
21685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21686   int jresult ;
21687   int result;
21688
21689   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21690   jresult = (int)result;
21691   return jresult;
21692 }
21693
21694
21695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21696   int jresult ;
21697   int result;
21698
21699   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21700   jresult = (int)result;
21701   return jresult;
21702 }
21703
21704
21705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21706   int jresult ;
21707   int result;
21708
21709   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21710   jresult = (int)result;
21711   return jresult;
21712 }
21713
21714
21715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21716   int jresult ;
21717   int result;
21718
21719   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21720   jresult = (int)result;
21721   return jresult;
21722 }
21723
21724
21725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21726   int jresult ;
21727   int result;
21728
21729   result = (int)Dali::Actor::Property::SIZE;
21730   jresult = (int)result;
21731   return jresult;
21732 }
21733
21734
21735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21736   int jresult ;
21737   int result;
21738
21739   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21740   jresult = (int)result;
21741   return jresult;
21742 }
21743
21744
21745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21746   int jresult ;
21747   int result;
21748
21749   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21750   jresult = (int)result;
21751   return jresult;
21752 }
21753
21754
21755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21756   int jresult ;
21757   int result;
21758
21759   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21760   jresult = (int)result;
21761   return jresult;
21762 }
21763
21764
21765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21766   int jresult ;
21767   int result;
21768
21769   result = (int)Dali::Actor::Property::POSITION;
21770   jresult = (int)result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21776   int jresult ;
21777   int result;
21778
21779   result = (int)Dali::Actor::Property::POSITION_X;
21780   jresult = (int)result;
21781   return jresult;
21782 }
21783
21784
21785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21786   int jresult ;
21787   int result;
21788
21789   result = (int)Dali::Actor::Property::POSITION_Y;
21790   jresult = (int)result;
21791   return jresult;
21792 }
21793
21794
21795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21796   int jresult ;
21797   int result;
21798
21799   result = (int)Dali::Actor::Property::POSITION_Z;
21800   jresult = (int)result;
21801   return jresult;
21802 }
21803
21804
21805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21806   int jresult ;
21807   int result;
21808
21809   result = (int)Dali::Actor::Property::WORLD_POSITION;
21810   jresult = (int)result;
21811   return jresult;
21812 }
21813
21814
21815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21816   int jresult ;
21817   int result;
21818
21819   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21820   jresult = (int)result;
21821   return jresult;
21822 }
21823
21824
21825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21826   int jresult ;
21827   int result;
21828
21829   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21830   jresult = (int)result;
21831   return jresult;
21832 }
21833
21834
21835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21836   int jresult ;
21837   int result;
21838
21839   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21840   jresult = (int)result;
21841   return jresult;
21842 }
21843
21844
21845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21846   int jresult ;
21847   int result;
21848
21849   result = (int)Dali::Actor::Property::ORIENTATION;
21850   jresult = (int)result;
21851   return jresult;
21852 }
21853
21854
21855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21856   int jresult ;
21857   int result;
21858
21859   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21860   jresult = (int)result;
21861   return jresult;
21862 }
21863
21864
21865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21866   int jresult ;
21867   int result;
21868
21869   result = (int)Dali::Actor::Property::SCALE;
21870   jresult = (int)result;
21871   return jresult;
21872 }
21873
21874
21875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21876   int jresult ;
21877   int result;
21878
21879   result = (int)Dali::Actor::Property::SCALE_X;
21880   jresult = (int)result;
21881   return jresult;
21882 }
21883
21884
21885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21886   int jresult ;
21887   int result;
21888
21889   result = (int)Dali::Actor::Property::SCALE_Y;
21890   jresult = (int)result;
21891   return jresult;
21892 }
21893
21894
21895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21896   int jresult ;
21897   int result;
21898
21899   result = (int)Dali::Actor::Property::SCALE_Z;
21900   jresult = (int)result;
21901   return jresult;
21902 }
21903
21904
21905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21906   int jresult ;
21907   int result;
21908
21909   result = (int)Dali::Actor::Property::WORLD_SCALE;
21910   jresult = (int)result;
21911   return jresult;
21912 }
21913
21914
21915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21916   int jresult ;
21917   int result;
21918
21919   result = (int)Dali::Actor::Property::VISIBLE;
21920   jresult = (int)result;
21921   return jresult;
21922 }
21923
21924
21925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21926   int jresult ;
21927   int result;
21928
21929   result = (int)Dali::Actor::Property::COLOR;
21930   jresult = (int)result;
21931   return jresult;
21932 }
21933
21934
21935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21936   int jresult ;
21937   int result;
21938
21939   result = (int)Dali::Actor::Property::COLOR_RED;
21940   jresult = (int)result;
21941   return jresult;
21942 }
21943
21944
21945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21946   int jresult ;
21947   int result;
21948
21949   result = (int)Dali::Actor::Property::COLOR_GREEN;
21950   jresult = (int)result;
21951   return jresult;
21952 }
21953
21954
21955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21956   int jresult ;
21957   int result;
21958
21959   result = (int)Dali::Actor::Property::COLOR_BLUE;
21960   jresult = (int)result;
21961   return jresult;
21962 }
21963
21964
21965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21966   int jresult ;
21967   int result;
21968
21969   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21970   jresult = (int)result;
21971   return jresult;
21972 }
21973
21974
21975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21976   int jresult ;
21977   int result;
21978
21979   result = (int)Dali::Actor::Property::WORLD_COLOR;
21980   jresult = (int)result;
21981   return jresult;
21982 }
21983
21984
21985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21986   int jresult ;
21987   int result;
21988
21989   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21990   jresult = (int)result;
21991   return jresult;
21992 }
21993
21994
21995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21996   int jresult ;
21997   int result;
21998
21999   result = (int)Dali::Actor::Property::NAME;
22000   jresult = (int)result;
22001   return jresult;
22002 }
22003
22004
22005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
22006   int jresult ;
22007   int result;
22008
22009   result = (int)Dali::Actor::Property::SENSITIVE;
22010   jresult = (int)result;
22011   return jresult;
22012 }
22013
22014
22015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() {
22016   int jresult ;
22017   int result;
22018
22019   result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
22020   jresult = (int)result;
22021   return jresult;
22022 }
22023
22024
22025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
22026   int jresult ;
22027   int result;
22028
22029   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
22030   jresult = (int)result;
22031   return jresult;
22032 }
22033
22034
22035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
22036   int jresult ;
22037   int result;
22038
22039   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
22040   jresult = (int)result;
22041   return jresult;
22042 }
22043
22044
22045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
22046   int jresult ;
22047   int result;
22048
22049   result = (int)Dali::Actor::Property::INHERIT_SCALE;
22050   jresult = (int)result;
22051   return jresult;
22052 }
22053
22054
22055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
22056   int jresult ;
22057   int result;
22058
22059   result = (int)Dali::Actor::Property::COLOR_MODE;
22060   jresult = (int)result;
22061   return jresult;
22062 }
22063
22064
22065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
22066   int jresult ;
22067   int result;
22068
22069   result = (int)Dali::Actor::Property::DRAW_MODE;
22070   jresult = (int)result;
22071   return jresult;
22072 }
22073
22074
22075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
22076   int jresult ;
22077   int result;
22078
22079   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
22080   jresult = (int)result;
22081   return jresult;
22082 }
22083
22084
22085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
22086   int jresult ;
22087   int result;
22088
22089   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
22090   jresult = (int)result;
22091   return jresult;
22092 }
22093
22094
22095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
22096   int jresult ;
22097   int result;
22098
22099   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
22100   jresult = (int)result;
22101   return jresult;
22102 }
22103
22104
22105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
22106   int jresult ;
22107   int result;
22108
22109   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
22110   jresult = (int)result;
22111   return jresult;
22112 }
22113
22114
22115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
22116   int jresult ;
22117   int result;
22118
22119   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
22120   jresult = (int)result;
22121   return jresult;
22122 }
22123
22124
22125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
22126   int jresult ;
22127   int result;
22128
22129   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
22130   jresult = (int)result;
22131   return jresult;
22132 }
22133
22134
22135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
22136   int jresult ;
22137   int result;
22138
22139   result = (int)Dali::Actor::Property::PADDING;
22140   jresult = (int)result;
22141   return jresult;
22142 }
22143
22144
22145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
22146   int jresult ;
22147   int result;
22148
22149   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
22150   jresult = (int)result;
22151   return jresult;
22152 }
22153
22154
22155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
22156   int jresult ;
22157   int result;
22158
22159   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
22160   jresult = (int)result;
22161   return jresult;
22162 }
22163
22164
22165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
22166   int jresult ;
22167   int result;
22168
22169   result = (int)Dali::Actor::Property::INHERIT_POSITION;
22170   jresult = (int)result;
22171   return jresult;
22172 }
22173
22174
22175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
22176   int jresult ;
22177   int result;
22178
22179   result = (int)Dali::Actor::Property::CLIPPING_MODE;
22180   jresult = (int)result;
22181   return jresult;
22182 }
22183
22184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() {
22185   int jresult ;
22186   int result;
22187
22188   result = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
22189   jresult = (int)result;
22190   return jresult;
22191 }
22192
22193 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
22194
22195   return Dali::Actor::Property::OPACITY;
22196 }
22197
22198 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
22199
22200   return Dali::Actor::Property::SCREEN_POSITION;
22201 }
22202
22203 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
22204
22205   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
22206 }
22207
22208 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
22209   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
22210 }
22211
22212 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
22213   return Dali::Actor::Property::LAYOUT_DIRECTION;
22214 }
22215
22216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
22217   void * jresult ;
22218   Dali::Actor::Property *result = 0 ;
22219
22220   {
22221     try {
22222       result = (Dali::Actor::Property *)new Dali::Actor::Property();
22223     } CALL_CATCH_EXCEPTION(0);
22224   }
22225
22226   jresult = (void *)result;
22227   return jresult;
22228 }
22229
22230
22231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
22232   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
22233
22234   arg1 = (Dali::Actor::Property *)jarg1;
22235   {
22236     try {
22237       delete arg1;
22238     } CALL_CATCH_EXCEPTION();
22239   }
22240
22241 }
22242
22243
22244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
22245   void * jresult ;
22246   Dali::Actor *result = 0 ;
22247
22248   {
22249     try {
22250       result = (Dali::Actor *)new Dali::Actor();
22251     } CALL_CATCH_EXCEPTION(0);
22252   }
22253
22254   jresult = (void *)result;
22255   return jresult;
22256 }
22257
22258
22259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
22260   void * jresult ;
22261   Dali::Actor result;
22262
22263   {
22264     try {
22265       result = Dali::Actor::New();
22266     } CALL_CATCH_EXCEPTION(0);
22267   }
22268
22269   jresult = new Dali::Actor((const Dali::Actor &)result);
22270   return jresult;
22271 }
22272
22273
22274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
22275   void * jresult ;
22276   Dali::BaseHandle arg1 ;
22277   Dali::BaseHandle *argp1 ;
22278   Dali::Actor result;
22279
22280   argp1 = (Dali::BaseHandle *)jarg1;
22281   if (!argp1) {
22282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22283     return 0;
22284   }
22285   arg1 = *argp1;
22286   {
22287     try {
22288       result = Dali::Actor::DownCast(arg1);
22289     } CALL_CATCH_EXCEPTION(0);
22290   }
22291
22292   jresult = new Dali::Actor((const Dali::Actor &)result);
22293   return jresult;
22294 }
22295
22296
22297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
22298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22299
22300   arg1 = (Dali::Actor *)jarg1;
22301   {
22302     try {
22303       delete arg1;
22304     } CALL_CATCH_EXCEPTION();
22305   }
22306
22307 }
22308
22309
22310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
22311   void * jresult ;
22312   Dali::Actor *arg1 = 0 ;
22313   Dali::Actor *result = 0 ;
22314
22315   arg1 = (Dali::Actor *)jarg1;
22316   if (!arg1) {
22317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
22318     return 0;
22319   }
22320   {
22321     try {
22322       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
22323     } CALL_CATCH_EXCEPTION(0);
22324   }
22325
22326   jresult = (void *)result;
22327   return jresult;
22328 }
22329
22330
22331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
22332   void * jresult ;
22333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22334   Dali::Actor *arg2 = 0 ;
22335   Dali::Actor *result = 0 ;
22336
22337   arg1 = (Dali::Actor *)jarg1;
22338   arg2 = (Dali::Actor *)jarg2;
22339   if (!arg2) {
22340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
22341     return 0;
22342   }
22343   {
22344     try {
22345       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
22346     } CALL_CATCH_EXCEPTION(0);
22347   }
22348
22349   jresult = (void *)result;
22350   return jresult;
22351 }
22352
22353
22354 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
22355   char * jresult ;
22356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22357   std::string *result = 0 ;
22358   std::string name = "";
22359
22360   arg1 = (Dali::Actor *)jarg1;
22361   {
22362     try {
22363       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
22364       result = (std::string *) &name;
22365       jresult = SWIG_csharp_string_callback(result->c_str());
22366     } CALL_CATCH_EXCEPTION(0);
22367   }
22368   return jresult;
22369 }
22370
22371
22372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
22373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22374   std::string *arg2 = 0 ;
22375
22376   arg1 = (Dali::Actor *)jarg1;
22377   if (!jarg2) {
22378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22379     return ;
22380   }
22381   std::string arg2_str(jarg2);
22382   arg2 = &arg2_str;
22383   {
22384     try {
22385       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
22386     } CALL_CATCH_EXCEPTION();
22387   }
22388
22389
22390   //argout typemap for const std::string&
22391
22392 }
22393
22394
22395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
22396   unsigned int jresult ;
22397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22398   unsigned int result;
22399
22400   arg1 = (Dali::Actor *)jarg1;
22401
22402   if(!arg1) {
22403     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
22404     return -1;
22405   }
22406
22407   {
22408     try {
22409       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
22410     } CALL_CATCH_EXCEPTION(0);
22411   }
22412
22413   jresult = result;
22414   return jresult;
22415 }
22416
22417
22418 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
22419   bool jresult ;
22420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22421   bool result;
22422
22423   arg1 = (Dali::Actor *)jarg1;
22424   {
22425     try {
22426       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
22427     } CALL_CATCH_EXCEPTION(0);
22428   }
22429
22430   jresult = result;
22431   return jresult;
22432 }
22433
22434
22435 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
22436   bool jresult ;
22437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22438   bool result;
22439
22440   arg1 = (Dali::Actor *)jarg1;
22441   {
22442     try {
22443       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
22444     } CALL_CATCH_EXCEPTION(0);
22445   }
22446
22447   jresult = result;
22448   return jresult;
22449 }
22450
22451
22452 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
22453   bool jresult ;
22454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22455   bool result;
22456
22457   arg1 = (Dali::Actor *)jarg1;
22458   {
22459     try {
22460       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
22461     } CALL_CATCH_EXCEPTION(0);
22462   }
22463
22464   jresult = result;
22465   return jresult;
22466 }
22467
22468
22469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
22470   void * jresult ;
22471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22472   Dali::Layer result;
22473
22474   arg1 = (Dali::Actor *)jarg1;
22475   {
22476     try {
22477       result = (arg1)->GetLayer();
22478     } CALL_CATCH_EXCEPTION(0);
22479   }
22480
22481   jresult = new Dali::Layer((const Dali::Layer &)result);
22482   return jresult;
22483 }
22484
22485
22486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
22487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22488   Dali::Actor arg2 ;
22489   Dali::Actor *argp2 ;
22490
22491   arg1 = (Dali::Actor *)jarg1;
22492   argp2 = (Dali::Actor *)jarg2;
22493   if (!argp2) {
22494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22495     return ;
22496   }
22497   arg2 = *argp2;
22498   {
22499     try {
22500       (arg1)->Add(arg2);
22501     } CALL_CATCH_EXCEPTION();
22502   }
22503
22504 }
22505
22506
22507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
22508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22509   Dali::Actor arg2 ;
22510   Dali::Actor *argp2 ;
22511
22512   arg1 = (Dali::Actor *)jarg1;
22513   argp2 = (Dali::Actor *)jarg2;
22514   if (!argp2) {
22515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
22516     return ;
22517   }
22518   arg2 = *argp2;
22519   {
22520     try {
22521       (arg1)->Remove(arg2);
22522     } CALL_CATCH_EXCEPTION();
22523   }
22524
22525 }
22526
22527
22528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
22529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22530
22531   arg1 = (Dali::Actor *)jarg1;
22532   {
22533     try {
22534       (arg1)->Unparent();
22535     } CALL_CATCH_EXCEPTION();
22536   }
22537
22538 }
22539
22540
22541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
22542   unsigned int jresult ;
22543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22544   unsigned int result;
22545
22546   arg1 = (Dali::Actor *)jarg1;
22547   {
22548     try {
22549       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
22550     } CALL_CATCH_EXCEPTION(0);
22551   }
22552
22553   jresult = result;
22554   return jresult;
22555 }
22556
22557
22558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
22559   void * jresult ;
22560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22561   unsigned int arg2 ;
22562   Dali::Actor result;
22563
22564   arg1 = (Dali::Actor *)jarg1;
22565   arg2 = (unsigned int)jarg2;
22566   {
22567     try {
22568       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
22569     } CALL_CATCH_EXCEPTION(0);
22570   }
22571
22572   jresult = new Dali::Actor((const Dali::Actor &)result);
22573   return jresult;
22574 }
22575
22576
22577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
22578   void * jresult ;
22579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22580   std::string *arg2 = 0 ;
22581   Dali::Actor result;
22582
22583   arg1 = (Dali::Actor *)jarg1;
22584   if (!jarg2) {
22585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22586     return 0;
22587   }
22588   std::string arg2_str(jarg2);
22589   arg2 = &arg2_str;
22590   {
22591     try {
22592       result = (arg1)->FindChildByName((std::string const &)*arg2);
22593     } CALL_CATCH_EXCEPTION(0);
22594   }
22595
22596   jresult = new Dali::Actor((const Dali::Actor &)result);
22597
22598   //argout typemap for const std::string&
22599
22600   return jresult;
22601 }
22602
22603
22604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
22605   void * jresult ;
22606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22607   unsigned int arg2 ;
22608   Dali::Actor result;
22609
22610   arg1 = (Dali::Actor *)jarg1;
22611   arg2 = (unsigned int)jarg2;
22612   {
22613     try {
22614       result = (arg1)->FindChildById(arg2);
22615     } CALL_CATCH_EXCEPTION(0);
22616   }
22617
22618   jresult = new Dali::Actor((const Dali::Actor &)result);
22619   return jresult;
22620 }
22621
22622
22623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
22624   void * jresult ;
22625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22626   Dali::Actor result;
22627
22628   arg1 = (Dali::Actor *)jarg1;
22629   {
22630     try {
22631       result = ((Dali::Actor const *)arg1)->GetParent();
22632     } CALL_CATCH_EXCEPTION(0);
22633   }
22634
22635   jresult = new Dali::Actor((const Dali::Actor &)result);
22636   return jresult;
22637 }
22638
22639
22640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
22641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22642   Dali::Vector3 *arg2 = 0 ;
22643
22644   arg1 = (Dali::Actor *)jarg1;
22645   arg2 = (Dali::Vector3 *)jarg2;
22646   if (!arg2) {
22647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22648     return ;
22649   }
22650   {
22651     try {
22652       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
22653     } CALL_CATCH_EXCEPTION();
22654   }
22655
22656 }
22657
22658
22659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
22660   void * jresult ;
22661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22662   Dali::Vector3 result;
22663
22664   arg1 = (Dali::Actor *)jarg1;
22665   {
22666     try {
22667       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
22668     } CALL_CATCH_EXCEPTION(0);
22669   }
22670
22671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22672   return jresult;
22673 }
22674
22675
22676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
22677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22678   Dali::Vector3 *arg2 = 0 ;
22679
22680   arg1 = (Dali::Actor *)jarg1;
22681   arg2 = (Dali::Vector3 *)jarg2;
22682   if (!arg2) {
22683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22684     return ;
22685   }
22686   {
22687     try {
22688       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22689     } CALL_CATCH_EXCEPTION();
22690   }
22691
22692 }
22693
22694
22695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22696   void * jresult ;
22697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22698   Dali::Vector3 result;
22699
22700   arg1 = (Dali::Actor *)jarg1;
22701   {
22702     try {
22703       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22704     } CALL_CATCH_EXCEPTION(0);
22705   }
22706
22707   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22708   return jresult;
22709 }
22710
22711
22712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22714   float arg2 ;
22715   float arg3 ;
22716
22717   arg1 = (Dali::Actor *)jarg1;
22718   arg2 = (float)jarg2;
22719   arg3 = (float)jarg3;
22720   {
22721     try {
22722       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22723     } CALL_CATCH_EXCEPTION();
22724   }
22725
22726 }
22727
22728
22729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22730   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22731   float arg2 ;
22732   float arg3 ;
22733   float arg4 ;
22734
22735   arg1 = (Dali::Actor *)jarg1;
22736   arg2 = (float)jarg2;
22737   arg3 = (float)jarg3;
22738   arg4 = (float)jarg4;
22739   {
22740     try {
22741       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22742     } CALL_CATCH_EXCEPTION();
22743   }
22744
22745 }
22746
22747
22748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22750   Dali::Vector2 *arg2 = 0 ;
22751
22752   arg1 = (Dali::Actor *)jarg1;
22753   arg2 = (Dali::Vector2 *)jarg2;
22754   if (!arg2) {
22755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22756     return ;
22757   }
22758   {
22759     try {
22760       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22761     } CALL_CATCH_EXCEPTION();
22762   }
22763
22764 }
22765
22766
22767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22769   Dali::Vector3 *arg2 = 0 ;
22770
22771   arg1 = (Dali::Actor *)jarg1;
22772   arg2 = (Dali::Vector3 *)jarg2;
22773   if (!arg2) {
22774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22775     return ;
22776   }
22777   {
22778     try {
22779       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22780     } CALL_CATCH_EXCEPTION();
22781   }
22782
22783 }
22784
22785
22786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22787   void * jresult ;
22788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22789   Dali::Vector3 result;
22790
22791   arg1 = (Dali::Actor *)jarg1;
22792   {
22793     try {
22794       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22795     } CALL_CATCH_EXCEPTION(0);
22796   }
22797
22798   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22799   return jresult;
22800 }
22801
22802
22803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22804   void * jresult ;
22805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22806   Dali::Vector3 result;
22807
22808   arg1 = (Dali::Actor *)jarg1;
22809   {
22810     try {
22811       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22812     } CALL_CATCH_EXCEPTION(0);
22813   }
22814
22815   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22816   return jresult;
22817 }
22818
22819
22820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22821   void * jresult ;
22822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22823   Dali::Vector3 result;
22824
22825   arg1 = (Dali::Actor *)jarg1;
22826   {
22827     try {
22828       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22829     } CALL_CATCH_EXCEPTION(0);
22830   }
22831
22832   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22833   return jresult;
22834 }
22835
22836
22837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22839   float arg2 ;
22840   float arg3 ;
22841
22842   arg1 = (Dali::Actor *)jarg1;
22843   arg2 = (float)jarg2;
22844   arg3 = (float)jarg3;
22845   {
22846     try {
22847       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22848     } CALL_CATCH_EXCEPTION();
22849   }
22850
22851 }
22852
22853
22854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22856   float arg2 ;
22857   float arg3 ;
22858   float arg4 ;
22859
22860   arg1 = (Dali::Actor *)jarg1;
22861   arg2 = (float)jarg2;
22862   arg3 = (float)jarg3;
22863   arg4 = (float)jarg4;
22864   {
22865     try {
22866       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22867     } CALL_CATCH_EXCEPTION();
22868   }
22869
22870 }
22871
22872
22873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22875   Dali::Vector3 *arg2 = 0 ;
22876
22877   arg1 = (Dali::Actor *)jarg1;
22878   arg2 = (Dali::Vector3 *)jarg2;
22879   if (!arg2) {
22880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22881     return ;
22882   }
22883   {
22884     try {
22885       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22886     } CALL_CATCH_EXCEPTION();
22887   }
22888
22889 }
22890
22891
22892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22894   float arg2 ;
22895
22896   arg1 = (Dali::Actor *)jarg1;
22897   arg2 = (float)jarg2;
22898   {
22899     try {
22900       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22901     } CALL_CATCH_EXCEPTION();
22902   }
22903
22904 }
22905
22906
22907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22908   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22909   float arg2 ;
22910
22911   arg1 = (Dali::Actor *)jarg1;
22912   arg2 = (float)jarg2;
22913   {
22914     try {
22915       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22916     } CALL_CATCH_EXCEPTION();
22917   }
22918
22919 }
22920
22921
22922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22924   float arg2 ;
22925
22926   arg1 = (Dali::Actor *)jarg1;
22927   arg2 = (float)jarg2;
22928   {
22929     try {
22930       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22931     } CALL_CATCH_EXCEPTION();
22932   }
22933
22934 }
22935
22936
22937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22939   Dali::Vector3 *arg2 = 0 ;
22940
22941   arg1 = (Dali::Actor *)jarg1;
22942   arg2 = (Dali::Vector3 *)jarg2;
22943   if (!arg2) {
22944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22945     return ;
22946   }
22947   {
22948     try {
22949       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22950     } CALL_CATCH_EXCEPTION();
22951   }
22952
22953 }
22954
22955
22956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22957   void * jresult ;
22958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22959   Dali::Vector3 result;
22960
22961   arg1 = (Dali::Actor *)jarg1;
22962   {
22963     try {
22964       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22965     } CALL_CATCH_EXCEPTION(0);
22966   }
22967
22968   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22969   return jresult;
22970 }
22971
22972
22973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22974   void * jresult ;
22975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22976   Dali::Vector3 result;
22977
22978   arg1 = (Dali::Actor *)jarg1;
22979   {
22980     try {
22981       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22982     } CALL_CATCH_EXCEPTION(0);
22983   }
22984
22985   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22986   return jresult;
22987 }
22988
22989
22990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
22991   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22992   bool arg2 ;
22993
22994   arg1 = (Dali::Actor *)jarg1;
22995   arg2 = jarg2 ? true : false;
22996   {
22997     try {
22998       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22999     } CALL_CATCH_EXCEPTION();
23000   }
23001
23002 }
23003
23004
23005 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
23006   bool jresult ;
23007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23008   bool result;
23009
23010   arg1 = (Dali::Actor *)jarg1;
23011   {
23012     try {
23013       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
23014     } CALL_CATCH_EXCEPTION(0);
23015   }
23016
23017   jresult = result;
23018   return jresult;
23019 }
23020
23021
23022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23024   Dali::Degree *arg2 = 0 ;
23025   Dali::Vector3 *arg3 = 0 ;
23026
23027   arg1 = (Dali::Actor *)jarg1;
23028   arg2 = (Dali::Degree *)jarg2;
23029   if (!arg2) {
23030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23031     return ;
23032   }
23033   arg3 = (Dali::Vector3 *)jarg3;
23034   if (!arg3) {
23035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23036     return ;
23037   }
23038   {
23039     try {
23040       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23041     } CALL_CATCH_EXCEPTION();
23042   }
23043
23044 }
23045
23046
23047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23049   Dali::Radian *arg2 = 0 ;
23050   Dali::Vector3 *arg3 = 0 ;
23051
23052   arg1 = (Dali::Actor *)jarg1;
23053   arg2 = (Dali::Radian *)jarg2;
23054   if (!arg2) {
23055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23056     return ;
23057   }
23058   arg3 = (Dali::Vector3 *)jarg3;
23059   if (!arg3) {
23060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23061     return ;
23062   }
23063   {
23064     try {
23065       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
23066     } CALL_CATCH_EXCEPTION();
23067   }
23068
23069 }
23070
23071
23072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
23073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23074   Dali::Quaternion *arg2 = 0 ;
23075
23076   arg1 = (Dali::Actor *)jarg1;
23077   arg2 = (Dali::Quaternion *)jarg2;
23078   if (!arg2) {
23079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23080     return ;
23081   }
23082   {
23083     try {
23084       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
23085     } CALL_CATCH_EXCEPTION();
23086   }
23087
23088 }
23089
23090
23091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23092   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23093   Dali::Degree *arg2 = 0 ;
23094   Dali::Vector3 *arg3 = 0 ;
23095
23096   arg1 = (Dali::Actor *)jarg1;
23097   arg2 = (Dali::Degree *)jarg2;
23098   if (!arg2) {
23099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
23100     return ;
23101   }
23102   arg3 = (Dali::Vector3 *)jarg3;
23103   if (!arg3) {
23104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23105     return ;
23106   }
23107   {
23108     try {
23109       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
23110     } CALL_CATCH_EXCEPTION();
23111   }
23112
23113 }
23114
23115
23116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23118   Dali::Radian *arg2 = 0 ;
23119   Dali::Vector3 *arg3 = 0 ;
23120
23121   arg1 = (Dali::Actor *)jarg1;
23122   arg2 = (Dali::Radian *)jarg2;
23123   if (!arg2) {
23124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
23125     return ;
23126   }
23127   arg3 = (Dali::Vector3 *)jarg3;
23128   if (!arg3) {
23129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23130     return ;
23131   }
23132   {
23133     try {
23134       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
23135     } CALL_CATCH_EXCEPTION();
23136   }
23137
23138 }
23139
23140
23141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
23142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23143   Dali::Quaternion *arg2 = 0 ;
23144
23145   arg1 = (Dali::Actor *)jarg1;
23146   arg2 = (Dali::Quaternion *)jarg2;
23147   if (!arg2) {
23148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
23149     return ;
23150   }
23151   {
23152     try {
23153       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
23154     } CALL_CATCH_EXCEPTION();
23155   }
23156
23157 }
23158
23159
23160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
23161   void * jresult ;
23162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23163   Dali::Quaternion result;
23164
23165   arg1 = (Dali::Actor *)jarg1;
23166   {
23167     try {
23168       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
23169     } CALL_CATCH_EXCEPTION(0);
23170   }
23171
23172   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23173   return jresult;
23174 }
23175
23176
23177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
23178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23179   bool arg2 ;
23180
23181   arg1 = (Dali::Actor *)jarg1;
23182   arg2 = jarg2 ? true : false;
23183   {
23184     try {
23185       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
23186     } CALL_CATCH_EXCEPTION();
23187   }
23188
23189 }
23190
23191
23192 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
23193   bool jresult ;
23194   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23195   bool result;
23196
23197   arg1 = (Dali::Actor *)jarg1;
23198   {
23199     try {
23200       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
23201     } CALL_CATCH_EXCEPTION(0);
23202   }
23203
23204   jresult = result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
23210   void * jresult ;
23211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23212   Dali::Quaternion result;
23213
23214   arg1 = (Dali::Actor *)jarg1;
23215   {
23216     try {
23217       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
23218     } CALL_CATCH_EXCEPTION(0);
23219   }
23220
23221   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
23227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23228   float arg2 ;
23229
23230   arg1 = (Dali::Actor *)jarg1;
23231   arg2 = (float)jarg2;
23232   {
23233     try {
23234       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
23235     } CALL_CATCH_EXCEPTION();
23236   }
23237
23238 }
23239
23240
23241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
23242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23243   float arg2 ;
23244   float arg3 ;
23245   float arg4 ;
23246
23247   arg1 = (Dali::Actor *)jarg1;
23248   arg2 = (float)jarg2;
23249   arg3 = (float)jarg3;
23250   arg4 = (float)jarg4;
23251   {
23252     try {
23253       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
23254     } CALL_CATCH_EXCEPTION();
23255   }
23256
23257 }
23258
23259
23260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
23261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23262   Dali::Vector3 *arg2 = 0 ;
23263
23264   arg1 = (Dali::Actor *)jarg1;
23265   arg2 = (Dali::Vector3 *)jarg2;
23266   if (!arg2) {
23267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23268     return ;
23269   }
23270   {
23271     try {
23272       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
23273     } CALL_CATCH_EXCEPTION();
23274   }
23275
23276 }
23277
23278
23279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
23280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23281   Dali::Vector3 *arg2 = 0 ;
23282
23283   arg1 = (Dali::Actor *)jarg1;
23284   arg2 = (Dali::Vector3 *)jarg2;
23285   if (!arg2) {
23286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23287     return ;
23288   }
23289   {
23290     try {
23291       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
23292     } CALL_CATCH_EXCEPTION();
23293   }
23294
23295 }
23296
23297
23298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
23299   void * jresult ;
23300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23301   Dali::Vector3 result;
23302
23303   arg1 = (Dali::Actor *)jarg1;
23304   {
23305     try {
23306       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
23307     } CALL_CATCH_EXCEPTION(0);
23308   }
23309
23310   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
23316   void * jresult ;
23317   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23318   Dali::Vector3 result;
23319
23320   arg1 = (Dali::Actor *)jarg1;
23321   {
23322     try {
23323       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
23324     } CALL_CATCH_EXCEPTION(0);
23325   }
23326
23327   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23328   return jresult;
23329 }
23330
23331
23332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
23333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23334   bool arg2 ;
23335
23336   arg1 = (Dali::Actor *)jarg1;
23337   arg2 = jarg2 ? true : false;
23338   {
23339     try {
23340       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
23341     } CALL_CATCH_EXCEPTION();
23342   }
23343
23344 }
23345
23346
23347 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
23348   bool jresult ;
23349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23350   bool result;
23351
23352   arg1 = (Dali::Actor *)jarg1;
23353   {
23354     try {
23355       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
23356     } CALL_CATCH_EXCEPTION(0);
23357   }
23358
23359   jresult = result;
23360   return jresult;
23361 }
23362
23363
23364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
23365   void * jresult ;
23366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23367   Dali::Matrix result;
23368
23369   arg1 = (Dali::Actor *)jarg1;
23370   {
23371     try {
23372       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
23373     } CALL_CATCH_EXCEPTION(0);
23374   }
23375
23376   jresult = new Dali::Matrix((const Dali::Matrix &)result);
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
23382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23383   bool arg2 ;
23384
23385   arg1 = (Dali::Actor *)jarg1;
23386   arg2 = jarg2 ? true : false;
23387   {
23388     try {
23389       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
23390     } CALL_CATCH_EXCEPTION();
23391   }
23392
23393 }
23394
23395
23396 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
23397   bool jresult ;
23398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23399   bool result;
23400
23401   arg1 = (Dali::Actor *)jarg1;
23402   {
23403     try {
23404       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
23405     } CALL_CATCH_EXCEPTION(0);
23406   }
23407
23408   jresult = result;
23409   return jresult;
23410 }
23411
23412
23413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
23414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23415   float arg2 ;
23416
23417   arg1 = (Dali::Actor *)jarg1;
23418   arg2 = (float)jarg2;
23419   {
23420     try {
23421       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
23422     } CALL_CATCH_EXCEPTION();
23423   }
23424
23425 }
23426
23427
23428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
23429   float jresult ;
23430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23431   float result;
23432
23433   arg1 = (Dali::Actor *)jarg1;
23434   {
23435     try {
23436       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
23437     } CALL_CATCH_EXCEPTION(0);
23438   }
23439
23440   jresult = result;
23441   return jresult;
23442 }
23443
23444
23445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
23446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23447   Dali::Vector4 *arg2 = 0 ;
23448
23449   arg1 = (Dali::Actor *)jarg1;
23450   arg2 = (Dali::Vector4 *)jarg2;
23451   if (!arg2) {
23452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
23453     return ;
23454   }
23455   {
23456     try {
23457       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
23458     } CALL_CATCH_EXCEPTION();
23459   }
23460
23461 }
23462
23463
23464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
23465   void * jresult ;
23466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23467   Dali::Vector4 result;
23468
23469   arg1 = (Dali::Actor *)jarg1;
23470   {
23471     try {
23472       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
23473     } CALL_CATCH_EXCEPTION(0);
23474   }
23475
23476   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
23477   return jresult;
23478 }
23479
23480
23481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
23482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23483   Dali::ColorMode arg2 ;
23484
23485   arg1 = (Dali::Actor *)jarg1;
23486   arg2 = (Dali::ColorMode)jarg2;
23487   {
23488     try {
23489       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
23490     } CALL_CATCH_EXCEPTION();
23491   }
23492
23493 }
23494
23495
23496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
23497   int jresult ;
23498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23499   Dali::ColorMode result;
23500
23501   arg1 = (Dali::Actor *)jarg1;
23502   {
23503     try {
23504       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
23505     } CALL_CATCH_EXCEPTION(0);
23506   }
23507
23508   jresult = (int)result;
23509   return jresult;
23510 }
23511
23512
23513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
23514   void * jresult ;
23515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23516   Dali::Vector4 result;
23517
23518   arg1 = (Dali::Actor *)jarg1;
23519   {
23520     try {
23521       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
23522     } CALL_CATCH_EXCEPTION(0);
23523   }
23524
23525   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
23531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23532   Dali::DrawMode::Type arg2 ;
23533
23534   arg1 = (Dali::Actor *)jarg1;
23535   arg2 = (Dali::DrawMode::Type)jarg2;
23536   {
23537     try {
23538       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
23539     } CALL_CATCH_EXCEPTION();
23540   }
23541
23542 }
23543
23544
23545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
23546   int jresult ;
23547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23548   Dali::DrawMode::Type result;
23549
23550   arg1 = (Dali::Actor *)jarg1;
23551   {
23552     try {
23553       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
23554     } CALL_CATCH_EXCEPTION(0);
23555   }
23556
23557   jresult = (int)result;
23558   return jresult;
23559 }
23560
23561
23562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
23563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23564   bool arg2 ;
23565
23566   arg1 = (Dali::Actor *)jarg1;
23567   arg2 = jarg2 ? true : false;
23568   {
23569     try {
23570       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
23571     } CALL_CATCH_EXCEPTION();
23572   }
23573
23574 }
23575
23576
23577 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
23578   bool jresult ;
23579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23580   bool result;
23581
23582   arg1 = (Dali::Actor *)jarg1;
23583   {
23584     try {
23585       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
23586     } CALL_CATCH_EXCEPTION(0);
23587   }
23588
23589   jresult = result;
23590   return jresult;
23591 }
23592
23593
23594 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
23595   bool jresult ;
23596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23597   float *arg2 = 0 ;
23598   float *arg3 = 0 ;
23599   float arg4 ;
23600   float arg5 ;
23601   bool result;
23602
23603   arg1 = (Dali::Actor *)jarg1;
23604   arg2 = (float *)jarg2;
23605   arg3 = (float *)jarg3;
23606   arg4 = (float)jarg4;
23607   arg5 = (float)jarg5;
23608   {
23609     try {
23610       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
23611     } CALL_CATCH_EXCEPTION(0);
23612   }
23613
23614   jresult = result;
23615   return jresult;
23616 }
23617
23618
23619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
23620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23621   bool arg2 ;
23622
23623   arg1 = (Dali::Actor *)jarg1;
23624   arg2 = jarg2 ? true : false;
23625   {
23626     try {
23627       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
23628     } CALL_CATCH_EXCEPTION();
23629   }
23630
23631 }
23632
23633
23634 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
23635   bool jresult ;
23636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23637   bool result;
23638
23639   arg1 = (Dali::Actor *)jarg1;
23640   {
23641     try {
23642       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
23643     } CALL_CATCH_EXCEPTION(0);
23644   }
23645
23646   jresult = result;
23647   return jresult;
23648 }
23649
23650
23651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
23652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23653   bool arg2 ;
23654
23655   arg1 = (Dali::Actor *)jarg1;
23656   arg2 = jarg2 ? true : false;
23657   {
23658     try {
23659       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
23660     } CALL_CATCH_EXCEPTION();
23661   }
23662
23663 }
23664
23665
23666 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
23667   bool jresult ;
23668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23669   bool result;
23670
23671   arg1 = (Dali::Actor *)jarg1;
23672   {
23673     try {
23674       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
23675     } CALL_CATCH_EXCEPTION(0);
23676   }
23677
23678   jresult = result;
23679   return jresult;
23680 }
23681
23682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
23683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23684   arg1 = (Dali::Actor *)actor;
23685   {
23686     try {
23687       (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
23688     } CALL_CATCH_EXCEPTION();
23689   }
23690 }
23691
23692
23693 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
23694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23695   bool result;
23696
23697   arg1 = (Dali::Actor *)actor;
23698   {
23699     try {
23700       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
23701     } CALL_CATCH_EXCEPTION(0);
23702   }
23703   return result;
23704 }
23705
23706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
23707   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23708   bool arg2 ;
23709
23710   arg1 = (Dali::Actor *)jarg1;
23711   arg2 = jarg2 ? true : false;
23712   {
23713     try {
23714       (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
23715     } CALL_CATCH_EXCEPTION();
23716   }
23717
23718 }
23719
23720
23721 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
23722   bool jresult ;
23723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23724   bool result;
23725
23726   arg1 = (Dali::Actor *)jarg1;
23727   {
23728     try {
23729       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
23730     } CALL_CATCH_EXCEPTION(0);
23731   }
23732
23733   jresult = result;
23734   return jresult;
23735 }
23736
23737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
23738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23739   Dali::ResizePolicy::Type arg2 ;
23740   Dali::Dimension::Type arg3 ;
23741
23742   arg1 = (Dali::Actor *)jarg1;
23743   arg2 = (Dali::ResizePolicy::Type)jarg2;
23744   arg3 = (Dali::Dimension::Type)jarg3;
23745   {
23746     try {
23747       (arg1)->SetResizePolicy(arg2,arg3);
23748     } CALL_CATCH_EXCEPTION();
23749   }
23750
23751 }
23752
23753
23754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
23755   int jresult ;
23756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23757   Dali::Dimension::Type arg2 ;
23758   Dali::ResizePolicy::Type result;
23759
23760   arg1 = (Dali::Actor *)jarg1;
23761   arg2 = (Dali::Dimension::Type)jarg2;
23762   {
23763     try {
23764       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23765     } CALL_CATCH_EXCEPTION(0);
23766   }
23767
23768   jresult = (int)result;
23769   return jresult;
23770 }
23771
23772
23773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23775   Dali::SizeScalePolicy::Type arg2 ;
23776
23777   arg1 = (Dali::Actor *)jarg1;
23778   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23779   {
23780     try {
23781       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23782     } CALL_CATCH_EXCEPTION();
23783   }
23784
23785 }
23786
23787
23788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23789   int jresult ;
23790   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23791   Dali::SizeScalePolicy::Type result;
23792
23793   arg1 = (Dali::Actor *)jarg1;
23794   {
23795     try {
23796       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23797     } CALL_CATCH_EXCEPTION(0);
23798   }
23799
23800   jresult = (int)result;
23801   return jresult;
23802 }
23803
23804
23805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23807   Dali::Vector3 *arg2 = 0 ;
23808
23809   arg1 = (Dali::Actor *)jarg1;
23810   arg2 = (Dali::Vector3 *)jarg2;
23811   if (!arg2) {
23812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23813     return ;
23814   }
23815   {
23816     try {
23817       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23818     } CALL_CATCH_EXCEPTION();
23819   }
23820
23821 }
23822
23823
23824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23825   void * jresult ;
23826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23827   Dali::Vector3 result;
23828
23829   arg1 = (Dali::Actor *)jarg1;
23830   {
23831     try {
23832       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23833     } CALL_CATCH_EXCEPTION(0);
23834   }
23835
23836   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23837   return jresult;
23838 }
23839
23840
23841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23842   float jresult ;
23843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23844   float arg2 ;
23845   float result;
23846
23847   arg1 = (Dali::Actor *)jarg1;
23848   arg2 = (float)jarg2;
23849   {
23850     try {
23851       result = (float)(arg1)->GetHeightForWidth(arg2);
23852     } CALL_CATCH_EXCEPTION(0);
23853   }
23854
23855   jresult = result;
23856   return jresult;
23857 }
23858
23859
23860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23861   float jresult ;
23862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23863   float arg2 ;
23864   float result;
23865
23866   arg1 = (Dali::Actor *)jarg1;
23867   arg2 = (float)jarg2;
23868   {
23869     try {
23870       result = (float)(arg1)->GetWidthForHeight(arg2);
23871     } CALL_CATCH_EXCEPTION(0);
23872   }
23873
23874   jresult = result;
23875   return jresult;
23876 }
23877
23878
23879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23880   float jresult ;
23881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23882   Dali::Dimension::Type arg2 ;
23883   float result;
23884
23885   arg1 = (Dali::Actor *)jarg1;
23886   arg2 = (Dali::Dimension::Type)jarg2;
23887   {
23888     try {
23889       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23890     } CALL_CATCH_EXCEPTION(0);
23891   }
23892
23893   jresult = result;
23894   return jresult;
23895 }
23896
23897
23898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23900   Dali::Padding *arg2 = 0 ;
23901
23902   arg1 = (Dali::Actor *)jarg1;
23903   arg2 = (Dali::Padding *)jarg2;
23904   if (!arg2) {
23905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23906     return ;
23907   }
23908   {
23909     try {
23910       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23911     } CALL_CATCH_EXCEPTION();
23912   }
23913
23914 }
23915
23916
23917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23919   Dali::Padding *arg2 = 0 ;
23920
23921   arg1 = (Dali::Actor *)jarg1;
23922   arg2 = (Dali::Padding *)jarg2;
23923   if (!arg2) {
23924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23925     return ;
23926   }
23927   {
23928     try {
23929       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23930     } CALL_CATCH_EXCEPTION();
23931   }
23932
23933 }
23934
23935
23936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23938   Dali::Vector2 *arg2 = 0 ;
23939
23940   arg1 = (Dali::Actor *)jarg1;
23941   arg2 = (Dali::Vector2 *)jarg2;
23942   if (!arg2) {
23943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23944     return ;
23945   }
23946   {
23947     try {
23948       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23949     } CALL_CATCH_EXCEPTION();
23950   }
23951
23952 }
23953
23954
23955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23956   void * jresult ;
23957   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23958   Dali::Vector2 result;
23959
23960   arg1 = (Dali::Actor *)jarg1;
23961   {
23962     try {
23963       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23964     } CALL_CATCH_EXCEPTION(0);
23965   }
23966
23967   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23968   return jresult;
23969 }
23970
23971
23972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23974   Dali::Vector2 *arg2 = 0 ;
23975
23976   arg1 = (Dali::Actor *)jarg1;
23977   arg2 = (Dali::Vector2 *)jarg2;
23978   if (!arg2) {
23979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23980     return ;
23981   }
23982   {
23983     try {
23984       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23985     } CALL_CATCH_EXCEPTION();
23986   }
23987
23988 }
23989
23990
23991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23992   void * jresult ;
23993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23994   Dali::Vector2 result;
23995
23996   arg1 = (Dali::Actor *)jarg1;
23997   {
23998     try {
23999       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
24000     } CALL_CATCH_EXCEPTION(0);
24001   }
24002
24003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24004   return jresult;
24005 }
24006
24007
24008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
24009   int jresult ;
24010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24011   int result;
24012
24013   arg1 = (Dali::Actor *)jarg1;
24014   {
24015     try {
24016       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
24017       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
24018     } CALL_CATCH_EXCEPTION(0);
24019   }
24020
24021   jresult = result;
24022   return jresult;
24023 }
24024
24025
24026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
24027   unsigned int jresult ;
24028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24029   Dali::Renderer *arg2 = 0 ;
24030   unsigned int result;
24031
24032   arg1 = (Dali::Actor *)jarg1;
24033   arg2 = (Dali::Renderer *)jarg2;
24034   if (!arg2) {
24035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24036     return 0;
24037   }
24038   {
24039     try {
24040       result = (unsigned int)(arg1)->AddRenderer(*arg2);
24041     } CALL_CATCH_EXCEPTION(0);
24042   }
24043
24044   jresult = result;
24045   return jresult;
24046 }
24047
24048
24049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
24050   unsigned int jresult ;
24051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24052   unsigned int result;
24053
24054   arg1 = (Dali::Actor *)jarg1;
24055   {
24056     try {
24057       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
24058     } CALL_CATCH_EXCEPTION(0);
24059   }
24060
24061   jresult = result;
24062   return jresult;
24063 }
24064
24065
24066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
24067   void * jresult ;
24068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24069   unsigned int arg2 ;
24070   Dali::Renderer result;
24071
24072   arg1 = (Dali::Actor *)jarg1;
24073   arg2 = (unsigned int)jarg2;
24074   {
24075     try {
24076       result = (arg1)->GetRendererAt(arg2);
24077     } CALL_CATCH_EXCEPTION(0);
24078   }
24079
24080   jresult = new Dali::Renderer((const Dali::Renderer &)result);
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
24086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24087   Dali::Renderer *arg2 = 0 ;
24088
24089   arg1 = (Dali::Actor *)jarg1;
24090   arg2 = (Dali::Renderer *)jarg2;
24091   if (!arg2) {
24092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
24093     return ;
24094   }
24095   {
24096     try {
24097       (arg1)->RemoveRenderer(*arg2);
24098     } CALL_CATCH_EXCEPTION();
24099   }
24100
24101 }
24102
24103
24104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
24105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24106   unsigned int arg2 ;
24107
24108   arg1 = (Dali::Actor *)jarg1;
24109   arg2 = (unsigned int)jarg2;
24110   {
24111     try {
24112       (arg1)->RemoveRenderer(arg2);
24113     } CALL_CATCH_EXCEPTION();
24114   }
24115
24116 }
24117
24118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
24119   void * jresult ;
24120   Dali::Actor arg1 ;
24121   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24122   Dali::Actor::TouchEventSignalType *result = 0 ;
24123
24124
24125   argp1 = (Dali::Actor *)jarg1;
24126   if (!argp1) {
24127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24128     return 0;
24129   }
24130   arg1 = *argp1;
24131   {
24132     try {
24133       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
24134     } CALL_CATCH_EXCEPTION(0);
24135   }
24136
24137   jresult = (void *)result;
24138   return jresult;
24139 }
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
24142   void * jresult ;
24143   Dali::Actor arg1 ;
24144   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24145   Dali::Actor::TouchEventSignalType *result = 0 ;
24146
24147
24148   argp1 = (Dali::Actor *)jarg1;
24149   if (!argp1) {
24150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24151     return 0;
24152   }
24153   arg1 = *argp1;
24154   {
24155     try {
24156       result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
24157     } CALL_CATCH_EXCEPTION(0);
24158   }
24159
24160   jresult = (void *)result;
24161   return jresult;
24162 }
24163
24164
24165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
24166   void * jresult ;
24167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24168   Dali::Actor::TouchEventSignalType *result = 0 ;
24169
24170   arg1 = (Dali::Actor *)jarg1;
24171   {
24172     try {
24173       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
24174     } CALL_CATCH_EXCEPTION(0);
24175   }
24176
24177   jresult = (void *)result;
24178   return jresult;
24179 }
24180
24181
24182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
24183   void * jresult ;
24184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24185   Dali::Actor::HoverSignalType *result = 0 ;
24186
24187   arg1 = (Dali::Actor *)jarg1;
24188   {
24189     try {
24190       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
24191     } CALL_CATCH_EXCEPTION(0);
24192   }
24193
24194   jresult = (void *)result;
24195   return jresult;
24196 }
24197
24198
24199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
24200   void * jresult ;
24201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24202   Dali::Actor::WheelEventSignalType *result = 0 ;
24203
24204   arg1 = (Dali::Actor *)jarg1;
24205   {
24206     try {
24207       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24208     } CALL_CATCH_EXCEPTION(0);
24209   }
24210
24211   jresult = (void *)result;
24212   return jresult;
24213 }
24214
24215
24216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
24217   void * jresult ;
24218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24219   Dali::Actor::OnSceneSignalType *result = 0 ;
24220
24221   arg1 = (Dali::Actor *)jarg1;
24222   {
24223     try {
24224       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
24225     } CALL_CATCH_EXCEPTION(0);
24226   }
24227
24228   jresult = (void *)result;
24229   return jresult;
24230 }
24231
24232
24233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
24234   void * jresult ;
24235   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24236   Dali::Actor::OffSceneSignalType *result = 0 ;
24237
24238   arg1 = (Dali::Actor *)jarg1;
24239   {
24240     try {
24241       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
24242     } CALL_CATCH_EXCEPTION(0);
24243   }
24244
24245   jresult = (void *)result;
24246   return jresult;
24247 }
24248
24249
24250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
24251   void * jresult ;
24252   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24253   Dali::Actor::OnRelayoutSignalType *result = 0 ;
24254
24255   arg1 = (Dali::Actor *)jarg1;
24256   {
24257     try {
24258       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
24259     } CALL_CATCH_EXCEPTION(0);
24260   }
24261
24262   jresult = (void *)result;
24263   return jresult;
24264 }
24265
24266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
24267   Dali::Actor arg1 ;
24268   bool arg2;
24269   Dali::Actor *argp1 = (Dali::Actor *) 0 ;
24270
24271
24272   argp1 = (Dali::Actor *)jarg1;
24273   if (!argp1) {
24274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24275     return;
24276   }
24277   arg1 = *argp1;
24278   arg2 = jarg2;
24279   {
24280     try {
24281       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
24282     } CALL_CATCH_EXCEPTION();
24283   }
24284   return;
24285 }
24286
24287 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
24288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24289   arg1 = (Dali::Actor *)jarg1;
24290   Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
24291   {
24292     try {
24293       (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
24294     } CALL_CATCH_EXCEPTION();
24295   }
24296 }
24297
24298 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
24299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
24300   arg1 = (Dali::Actor *)jarg1;
24301
24302   Rect<int32_t> result;
24303   {
24304     try {
24305       result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
24306       *jarg2 = result.left;
24307       *jarg3 = result.right;
24308       *jarg4 = result.bottom;
24309       *jarg5 = result.top;
24310     } CALL_CATCH_EXCEPTION();
24311   }
24312 }
24313
24314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
24315   Dali::Actor *arg1 = 0 ;
24316
24317   arg1 = (Dali::Actor *)jarg1;
24318   if (!arg1) {
24319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24320     return ;
24321   }
24322   {
24323     try {
24324       Dali::UnparentAndReset(*arg1);
24325     } CALL_CATCH_EXCEPTION();
24326   }
24327
24328 }
24329
24330
24331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
24332   int jresult ;
24333   int result;
24334
24335   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
24336   jresult = (int)result;
24337   return jresult;
24338 }
24339
24340
24341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
24342   int jresult ;
24343   int result;
24344
24345   result = (int)Dali::Layer::Property::CLIPPING_BOX;
24346   jresult = (int)result;
24347   return jresult;
24348 }
24349
24350
24351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
24352   int jresult ;
24353   int result;
24354
24355   result = (int)Dali::Layer::Property::BEHAVIOR;
24356   jresult = (int)result;
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
24362   void * jresult ;
24363   Dali::Layer::Property *result = 0 ;
24364
24365   {
24366     try {
24367       result = (Dali::Layer::Property *)new Dali::Layer::Property();
24368     } CALL_CATCH_EXCEPTION(0);
24369   }
24370
24371   jresult = (void *)result;
24372   return jresult;
24373 }
24374
24375
24376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
24377   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
24378
24379   arg1 = (Dali::Layer::Property *)jarg1;
24380   {
24381     try {
24382       delete arg1;
24383     } CALL_CATCH_EXCEPTION();
24384   }
24385
24386 }
24387
24388
24389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
24390   void * jresult ;
24391   Dali::Layer *result = 0 ;
24392
24393   {
24394     try {
24395       result = (Dali::Layer *)new Dali::Layer();
24396     } CALL_CATCH_EXCEPTION(0);
24397   }
24398
24399   jresult = (void *)result;
24400   return jresult;
24401 }
24402
24403
24404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
24405   void * jresult ;
24406   Dali::Layer result;
24407
24408   {
24409     try {
24410       result = Dali::Layer::New();
24411     } CALL_CATCH_EXCEPTION(0);
24412   }
24413
24414   jresult = new Dali::Layer((const Dali::Layer &)result);
24415   return jresult;
24416 }
24417
24418
24419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
24420   void * jresult ;
24421   Dali::BaseHandle arg1 ;
24422   Dali::BaseHandle *argp1 ;
24423   Dali::Layer result;
24424
24425   argp1 = (Dali::BaseHandle *)jarg1;
24426   if (!argp1) {
24427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24428     return 0;
24429   }
24430   arg1 = *argp1;
24431   {
24432     try {
24433       result = Dali::Layer::DownCast(arg1);
24434     } CALL_CATCH_EXCEPTION(0);
24435   }
24436
24437   jresult = new Dali::Layer((const Dali::Layer &)result);
24438   return jresult;
24439 }
24440
24441
24442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
24443   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24444
24445   arg1 = (Dali::Layer *)jarg1;
24446   {
24447     try {
24448       delete arg1;
24449     } CALL_CATCH_EXCEPTION();
24450   }
24451
24452 }
24453
24454
24455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
24456   void * jresult ;
24457   Dali::Layer *arg1 = 0 ;
24458   Dali::Layer *result = 0 ;
24459
24460   arg1 = (Dali::Layer *)jarg1;
24461   if (!arg1) {
24462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
24463     return 0;
24464   }
24465   {
24466     try {
24467       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
24468     } CALL_CATCH_EXCEPTION(0);
24469   }
24470
24471   jresult = (void *)result;
24472   return jresult;
24473 }
24474
24475
24476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
24477   void * jresult ;
24478   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24479   Dali::Layer *arg2 = 0 ;
24480   Dali::Layer *result = 0 ;
24481
24482   arg1 = (Dali::Layer *)jarg1;
24483   arg2 = (Dali::Layer *)jarg2;
24484   if (!arg2) {
24485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
24486     return 0;
24487   }
24488   {
24489     try {
24490       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
24491     } CALL_CATCH_EXCEPTION(0);
24492   }
24493
24494   jresult = (void *)result;
24495   return jresult;
24496 }
24497
24498
24499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
24500   unsigned int jresult ;
24501   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24502   unsigned int result;
24503
24504   arg1 = (Dali::Layer *)jarg1;
24505   {
24506     try {
24507       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
24508     } CALL_CATCH_EXCEPTION(0);
24509   }
24510
24511   jresult = result;
24512   return jresult;
24513 }
24514
24515
24516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
24517   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24518
24519   arg1 = (Dali::Layer *)jarg1;
24520   {
24521     try {
24522       (arg1)->Raise();
24523     } CALL_CATCH_EXCEPTION();
24524   }
24525
24526 }
24527
24528
24529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
24530   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24531
24532   arg1 = (Dali::Layer *)jarg1;
24533   {
24534     try {
24535       (arg1)->Lower();
24536     } CALL_CATCH_EXCEPTION();
24537   }
24538
24539 }
24540
24541
24542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
24543   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24544   Dali::Layer arg2 ;
24545   Dali::Layer *argp2 ;
24546
24547   arg1 = (Dali::Layer *)jarg1;
24548   argp2 = (Dali::Layer *)jarg2;
24549   if (!argp2) {
24550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
24551     return ;
24552   }
24553   arg2 = *argp2;
24554   {
24555     try {
24556       (arg1)->RaiseAbove(arg2);
24557     } CALL_CATCH_EXCEPTION();
24558   }
24559
24560 }
24561
24562
24563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
24564   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24565   Dali::Layer arg2 ;
24566   Dali::Layer *argp2 ;
24567
24568   arg1 = (Dali::Layer *)jarg1;
24569   argp2 = (Dali::Layer *)jarg2;
24570   if (!argp2) {
24571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
24572     return ;
24573   }
24574   arg2 = *argp2;
24575   {
24576     try {
24577       (arg1)->LowerBelow(arg2);
24578     } CALL_CATCH_EXCEPTION();
24579   }
24580
24581 }
24582
24583
24584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
24585   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24586
24587   arg1 = (Dali::Layer *)jarg1;
24588   {
24589     try {
24590       (arg1)->RaiseToTop();
24591     } CALL_CATCH_EXCEPTION();
24592   }
24593
24594 }
24595
24596
24597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
24598   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24599
24600   arg1 = (Dali::Layer *)jarg1;
24601   {
24602     try {
24603       (arg1)->LowerToBottom();
24604     } CALL_CATCH_EXCEPTION();
24605   }
24606
24607 }
24608
24609
24610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
24611   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24612   Dali::Layer arg2 ;
24613   Dali::Layer *argp2 ;
24614
24615   arg1 = (Dali::Layer *)jarg1;
24616   argp2 = (Dali::Layer *)jarg2;
24617   if (!argp2) {
24618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
24619     return ;
24620   }
24621   arg2 = *argp2;
24622   {
24623     try {
24624       (arg1)->MoveAbove(arg2);
24625     } CALL_CATCH_EXCEPTION();
24626   }
24627
24628 }
24629
24630
24631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
24632   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24633   Dali::Layer arg2 ;
24634   Dali::Layer *argp2 ;
24635
24636   arg1 = (Dali::Layer *)jarg1;
24637   argp2 = (Dali::Layer *)jarg2;
24638   if (!argp2) {
24639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
24640     return ;
24641   }
24642   arg2 = *argp2;
24643   {
24644     try {
24645       (arg1)->MoveBelow(arg2);
24646     } CALL_CATCH_EXCEPTION();
24647   }
24648
24649 }
24650
24651
24652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
24653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24654   Dali::Layer::Behavior arg2 ;
24655
24656   arg1 = (Dali::Layer *)jarg1;
24657   arg2 = (Dali::Layer::Behavior)jarg2;
24658   {
24659     try {
24660       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
24661     } CALL_CATCH_EXCEPTION();
24662   }
24663
24664 }
24665
24666
24667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
24668   int jresult ;
24669   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24670   Dali::Layer::Behavior result;
24671
24672   arg1 = (Dali::Layer *)jarg1;
24673   {
24674     try {
24675       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
24676     } CALL_CATCH_EXCEPTION(0);
24677   }
24678
24679   jresult = (int)result;
24680   return jresult;
24681 }
24682
24683
24684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
24685   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24686   bool arg2 ;
24687
24688   arg1 = (Dali::Layer *)jarg1;
24689   arg2 = jarg2 ? true : false;
24690   {
24691     try {
24692       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
24693     } CALL_CATCH_EXCEPTION();
24694   }
24695
24696 }
24697
24698
24699 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
24700   bool jresult ;
24701   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24702   bool result;
24703
24704   arg1 = (Dali::Layer *)jarg1;
24705   {
24706     try {
24707       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
24708     } CALL_CATCH_EXCEPTION(0);
24709   }
24710
24711   jresult = result;
24712   return jresult;
24713 }
24714
24715
24716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
24717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24718   int arg2 ;
24719   int arg3 ;
24720   int arg4 ;
24721   int arg5 ;
24722
24723   arg1 = (Dali::Layer *)jarg1;
24724   arg2 = (int)jarg2;
24725   arg3 = (int)jarg3;
24726   arg4 = (int)jarg4;
24727   arg5 = (int)jarg5;
24728   {
24729     try {
24730       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
24731     } CALL_CATCH_EXCEPTION();
24732   }
24733
24734 }
24735
24736
24737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
24738   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24739   Dali::ClippingBox arg2 ;
24740   Dali::ClippingBox *argp2 ;
24741
24742   arg1 = (Dali::Layer *)jarg1;
24743   argp2 = (Dali::ClippingBox *)jarg2;
24744   if (!argp2) {
24745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
24746     return ;
24747   }
24748   arg2 = *argp2;
24749   {
24750     try {
24751       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
24752     } CALL_CATCH_EXCEPTION();
24753   }
24754
24755 }
24756
24757
24758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
24759   void * jresult ;
24760   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24761   Dali::ClippingBox result;
24762
24763   arg1 = (Dali::Layer *)jarg1;
24764   {
24765     try {
24766       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
24767     } CALL_CATCH_EXCEPTION(0);
24768   }
24769
24770   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
24771   return jresult;
24772 }
24773
24774
24775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
24776   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24777   bool arg2 ;
24778
24779   arg1 = (Dali::Layer *)jarg1;
24780   arg2 = jarg2 ? true : false;
24781   {
24782     try {
24783       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
24784     } CALL_CATCH_EXCEPTION();
24785   }
24786
24787 }
24788
24789
24790 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
24791   bool jresult ;
24792   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24793   bool result;
24794
24795   arg1 = (Dali::Layer *)jarg1;
24796   {
24797     try {
24798       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
24799     } CALL_CATCH_EXCEPTION(0);
24800   }
24801
24802   jresult = result;
24803   return jresult;
24804 }
24805
24806
24807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
24808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24809   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
24810
24811   arg1 = (Dali::Layer *)jarg1;
24812   arg2 = (Dali::Layer::SortFunctionType)jarg2;
24813   {
24814     try {
24815       (arg1)->SetSortFunction(arg2);
24816     } CALL_CATCH_EXCEPTION();
24817   }
24818
24819 }
24820
24821
24822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
24823   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24824   bool arg2 ;
24825
24826   arg1 = (Dali::Layer *)jarg1;
24827   arg2 = jarg2 ? true : false;
24828   {
24829     try {
24830       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
24831     } CALL_CATCH_EXCEPTION();
24832   }
24833
24834 }
24835
24836
24837 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
24838   bool jresult ;
24839   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24840   bool result;
24841
24842   arg1 = (Dali::Layer *)jarg1;
24843   {
24844     try {
24845       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
24846     } CALL_CATCH_EXCEPTION(0);
24847   }
24848
24849   jresult = result;
24850   return jresult;
24851 }
24852
24853
24854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
24855   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24856   bool arg2 ;
24857
24858   arg1 = (Dali::Layer *)jarg1;
24859   arg2 = jarg2 ? true : false;
24860   {
24861     try {
24862       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24863     } CALL_CATCH_EXCEPTION();
24864   }
24865
24866 }
24867
24868
24869 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24870   bool jresult ;
24871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24872   bool result;
24873
24874   arg1 = (Dali::Layer *)jarg1;
24875   {
24876     try {
24877       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24878     } CALL_CATCH_EXCEPTION(0);
24879   }
24880
24881   jresult = result;
24882   return jresult;
24883 }
24884
24885
24886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24887   void * jresult ;
24888   Dali::Stage result;
24889
24890   {
24891     try {
24892       result = Dali::Stage::GetCurrent();
24893     } CALL_CATCH_EXCEPTION(0);
24894   }
24895
24896   jresult = new Dali::Stage((const Dali::Stage &)result);
24897   return jresult;
24898 }
24899
24900
24901 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24902   bool jresult ;
24903   bool result;
24904
24905   {
24906     try {
24907       result = (bool)Dali::Stage::IsInstalled();
24908     } CALL_CATCH_EXCEPTION(0);
24909   }
24910
24911   jresult = result;
24912   return jresult;
24913 }
24914
24915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
24916   void * jresult ;
24917   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24918   Dali::RenderTaskList result;
24919
24920   arg1 = (Dali::Stage *)jarg1;
24921   {
24922     try {
24923       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
24924     } CALL_CATCH_EXCEPTION(0);
24925   }
24926
24927   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24928   return jresult;
24929 }
24930
24931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24932   void * jresult ;
24933   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24934   Dali::Vector2 result;
24935
24936   arg1 = (Dali::Stage *)jarg1;
24937   {
24938     try {
24939       result = ((Dali::Stage const *)arg1)->GetDpi();
24940     } CALL_CATCH_EXCEPTION(0);
24941   }
24942
24943   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24949   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24950   float arg2 ;
24951
24952   arg1 = (Dali::Stage *)jarg1;
24953   arg2 = (float)jarg2;
24954   {
24955     try {
24956       (arg1)->KeepRendering(arg2);
24957     } CALL_CATCH_EXCEPTION();
24958   }
24959
24960 }
24961
24962
24963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24964   void * jresult ;
24965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24966   Dali::Stage::KeyEventSignalType *result = 0 ;
24967
24968   arg1 = (Dali::Stage *)jarg1;
24969   {
24970     try {
24971       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24972     } CALL_CATCH_EXCEPTION(0);
24973   }
24974
24975   jresult = (void *)result;
24976   return jresult;
24977 }
24978
24979
24980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24981   void * jresult ;
24982   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24983   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24984
24985   arg1 = (Dali::Stage *)jarg1;
24986   {
24987     try {
24988       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24989     } CALL_CATCH_EXCEPTION(0);
24990   }
24991
24992   jresult = (void *)result;
24993   return jresult;
24994 }
24995
24996
24997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24998   void * jresult ;
24999   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25000   Dali::Stage::TouchEventSignalType *result = 0 ;
25001
25002   arg1 = (Dali::Stage *)jarg1;
25003   {
25004     try {
25005       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
25006     } CALL_CATCH_EXCEPTION(0);
25007   }
25008
25009   jresult = (void *)result;
25010   return jresult;
25011 }
25012
25013
25014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
25015   void * jresult ;
25016   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25017   Dali::Stage::WheelEventSignalType *result = 0 ;
25018
25019   arg1 = (Dali::Stage *)jarg1;
25020   {
25021     try {
25022       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
25023     } CALL_CATCH_EXCEPTION(0);
25024   }
25025
25026   jresult = (void *)result;
25027   return jresult;
25028 }
25029
25030
25031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
25032   void * jresult ;
25033   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25034   Dali::Stage::ContextStatusSignal *result = 0 ;
25035
25036   arg1 = (Dali::Stage *)jarg1;
25037   {
25038     try {
25039       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
25040     } CALL_CATCH_EXCEPTION(0);
25041   }
25042
25043   jresult = (void *)result;
25044   return jresult;
25045 }
25046
25047
25048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
25049   void * jresult ;
25050   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25051   Dali::Stage::ContextStatusSignal *result = 0 ;
25052
25053   arg1 = (Dali::Stage *)jarg1;
25054   {
25055     try {
25056       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
25057     } CALL_CATCH_EXCEPTION(0);
25058   }
25059
25060   jresult = (void *)result;
25061   return jresult;
25062 }
25063
25064
25065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
25066   void * jresult ;
25067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25068   Dali::Stage::SceneCreatedSignalType *result = 0 ;
25069
25070   arg1 = (Dali::Stage *)jarg1;
25071   {
25072     try {
25073       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
25074     } CALL_CATCH_EXCEPTION(0);
25075   }
25076
25077   jresult = (void *)result;
25078   return jresult;
25079 }
25080
25081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
25082   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25083   Dali::DevelStage::Rendering arg2 ;
25084
25085   arg1 = (Dali::Stage *)jarg1;
25086   arg2 = (Dali::DevelStage::Rendering)jarg2;
25087   {
25088     try {
25089       DevelStage::SetRenderingBehavior(*arg1,arg2);
25090     } CALL_CATCH_EXCEPTION();
25091   }
25092
25093 }
25094
25095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
25096
25097   int jresult ;
25098   int result ;
25099   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
25100
25101   arg1 = (Dali::Stage *)jarg1;
25102   {
25103     try {
25104       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
25105     } CALL_CATCH_EXCEPTION(0);
25106   }
25107
25108   jresult = result;
25109   return jresult;
25110 }
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
25113   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
25114
25115   arg1 = (Dali::RelayoutContainer *)jarg1;
25116   {
25117     try {
25118       delete arg1;
25119     } CALL_CATCH_EXCEPTION();
25120   }
25121
25122 }
25123
25124
25125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
25126   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
25127   Dali::Actor *arg2 = 0 ;
25128   Dali::Vector2 *arg3 = 0 ;
25129
25130   arg1 = (Dali::RelayoutContainer *)jarg1;
25131   arg2 = (Dali::Actor *)jarg2;
25132   if (!arg2) {
25133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
25134     return ;
25135   }
25136   arg3 = (Dali::Vector2 *)jarg3;
25137   if (!arg3) {
25138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25139     return ;
25140   }
25141   {
25142     try {
25143       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
25144     } CALL_CATCH_EXCEPTION();
25145   }
25146
25147 }
25148
25149
25150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
25151   void * jresult ;
25152   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25153   Dali::CustomActor result;
25154
25155   arg1 = (Dali::CustomActorImpl *)jarg1;
25156   {
25157     try {
25158       result = ((Dali::CustomActorImpl const *)arg1)->Self();
25159     } CALL_CATCH_EXCEPTION(0);
25160   }
25161
25162   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
25163   return jresult;
25164 }
25165
25166
25167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
25168   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25169   int arg2 ;
25170
25171   arg1 = (Dali::CustomActorImpl *)jarg1;
25172   arg2 = (int)jarg2;
25173   {
25174     try {
25175       (arg1)->OnSceneConnection(arg2);
25176     } CALL_CATCH_EXCEPTION();
25177   }
25178
25179 }
25180
25181
25182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
25183   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25184
25185   arg1 = (Dali::CustomActorImpl *)jarg1;
25186   {
25187     try {
25188       (arg1)->OnSceneDisconnection();
25189     } CALL_CATCH_EXCEPTION();
25190   }
25191
25192 }
25193
25194
25195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
25196   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25197   Dali::Actor *arg2 = 0 ;
25198
25199   arg1 = (Dali::CustomActorImpl *)jarg1;
25200   arg2 = (Dali::Actor *)jarg2;
25201   if (!arg2) {
25202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25203     return ;
25204   }
25205   {
25206     try {
25207       (arg1)->OnChildAdd(*arg2);
25208     } CALL_CATCH_EXCEPTION();
25209   }
25210
25211 }
25212
25213
25214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
25215   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25216   Dali::Actor *arg2 = 0 ;
25217
25218   arg1 = (Dali::CustomActorImpl *)jarg1;
25219   arg2 = (Dali::Actor *)jarg2;
25220   if (!arg2) {
25221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
25222     return ;
25223   }
25224   {
25225     try {
25226       (arg1)->OnChildRemove(*arg2);
25227     } CALL_CATCH_EXCEPTION();
25228   }
25229
25230 }
25231
25232
25233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
25234   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25235   Dali::Property::Index arg2 ;
25236   Dali::Property::Value arg3 ;
25237   Dali::Property::Value *argp3 ;
25238
25239   arg1 = (Dali::CustomActorImpl *)jarg1;
25240   arg2 = (Dali::Property::Index)jarg2;
25241   argp3 = (Dali::Property::Value *)jarg3;
25242   if (!argp3) {
25243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
25244     return ;
25245   }
25246   arg3 = *argp3;
25247   {
25248     try {
25249       (arg1)->OnPropertySet(arg2,arg3);
25250     } CALL_CATCH_EXCEPTION();
25251   }
25252
25253 }
25254
25255
25256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
25257   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25258   Dali::Vector3 *arg2 = 0 ;
25259
25260   arg1 = (Dali::CustomActorImpl *)jarg1;
25261   arg2 = (Dali::Vector3 *)jarg2;
25262   if (!arg2) {
25263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25264     return ;
25265   }
25266   {
25267     try {
25268       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
25269     } CALL_CATCH_EXCEPTION();
25270   }
25271
25272 }
25273
25274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
25275   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25276   Dali::Animation *arg2 = 0 ;
25277   Dali::Vector3 *arg3 = 0 ;
25278
25279   arg1 = (Dali::CustomActorImpl *)jarg1;
25280   arg2 = (Dali::Animation *)jarg2;
25281   if (!arg2) {
25282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
25283     return ;
25284   }
25285   arg3 = (Dali::Vector3 *)jarg3;
25286   if (!arg3) {
25287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25288     return ;
25289   }
25290   {
25291     try {
25292       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
25293     } CALL_CATCH_EXCEPTION();
25294   }
25295 }
25296
25297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
25298   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25299   Dali::Vector2 *arg2 = 0 ;
25300   Dali::RelayoutContainer *arg3 = 0 ;
25301
25302   arg1 = (Dali::CustomActorImpl *)jarg1;
25303   arg2 = (Dali::Vector2 *)jarg2;
25304   if (!arg2) {
25305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
25306     return ;
25307   }
25308   arg3 = (Dali::RelayoutContainer *)jarg3;
25309   if (!arg3) {
25310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
25311     return ;
25312   }
25313   {
25314     try {
25315       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
25316     } CALL_CATCH_EXCEPTION();
25317   }
25318
25319 }
25320
25321
25322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
25323   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25324   Dali::ResizePolicy::Type arg2 ;
25325   Dali::Dimension::Type arg3 ;
25326
25327   arg1 = (Dali::CustomActorImpl *)jarg1;
25328   arg2 = (Dali::ResizePolicy::Type)jarg2;
25329   arg3 = (Dali::Dimension::Type)jarg3;
25330   {
25331     try {
25332       (arg1)->OnSetResizePolicy(arg2,arg3);
25333     } CALL_CATCH_EXCEPTION();
25334   }
25335
25336 }
25337
25338
25339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
25340   void * jresult ;
25341   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25342   Dali::Vector3 result;
25343
25344   arg1 = (Dali::CustomActorImpl *)jarg1;
25345   {
25346     try {
25347       result = (arg1)->GetNaturalSize();
25348     } CALL_CATCH_EXCEPTION(0);
25349   }
25350
25351   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
25352   return jresult;
25353 }
25354
25355
25356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
25357   float jresult ;
25358   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25359   Dali::Actor *arg2 = 0 ;
25360   Dali::Dimension::Type arg3 ;
25361   float result;
25362
25363   arg1 = (Dali::CustomActorImpl *)jarg1;
25364   arg2 = (Dali::Actor *)jarg2;
25365   if (!arg2) {
25366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
25367     return 0;
25368   }
25369   arg3 = (Dali::Dimension::Type)jarg3;
25370   {
25371     try {
25372       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
25373     } CALL_CATCH_EXCEPTION(0);
25374   }
25375
25376   jresult = result;
25377   return jresult;
25378 }
25379
25380
25381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
25382   float jresult ;
25383   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25384   float arg2 ;
25385   float result;
25386
25387   arg1 = (Dali::CustomActorImpl *)jarg1;
25388   arg2 = (float)jarg2;
25389   {
25390     try {
25391       result = (float)(arg1)->GetHeightForWidth(arg2);
25392     } CALL_CATCH_EXCEPTION(0);
25393   }
25394
25395   jresult = result;
25396   return jresult;
25397 }
25398
25399
25400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
25401   float jresult ;
25402   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25403   float arg2 ;
25404   float result;
25405
25406   arg1 = (Dali::CustomActorImpl *)jarg1;
25407   arg2 = (float)jarg2;
25408   {
25409     try {
25410       result = (float)(arg1)->GetWidthForHeight(arg2);
25411     } CALL_CATCH_EXCEPTION(0);
25412   }
25413
25414   jresult = result;
25415   return jresult;
25416 }
25417
25418
25419 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
25420   bool jresult ;
25421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25422   Dali::Dimension::Type arg2 ;
25423   bool result;
25424
25425   arg1 = (Dali::CustomActorImpl *)jarg1;
25426   arg2 = (Dali::Dimension::Type)jarg2;
25427   {
25428     try {
25429       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
25430     } CALL_CATCH_EXCEPTION(0);
25431   }
25432
25433   jresult = result;
25434   return jresult;
25435 }
25436
25437
25438 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
25439   bool jresult ;
25440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25441   bool result;
25442
25443   arg1 = (Dali::CustomActorImpl *)jarg1;
25444   {
25445     try {
25446       result = (bool)(arg1)->RelayoutDependentOnChildren();
25447     } CALL_CATCH_EXCEPTION(0);
25448   }
25449
25450   jresult = result;
25451   return jresult;
25452 }
25453
25454
25455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
25456   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25457   Dali::Dimension::Type arg2 ;
25458
25459   arg1 = (Dali::CustomActorImpl *)jarg1;
25460   arg2 = (Dali::Dimension::Type)jarg2;
25461   {
25462     try {
25463       (arg1)->OnCalculateRelayoutSize(arg2);
25464     } CALL_CATCH_EXCEPTION();
25465   }
25466
25467 }
25468
25469
25470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
25471   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25472   float arg2 ;
25473   Dali::Dimension::Type arg3 ;
25474
25475   arg1 = (Dali::CustomActorImpl *)jarg1;
25476   arg2 = (float)jarg2;
25477   arg3 = (Dali::Dimension::Type)jarg3;
25478   {
25479     try {
25480       (arg1)->OnLayoutNegotiated(arg2,arg3);
25481     } CALL_CATCH_EXCEPTION();
25482   }
25483
25484 }
25485
25486 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
25487   bool jresult ;
25488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
25489   bool result;
25490
25491   arg1 = (Dali::CustomActorImpl *)jarg1;
25492   {
25493     try {
25494       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
25495     } CALL_CATCH_EXCEPTION(0);
25496   }
25497
25498   jresult = result;
25499   return jresult;
25500 }
25501
25502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
25503   void * jresult ;
25504   Dali::CustomActor *result = 0 ;
25505
25506   {
25507     try {
25508       result = (Dali::CustomActor *)new Dali::CustomActor();
25509     } CALL_CATCH_EXCEPTION(0);
25510   }
25511
25512   jresult = (void *)result;
25513   return jresult;
25514 }
25515
25516
25517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
25518   void * jresult ;
25519   Dali::BaseHandle arg1 ;
25520   Dali::BaseHandle *argp1 ;
25521   Dali::CustomActor result;
25522
25523   argp1 = (Dali::BaseHandle *)jarg1;
25524   if (!argp1) {
25525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25526     return 0;
25527   }
25528   arg1 = *argp1;
25529   {
25530     try {
25531       result = Dali::CustomActor::DownCast(arg1);
25532     } CALL_CATCH_EXCEPTION(0);
25533   }
25534
25535   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
25536   return jresult;
25537 }
25538
25539
25540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
25541   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
25542
25543   arg1 = (Dali::CustomActor *)jarg1;
25544   {
25545     try {
25546       delete arg1;
25547     } CALL_CATCH_EXCEPTION();
25548   }
25549
25550 }
25551
25552
25553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
25554   void * jresult ;
25555   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
25556   Dali::CustomActorImpl *result = 0 ;
25557
25558   arg1 = (Dali::CustomActor *)jarg1;
25559   {
25560     try {
25561       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
25562     } CALL_CATCH_EXCEPTION(0);
25563   }
25564
25565   jresult = (void *)result;
25566   return jresult;
25567 }
25568
25569
25570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
25571   void * jresult ;
25572   Dali::CustomActorImpl *arg1 = 0 ;
25573   Dali::CustomActor *result = 0 ;
25574
25575   arg1 = (Dali::CustomActorImpl *)jarg1;
25576   if (!arg1) {
25577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
25578     return 0;
25579   }
25580   {
25581     try {
25582       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
25583     } CALL_CATCH_EXCEPTION(0);
25584   }
25585
25586   jresult = (void *)result;
25587   return jresult;
25588 }
25589
25590
25591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
25592   void * jresult ;
25593   Dali::CustomActor *arg1 = 0 ;
25594   Dali::CustomActor *result = 0 ;
25595
25596   arg1 = (Dali::CustomActor *)jarg1;
25597   if (!arg1) {
25598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
25599     return 0;
25600   }
25601   {
25602     try {
25603       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
25604     } CALL_CATCH_EXCEPTION(0);
25605   }
25606
25607   jresult = (void *)result;
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
25613   void * jresult ;
25614   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
25615   Dali::CustomActor *arg2 = 0 ;
25616   Dali::CustomActor *result = 0 ;
25617
25618   arg1 = (Dali::CustomActor *)jarg1;
25619   arg2 = (Dali::CustomActor *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
25622     return 0;
25623   }
25624   {
25625     try {
25626       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
25627     } CALL_CATCH_EXCEPTION(0);
25628   }
25629
25630   jresult = (void *)result;
25631   return jresult;
25632 }
25633
25634
25635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
25636   int jresult ;
25637   int result;
25638
25639   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
25640   jresult = (int)result;
25641   return jresult;
25642 }
25643
25644
25645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
25646   int jresult ;
25647   int result;
25648
25649   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
25650   jresult = (int)result;
25651   return jresult;
25652 }
25653
25654
25655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
25656   int jresult ;
25657   int result;
25658
25659   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
25660   jresult = (int)result;
25661   return jresult;
25662 }
25663
25664
25665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
25666   int jresult ;
25667   int result;
25668
25669   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
25670   jresult = (int)result;
25671   return jresult;
25672 }
25673
25674
25675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
25676   int jresult ;
25677   int result;
25678
25679   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
25680   jresult = (int)result;
25681   return jresult;
25682 }
25683
25684
25685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
25686   int jresult ;
25687   int result;
25688
25689   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
25690   jresult = (int)result;
25691   return jresult;
25692 }
25693
25694
25695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
25696   int jresult ;
25697   int result;
25698
25699   result = (int)Dali::PanGestureDetector::Property::PANNING;
25700   jresult = (int)result;
25701   return jresult;
25702 }
25703
25704
25705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
25706   void * jresult ;
25707   Dali::PanGestureDetector::Property *result = 0 ;
25708
25709   {
25710     try {
25711       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
25712     } CALL_CATCH_EXCEPTION(0);
25713   }
25714
25715   jresult = (void *)result;
25716   return jresult;
25717 }
25718
25719
25720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
25721   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
25722
25723   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
25724   {
25725     try {
25726       delete arg1;
25727     } CALL_CATCH_EXCEPTION();
25728   }
25729
25730 }
25731
25732
25733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
25734   void * jresult ;
25735   Dali::Radian *result = 0 ;
25736
25737   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
25738   jresult = (void *)result;
25739   return jresult;
25740 }
25741
25742
25743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
25744   void * jresult ;
25745   Dali::Radian *result = 0 ;
25746
25747   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
25748   jresult = (void *)result;
25749   return jresult;
25750 }
25751
25752
25753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
25754   void * jresult ;
25755   Dali::Radian *result = 0 ;
25756
25757   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
25758   jresult = (void *)result;
25759   return jresult;
25760 }
25761
25762
25763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
25764   void * jresult ;
25765   Dali::Radian *result = 0 ;
25766
25767   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
25768   jresult = (void *)result;
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
25774   void * jresult ;
25775   Dali::Radian *result = 0 ;
25776
25777   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
25778   jresult = (void *)result;
25779   return jresult;
25780 }
25781
25782
25783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
25784   void * jresult ;
25785   Dali::Radian *result = 0 ;
25786
25787   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
25788   jresult = (void *)result;
25789   return jresult;
25790 }
25791
25792
25793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
25794   void * jresult ;
25795   Dali::Radian *result = 0 ;
25796
25797   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
25798   jresult = (void *)result;
25799   return jresult;
25800 }
25801
25802
25803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
25804   void * jresult ;
25805   Dali::PanGestureDetector *result = 0 ;
25806
25807   {
25808     try {
25809       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
25810     } CALL_CATCH_EXCEPTION(0);
25811   }
25812
25813   jresult = (void *)result;
25814   return jresult;
25815 }
25816
25817
25818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
25819   void * jresult ;
25820   Dali::PanGestureDetector result;
25821
25822   {
25823     try {
25824       result = Dali::PanGestureDetector::New();
25825     } CALL_CATCH_EXCEPTION(0);
25826   }
25827
25828   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25829   return jresult;
25830 }
25831
25832
25833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
25834   void * jresult ;
25835   Dali::BaseHandle arg1 ;
25836   Dali::BaseHandle *argp1 ;
25837   Dali::PanGestureDetector result;
25838
25839   argp1 = (Dali::BaseHandle *)jarg1;
25840   if (!argp1) {
25841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25842     return 0;
25843   }
25844   arg1 = *argp1;
25845   {
25846     try {
25847       result = Dali::PanGestureDetector::DownCast(arg1);
25848     } CALL_CATCH_EXCEPTION(0);
25849   }
25850
25851   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25852   return jresult;
25853 }
25854
25855
25856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25857   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25858
25859   arg1 = (Dali::PanGestureDetector *)jarg1;
25860   {
25861     try {
25862       delete arg1;
25863     } CALL_CATCH_EXCEPTION();
25864   }
25865
25866 }
25867
25868
25869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25870   void * jresult ;
25871   Dali::PanGestureDetector *arg1 = 0 ;
25872   Dali::PanGestureDetector *result = 0 ;
25873
25874   arg1 = (Dali::PanGestureDetector *)jarg1;
25875   if (!arg1) {
25876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25877     return 0;
25878   }
25879   {
25880     try {
25881       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25882     } CALL_CATCH_EXCEPTION(0);
25883   }
25884
25885   jresult = (void *)result;
25886   return jresult;
25887 }
25888
25889
25890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25891   void * jresult ;
25892   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25893   Dali::PanGestureDetector *arg2 = 0 ;
25894   Dali::PanGestureDetector *result = 0 ;
25895
25896   arg1 = (Dali::PanGestureDetector *)jarg1;
25897   arg2 = (Dali::PanGestureDetector *)jarg2;
25898   if (!arg2) {
25899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25900     return 0;
25901   }
25902   {
25903     try {
25904       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25905     } CALL_CATCH_EXCEPTION(0);
25906   }
25907
25908   jresult = (void *)result;
25909   return jresult;
25910 }
25911
25912
25913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25914   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25915   unsigned int arg2 ;
25916
25917   arg1 = (Dali::PanGestureDetector *)jarg1;
25918   arg2 = (unsigned int)jarg2;
25919   {
25920     try {
25921       (arg1)->SetMinimumTouchesRequired(arg2);
25922     } CALL_CATCH_EXCEPTION();
25923   }
25924
25925 }
25926
25927
25928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25929   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25930   unsigned int arg2 ;
25931
25932   arg1 = (Dali::PanGestureDetector *)jarg1;
25933   arg2 = (unsigned int)jarg2;
25934   {
25935     try {
25936       (arg1)->SetMaximumTouchesRequired(arg2);
25937     } CALL_CATCH_EXCEPTION();
25938   }
25939
25940 }
25941
25942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
25943   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25944   uint32_t arg2 ;
25945
25946   arg1 = (Dali::PanGestureDetector *)jarg1;
25947   arg2 = (uint32_t)jarg2;
25948   {
25949     try {
25950       (arg1)->SetMaximumMotionEventAge(arg2);
25951     } CALL_CATCH_EXCEPTION();
25952   }
25953
25954 }
25955
25956
25957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25958   unsigned int jresult ;
25959   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25960   unsigned int result;
25961
25962   arg1 = (Dali::PanGestureDetector *)jarg1;
25963   {
25964     try {
25965       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25966     } CALL_CATCH_EXCEPTION(0);
25967   }
25968
25969   jresult = result;
25970   return jresult;
25971 }
25972
25973
25974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25975   unsigned int jresult ;
25976   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25977   unsigned int result;
25978
25979   arg1 = (Dali::PanGestureDetector *)jarg1;
25980   {
25981     try {
25982       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25983     } CALL_CATCH_EXCEPTION(0);
25984   }
25985
25986   jresult = result;
25987   return jresult;
25988 }
25989
25990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
25991   unsigned int jresult ;
25992   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25993   uint32_t result;
25994
25995   arg1 = (Dali::PanGestureDetector *)jarg1;
25996   {
25997     try {
25998       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
25999     } CALL_CATCH_EXCEPTION(0);
26000   }
26001
26002   jresult = result;
26003   return jresult;
26004 }
26005
26006
26007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26008   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26009   Dali::Radian arg2 ;
26010   Dali::Radian arg3 ;
26011   Dali::Radian *argp2 ;
26012   Dali::Radian *argp3 ;
26013
26014   arg1 = (Dali::PanGestureDetector *)jarg1;
26015   argp2 = (Dali::Radian *)jarg2;
26016   if (!argp2) {
26017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26018     return ;
26019   }
26020   arg2 = *argp2;
26021   argp3 = (Dali::Radian *)jarg3;
26022   if (!argp3) {
26023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26024     return ;
26025   }
26026   arg3 = *argp3;
26027   {
26028     try {
26029       (arg1)->AddAngle(arg2,arg3);
26030     } CALL_CATCH_EXCEPTION();
26031   }
26032
26033 }
26034
26035
26036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
26037   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26038   Dali::Radian arg2 ;
26039   Dali::Radian *argp2 ;
26040
26041   arg1 = (Dali::PanGestureDetector *)jarg1;
26042   argp2 = (Dali::Radian *)jarg2;
26043   if (!argp2) {
26044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26045     return ;
26046   }
26047   arg2 = *argp2;
26048   {
26049     try {
26050       (arg1)->AddAngle(arg2);
26051     } CALL_CATCH_EXCEPTION();
26052   }
26053
26054 }
26055
26056
26057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
26058   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26059   Dali::Radian arg2 ;
26060   Dali::Radian arg3 ;
26061   Dali::Radian *argp2 ;
26062   Dali::Radian *argp3 ;
26063
26064   arg1 = (Dali::PanGestureDetector *)jarg1;
26065   argp2 = (Dali::Radian *)jarg2;
26066   if (!argp2) {
26067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26068     return ;
26069   }
26070   arg2 = *argp2;
26071   argp3 = (Dali::Radian *)jarg3;
26072   if (!argp3) {
26073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26074     return ;
26075   }
26076   arg3 = *argp3;
26077   {
26078     try {
26079       (arg1)->AddDirection(arg2,arg3);
26080     } CALL_CATCH_EXCEPTION();
26081   }
26082
26083 }
26084
26085
26086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
26087   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26088   Dali::Radian arg2 ;
26089   Dali::Radian *argp2 ;
26090
26091   arg1 = (Dali::PanGestureDetector *)jarg1;
26092   argp2 = (Dali::Radian *)jarg2;
26093   if (!argp2) {
26094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26095     return ;
26096   }
26097   arg2 = *argp2;
26098   {
26099     try {
26100       (arg1)->AddDirection(arg2);
26101     } CALL_CATCH_EXCEPTION();
26102   }
26103
26104 }
26105
26106
26107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
26108   unsigned long jresult ;
26109   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26110   size_t result;
26111
26112   arg1 = (Dali::PanGestureDetector *)jarg1;
26113   {
26114     try {
26115       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
26116     } CALL_CATCH_EXCEPTION(0);
26117   }
26118
26119   jresult = (unsigned long)result;
26120   return jresult;
26121 }
26122
26123
26124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
26125   void * jresult ;
26126   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26127   size_t arg2 ;
26128   Dali::PanGestureDetector::AngleThresholdPair result;
26129
26130   arg1 = (Dali::PanGestureDetector *)jarg1;
26131   arg2 = (size_t)jarg2;
26132   {
26133     try {
26134       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
26135     } CALL_CATCH_EXCEPTION(0);
26136   }
26137
26138   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
26139   return jresult;
26140 }
26141
26142
26143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
26144   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26145
26146   arg1 = (Dali::PanGestureDetector *)jarg1;
26147   {
26148     try {
26149       (arg1)->ClearAngles();
26150     } CALL_CATCH_EXCEPTION();
26151   }
26152
26153 }
26154
26155
26156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
26157   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26158   Dali::Radian arg2 ;
26159   Dali::Radian *argp2 ;
26160
26161   arg1 = (Dali::PanGestureDetector *)jarg1;
26162   argp2 = (Dali::Radian *)jarg2;
26163   if (!argp2) {
26164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26165     return ;
26166   }
26167   arg2 = *argp2;
26168   {
26169     try {
26170       (arg1)->RemoveAngle(arg2);
26171     } CALL_CATCH_EXCEPTION();
26172   }
26173
26174 }
26175
26176
26177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
26178   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26179   Dali::Radian arg2 ;
26180   Dali::Radian *argp2 ;
26181
26182   arg1 = (Dali::PanGestureDetector *)jarg1;
26183   argp2 = (Dali::Radian *)jarg2;
26184   if (!argp2) {
26185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
26186     return ;
26187   }
26188   arg2 = *argp2;
26189   {
26190     try {
26191       (arg1)->RemoveDirection(arg2);
26192     } CALL_CATCH_EXCEPTION();
26193   }
26194
26195 }
26196
26197
26198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
26199   void * jresult ;
26200   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
26201   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
26202
26203   arg1 = (Dali::PanGestureDetector *)jarg1;
26204   {
26205     try {
26206       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26207     } CALL_CATCH_EXCEPTION(0);
26208   }
26209
26210   jresult = (void *)result;
26211   return jresult;
26212 }
26213
26214
26215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
26216   Dali::PanGesture *arg1 = 0 ;
26217
26218   arg1 = (Dali::PanGesture *)jarg1;
26219   if (!arg1) {
26220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26221     return ;
26222   }
26223   {
26224     try {
26225       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
26226     } CALL_CATCH_EXCEPTION();
26227   }
26228
26229 }
26230
26231
26232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
26233   void * jresult ;
26234   Dali::PanGesture *result = 0 ;
26235
26236   {
26237     try {
26238       result = (Dali::PanGesture *)new Dali::PanGesture();
26239     } CALL_CATCH_EXCEPTION(0);
26240   }
26241
26242   jresult = (void *)result;
26243   return jresult;
26244 }
26245
26246
26247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
26248   void * jresult ;
26249   Dali::GestureState arg1 ;
26250   Dali::PanGesture result;
26251
26252   arg1 = (Dali::GestureState)jarg1;
26253   {
26254     try {
26255       result = DevelPanGesture::New(arg1);
26256     } CALL_CATCH_EXCEPTION(0);
26257   }
26258
26259   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
26265   void * jresult ;
26266   Dali::PanGesture *arg1 = 0 ;
26267   Dali::PanGesture *result = 0 ;
26268
26269   arg1 = (Dali::PanGesture *)jarg1;
26270   if (!arg1) {
26271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26272     return 0;
26273   }
26274   {
26275     try {
26276       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
26277     } CALL_CATCH_EXCEPTION(0);
26278   }
26279
26280   jresult = (void *)result;
26281   return jresult;
26282 }
26283
26284
26285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
26286   void * jresult ;
26287   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26288   Dali::PanGesture *arg2 = 0 ;
26289   Dali::PanGesture *result = 0 ;
26290
26291   arg1 = (Dali::PanGesture *)jarg1;
26292   arg2 = (Dali::PanGesture *)jarg2;
26293   if (!arg2) {
26294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
26295     return 0;
26296   }
26297   {
26298     try {
26299       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
26300     } CALL_CATCH_EXCEPTION(0);
26301   }
26302
26303   jresult = (void *)result;
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
26309   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26310
26311   arg1 = (Dali::PanGesture *)jarg1;
26312   {
26313     try {
26314       delete arg1;
26315     } CALL_CATCH_EXCEPTION();
26316   }
26317
26318 }
26319
26320
26321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
26322   void * jresult ;
26323   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26324   Dali::Vector2 result;
26325
26326   arg1 = (Dali::PanGesture *)jarg1;
26327   {
26328     try {
26329       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
26330     } catch (std::out_of_range& e) {
26331       {
26332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26333       };
26334     } catch (std::exception& e) {
26335       {
26336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26337       };
26338     } catch (Dali::DaliException e) {
26339       {
26340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26341       };
26342     } catch (...) {
26343       {
26344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26345       };
26346     }
26347   }
26348   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26349   return jresult;
26350 }
26351
26352
26353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
26354   void * jresult ;
26355   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26356   Dali::Vector2 result;
26357
26358   arg1 = (Dali::PanGesture *)jarg1;
26359   {
26360     try {
26361       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (Dali::DaliException e) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26373       };
26374     } catch (...) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26377       };
26378     }
26379   }
26380   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26381   return jresult;
26382 }
26383
26384
26385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
26386   void * jresult ;
26387   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26388   Dali::Vector2 result;
26389
26390   arg1 = (Dali::PanGesture *)jarg1;
26391   {
26392     try {
26393       result = ((Dali::PanGesture const *)arg1)->GetPosition();
26394     } catch (std::out_of_range& e) {
26395       {
26396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26397       };
26398     } catch (std::exception& e) {
26399       {
26400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26401       };
26402     } catch (Dali::DaliException e) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26405       };
26406     } catch (...) {
26407       {
26408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26409       };
26410     }
26411   }
26412   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26413   return jresult;
26414 }
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
26417   void * jresult ;
26418   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26419   Dali::Vector2 result;
26420
26421   arg1 = (Dali::PanGesture *)jarg1;
26422   {
26423     try {
26424       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
26425     } catch (std::out_of_range& e) {
26426       {
26427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26428       };
26429     } catch (std::exception& e) {
26430       {
26431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (Dali::DaliException e) {
26434       {
26435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26436       };
26437     } catch (...) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26440       };
26441     }
26442   }
26443   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
26449   void * jresult ;
26450   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26451   Dali::Vector2 result;
26452
26453   arg1 = (Dali::PanGesture *)jarg1;
26454   {
26455     try {
26456       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
26457     } catch (std::out_of_range& e) {
26458       {
26459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26460       };
26461     } catch (std::exception& e) {
26462       {
26463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26464       };
26465     } catch (Dali::DaliException e) {
26466       {
26467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26468       };
26469     } catch (...) {
26470       {
26471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26472       };
26473     }
26474   }
26475   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26476   return jresult;
26477 }
26478
26479
26480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
26481   void * jresult ;
26482   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26483   Dali::Vector2 result;
26484
26485   arg1 = (Dali::PanGesture *)jarg1;
26486   {
26487     try {
26488       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
26489     } catch (std::out_of_range& e) {
26490       {
26491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26492       };
26493     } catch (std::exception& e) {
26494       {
26495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26496       };
26497     } catch (Dali::DaliException e) {
26498       {
26499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26500       };
26501     } catch (...) {
26502       {
26503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26504       };
26505     }
26506   }
26507   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
26513   unsigned int jresult ;
26514   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26515   unsigned int result;
26516
26517   arg1 = (Dali::PanGesture *)jarg1;
26518   result = (unsigned int) ((arg1)->GetNumberOfTouches());
26519   jresult = result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
26525   float jresult ;
26526   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26527   float result;
26528
26529   arg1 = (Dali::PanGesture *)jarg1;
26530   {
26531     try {
26532       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
26533     } CALL_CATCH_EXCEPTION(0);
26534   }
26535
26536   jresult = result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
26542   float jresult ;
26543   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26544   float result;
26545
26546   arg1 = (Dali::PanGesture *)jarg1;
26547   {
26548     try {
26549       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
26550     } CALL_CATCH_EXCEPTION(0);
26551   }
26552
26553   jresult = result;
26554   return jresult;
26555 }
26556
26557
26558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
26559   float jresult ;
26560   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26561   float result;
26562
26563   arg1 = (Dali::PanGesture *)jarg1;
26564   {
26565     try {
26566       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
26567     } CALL_CATCH_EXCEPTION(0);
26568   }
26569
26570   jresult = result;
26571   return jresult;
26572 }
26573
26574
26575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
26576   float jresult ;
26577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
26578   float result;
26579
26580   arg1 = (Dali::PanGesture *)jarg1;
26581   {
26582     try {
26583       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
26584     } CALL_CATCH_EXCEPTION(0);
26585   }
26586
26587   jresult = result;
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
26593   void * jresult ;
26594   Dali::PinchGestureDetector *result = 0 ;
26595
26596   {
26597     try {
26598       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
26599     } CALL_CATCH_EXCEPTION(0);
26600   }
26601
26602   jresult = (void *)result;
26603   return jresult;
26604 }
26605
26606
26607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
26608   void * jresult ;
26609   Dali::PinchGestureDetector result;
26610
26611   {
26612     try {
26613       result = Dali::PinchGestureDetector::New();
26614     } CALL_CATCH_EXCEPTION(0);
26615   }
26616
26617   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
26618   return jresult;
26619 }
26620
26621
26622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
26623   void * jresult ;
26624   Dali::BaseHandle arg1 ;
26625   Dali::BaseHandle *argp1 ;
26626   Dali::PinchGestureDetector result;
26627
26628   argp1 = (Dali::BaseHandle *)jarg1;
26629   if (!argp1) {
26630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26631     return 0;
26632   }
26633   arg1 = *argp1;
26634   {
26635     try {
26636       result = Dali::PinchGestureDetector::DownCast(arg1);
26637     } CALL_CATCH_EXCEPTION(0);
26638   }
26639
26640   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
26641   return jresult;
26642 }
26643
26644
26645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
26646   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
26647
26648   arg1 = (Dali::PinchGestureDetector *)jarg1;
26649   {
26650     try {
26651       delete arg1;
26652     } CALL_CATCH_EXCEPTION();
26653   }
26654
26655 }
26656
26657
26658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
26659   void * jresult ;
26660   Dali::PinchGestureDetector *arg1 = 0 ;
26661   Dali::PinchGestureDetector *result = 0 ;
26662
26663   arg1 = (Dali::PinchGestureDetector *)jarg1;
26664   if (!arg1) {
26665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
26666     return 0;
26667   }
26668   {
26669     try {
26670       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
26671     } CALL_CATCH_EXCEPTION(0);
26672   }
26673
26674   jresult = (void *)result;
26675   return jresult;
26676 }
26677
26678
26679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
26680   void * jresult ;
26681   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
26682   Dali::PinchGestureDetector *arg2 = 0 ;
26683   Dali::PinchGestureDetector *result = 0 ;
26684
26685   arg1 = (Dali::PinchGestureDetector *)jarg1;
26686   arg2 = (Dali::PinchGestureDetector *)jarg2;
26687   if (!arg2) {
26688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
26689     return 0;
26690   }
26691   {
26692     try {
26693       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
26694     } CALL_CATCH_EXCEPTION(0);
26695   }
26696
26697   jresult = (void *)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
26703   void * jresult ;
26704   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
26705   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
26706
26707   arg1 = (Dali::PinchGestureDetector *)jarg1;
26708   {
26709     try {
26710       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26711     } CALL_CATCH_EXCEPTION(0);
26712   }
26713
26714   jresult = (void *)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
26720   void * jresult ;
26721   Dali::PinchGesture *result = 0 ;
26722
26723   {
26724     try {
26725       result = (Dali::PinchGesture *)new Dali::PinchGesture();
26726     } CALL_CATCH_EXCEPTION(0);
26727   }
26728
26729   jresult = (void *)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
26735   void * jresult ;
26736   Dali::GestureState arg1 ;
26737   Dali::PinchGesture result;
26738
26739   arg1 = (Dali::GestureState)jarg1;
26740   {
26741     try {
26742       result = DevelPinchGesture::New(arg1);
26743     } CALL_CATCH_EXCEPTION(0);
26744   }
26745
26746   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
26752   void * jresult ;
26753   Dali::PinchGesture *arg1 = 0 ;
26754   Dali::PinchGesture *result = 0 ;
26755
26756   arg1 = (Dali::PinchGesture *)jarg1;
26757   if (!arg1) {
26758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
26759     return 0;
26760   }
26761   {
26762     try {
26763       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
26764     } CALL_CATCH_EXCEPTION(0);
26765   }
26766
26767   jresult = (void *)result;
26768   return jresult;
26769 }
26770
26771
26772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
26773   void * jresult ;
26774   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26775   Dali::PinchGesture *arg2 = 0 ;
26776   Dali::PinchGesture *result = 0 ;
26777
26778   arg1 = (Dali::PinchGesture *)jarg1;
26779   arg2 = (Dali::PinchGesture *)jarg2;
26780   if (!arg2) {
26781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
26782     return 0;
26783   }
26784   {
26785     try {
26786       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
26787     } CALL_CATCH_EXCEPTION(0);
26788   }
26789
26790   jresult = (void *)result;
26791   return jresult;
26792 }
26793
26794
26795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
26796   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26797
26798   arg1 = (Dali::PinchGesture *)jarg1;
26799   {
26800     try {
26801       delete arg1;
26802     } CALL_CATCH_EXCEPTION();
26803   }
26804
26805 }
26806
26807
26808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
26809   float jresult ;
26810   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26811   float result;
26812
26813   arg1 = (Dali::PinchGesture *)jarg1;
26814   result = (float) ((arg1)->GetScale());
26815   jresult = result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
26821   float jresult ;
26822   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26823   float result;
26824
26825   arg1 = (Dali::PinchGesture *)jarg1;
26826   result = (float) ((arg1)->GetSpeed());
26827   jresult = result;
26828   return jresult;
26829 }
26830
26831
26832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
26833   void * jresult ;
26834   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26835   Dali::Vector2 result;
26836
26837   arg1 = (Dali::PinchGesture *)jarg1;
26838   {
26839     try {
26840       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
26841     } catch (std::out_of_range& e) {
26842       {
26843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26844       };
26845     } catch (std::exception& e) {
26846       {
26847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26848       };
26849     } catch (Dali::DaliException e) {
26850       {
26851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26852       };
26853     } catch (...) {
26854       {
26855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26856       };
26857     }
26858   }
26859   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26860   return jresult;
26861 }
26862
26863
26864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
26865   void * jresult ;
26866   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26867   Dali::Vector2 result;
26868
26869   arg1 = (Dali::PinchGesture *)jarg1;
26870   {
26871     try {
26872       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
26873     } catch (std::out_of_range& e) {
26874       {
26875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26876       };
26877     } catch (std::exception& e) {
26878       {
26879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26880       };
26881     } catch (Dali::DaliException e) {
26882       {
26883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26884       };
26885     } catch (...) {
26886       {
26887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26888       };
26889     }
26890   }
26891   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26892   return jresult;
26893 }
26894
26895
26896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26897   void * jresult ;
26898   Dali::TapGestureDetector *result = 0 ;
26899
26900   {
26901     try {
26902       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26903     } CALL_CATCH_EXCEPTION(0);
26904   }
26905
26906   jresult = (void *)result;
26907   return jresult;
26908 }
26909
26910
26911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26912   void * jresult ;
26913   Dali::TapGestureDetector result;
26914
26915   {
26916     try {
26917       result = Dali::TapGestureDetector::New();
26918     } CALL_CATCH_EXCEPTION(0);
26919   }
26920
26921   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26922   return jresult;
26923 }
26924
26925
26926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26927   void * jresult ;
26928   unsigned int arg1 ;
26929   Dali::TapGestureDetector result;
26930
26931   arg1 = (unsigned int)jarg1;
26932   {
26933     try {
26934       result = Dali::TapGestureDetector::New(arg1);
26935     } CALL_CATCH_EXCEPTION(0);
26936   }
26937
26938   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26939   return jresult;
26940 }
26941
26942
26943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26944   void * jresult ;
26945   Dali::BaseHandle arg1 ;
26946   Dali::BaseHandle *argp1 ;
26947   Dali::TapGestureDetector result;
26948
26949   argp1 = (Dali::BaseHandle *)jarg1;
26950   if (!argp1) {
26951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26952     return 0;
26953   }
26954   arg1 = *argp1;
26955   {
26956     try {
26957       result = Dali::TapGestureDetector::DownCast(arg1);
26958     } CALL_CATCH_EXCEPTION(0);
26959   }
26960
26961   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26962   return jresult;
26963 }
26964
26965
26966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26967   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26968
26969   arg1 = (Dali::TapGestureDetector *)jarg1;
26970   {
26971     try {
26972       delete arg1;
26973     } CALL_CATCH_EXCEPTION();
26974   }
26975
26976 }
26977
26978
26979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26980   void * jresult ;
26981   Dali::TapGestureDetector *arg1 = 0 ;
26982   Dali::TapGestureDetector *result = 0 ;
26983
26984   arg1 = (Dali::TapGestureDetector *)jarg1;
26985   if (!arg1) {
26986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26987     return 0;
26988   }
26989   {
26990     try {
26991       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26992     } CALL_CATCH_EXCEPTION(0);
26993   }
26994
26995   jresult = (void *)result;
26996   return jresult;
26997 }
26998
26999
27000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
27001   void * jresult ;
27002   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27003   Dali::TapGestureDetector *arg2 = 0 ;
27004   Dali::TapGestureDetector *result = 0 ;
27005
27006   arg1 = (Dali::TapGestureDetector *)jarg1;
27007   arg2 = (Dali::TapGestureDetector *)jarg2;
27008   if (!arg2) {
27009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27010     return 0;
27011   }
27012   {
27013     try {
27014       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
27015     } CALL_CATCH_EXCEPTION(0);
27016   }
27017
27018   jresult = (void *)result;
27019   return jresult;
27020 }
27021
27022
27023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
27024   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27025   unsigned int arg2 ;
27026
27027   arg1 = (Dali::TapGestureDetector *)jarg1;
27028   arg2 = (unsigned int)jarg2;
27029   {
27030     try {
27031       (arg1)->SetMinimumTapsRequired(arg2);
27032     } CALL_CATCH_EXCEPTION();
27033   }
27034
27035 }
27036
27037
27038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
27039   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27040   unsigned int arg2 ;
27041
27042   arg1 = (Dali::TapGestureDetector *)jarg1;
27043   arg2 = (unsigned int)jarg2;
27044   {
27045     try {
27046       (arg1)->SetMaximumTapsRequired(arg2);
27047     } CALL_CATCH_EXCEPTION();
27048   }
27049
27050 }
27051
27052
27053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
27054   unsigned int jresult ;
27055   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27056   unsigned int result;
27057
27058   arg1 = (Dali::TapGestureDetector *)jarg1;
27059   {
27060     try {
27061       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
27062     } CALL_CATCH_EXCEPTION(0);
27063   }
27064
27065   jresult = result;
27066   return jresult;
27067 }
27068
27069
27070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
27071   unsigned int jresult ;
27072   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27073   unsigned int result;
27074
27075   arg1 = (Dali::TapGestureDetector *)jarg1;
27076   {
27077     try {
27078       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
27079     } CALL_CATCH_EXCEPTION(0);
27080   }
27081
27082   jresult = result;
27083   return jresult;
27084 }
27085
27086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
27087   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
27088
27089   detector = (Dali::TapGestureDetector *)tapGestureDetector;
27090   if (!detector) {
27091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
27092     return;
27093   }
27094   {
27095     try {
27096       (detector)->ReceiveAllTapEvents(isReceive);
27097     } CALL_CATCH_EXCEPTION();
27098   }
27099
27100 }
27101
27102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
27103   void * jresult ;
27104   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
27105   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
27106
27107   arg1 = (Dali::TapGestureDetector *)jarg1;
27108   {
27109     try {
27110       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27111     } CALL_CATCH_EXCEPTION(0);
27112   }
27113
27114   jresult = (void *)result;
27115   return jresult;
27116 }
27117
27118
27119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
27120   void * jresult ;
27121   Dali::TapGesture *result = 0 ;
27122
27123   {
27124     try {
27125       result = (Dali::TapGesture *)new Dali::TapGesture();
27126     } CALL_CATCH_EXCEPTION(0);
27127   }
27128
27129   jresult = (void *)result;
27130   return jresult;
27131 }
27132
27133
27134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
27135   void * jresult ;
27136   Dali::GestureState arg1 ;
27137   Dali::TapGesture result;
27138
27139   arg1 = (Dali::GestureState)jarg1;
27140   {
27141     try {
27142       result = DevelTapGesture::New(arg1);
27143     } CALL_CATCH_EXCEPTION(0);
27144   }
27145
27146   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
27147   return jresult;
27148 }
27149
27150
27151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
27152   void * jresult ;
27153   Dali::TapGesture *arg1 = 0 ;
27154   Dali::TapGesture *result = 0 ;
27155
27156   arg1 = (Dali::TapGesture *)jarg1;
27157   if (!arg1) {
27158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
27159     return 0;
27160   }
27161   {
27162     try {
27163       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
27164     } CALL_CATCH_EXCEPTION(0);
27165   }
27166
27167   jresult = (void *)result;
27168   return jresult;
27169 }
27170
27171
27172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
27173   void * jresult ;
27174   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27175   Dali::TapGesture *arg2 = 0 ;
27176   Dali::TapGesture *result = 0 ;
27177
27178   arg1 = (Dali::TapGesture *)jarg1;
27179   arg2 = (Dali::TapGesture *)jarg2;
27180   if (!arg2) {
27181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
27182     return 0;
27183   }
27184   {
27185     try {
27186       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
27187     } CALL_CATCH_EXCEPTION(0);
27188   }
27189
27190   jresult = (void *)result;
27191   return jresult;
27192 }
27193
27194
27195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
27196   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27197
27198   arg1 = (Dali::TapGesture *)jarg1;
27199   {
27200     try {
27201       delete arg1;
27202     } CALL_CATCH_EXCEPTION();
27203   }
27204
27205 }
27206
27207
27208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
27209   unsigned int jresult ;
27210   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27211   unsigned int result;
27212
27213   arg1 = (Dali::TapGesture *)jarg1;
27214   result = (unsigned int) ((arg1)->GetNumberOfTaps());
27215   jresult = result;
27216   return jresult;
27217 }
27218
27219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
27220   unsigned int jresult ;
27221   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27222   unsigned int result;
27223
27224   arg1 = (Dali::TapGesture *)jarg1;
27225   result = (unsigned int) ((arg1)->GetNumberOfTouches());
27226   jresult = result;
27227   return jresult;
27228 }
27229
27230
27231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
27232   void * jresult ;
27233   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27234   Dali::Vector2 result;
27235
27236   arg1 = (Dali::TapGesture *)jarg1;
27237   {
27238     try {
27239       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
27240     } catch (std::out_of_range& e) {
27241       {
27242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27243       };
27244     } catch (std::exception& e) {
27245       {
27246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27247       };
27248     } catch (Dali::DaliException e) {
27249       {
27250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27251       };
27252     } catch (...) {
27253       {
27254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27255       };
27256     }
27257   }
27258   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27259   return jresult;
27260 }
27261
27262
27263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
27264   void * jresult ;
27265   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27266   Dali::Vector2 result;
27267
27268   arg1 = (Dali::TapGesture *)jarg1;
27269   {
27270     try {
27271       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
27272     } catch (std::out_of_range& e) {
27273       {
27274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27275       };
27276     } catch (std::exception& e) {
27277       {
27278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27279       };
27280     } catch (Dali::DaliException e) {
27281       {
27282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27283       };
27284     } catch (...) {
27285       {
27286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27287       };
27288     }
27289   }
27290   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
27291   return jresult;
27292 }
27293
27294
27295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TapGesture_sourceType_get(void * jarg1) {
27296   int jresult ;
27297   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
27298   Dali::GestureSourceType result;
27299
27300   arg1 = (Dali::TapGesture *)jarg1;
27301   {
27302     try {
27303       result = ((Dali::TapGesture const *)arg1)->GetSourceType();
27304     } CALL_CATCH_EXCEPTION(0);
27305   }
27306
27307   jresult = static_cast< int >(result);
27308   return jresult;
27309 }
27310
27311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
27312   void * jresult ;
27313   Dali::AlphaFunction *result = 0 ;
27314
27315   {
27316     try {
27317       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
27318     } CALL_CATCH_EXCEPTION(0);
27319   }
27320
27321   jresult = (void *)result;
27322   return jresult;
27323 }
27324
27325
27326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
27327   void * jresult ;
27328   Dali::AlphaFunction::BuiltinFunction arg1 ;
27329   Dali::AlphaFunction *result = 0 ;
27330
27331   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
27332   {
27333     try {
27334       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
27335     } CALL_CATCH_EXCEPTION(0);
27336   }
27337
27338   jresult = (void *)result;
27339   return jresult;
27340 }
27341
27342
27343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
27344   void * jresult ;
27345   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
27346   Dali::AlphaFunction *result = 0 ;
27347
27348   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
27349   {
27350     try {
27351       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
27352     } CALL_CATCH_EXCEPTION(0);
27353   }
27354
27355   jresult = (void *)result;
27356   return jresult;
27357 }
27358
27359
27360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
27361   void * jresult ;
27362   Dali::Vector2 *arg1 = 0 ;
27363   Dali::Vector2 *arg2 = 0 ;
27364   Dali::AlphaFunction *result = 0 ;
27365
27366   arg1 = (Dali::Vector2 *)jarg1;
27367   if (!arg1) {
27368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27369     return 0;
27370   }
27371   arg2 = (Dali::Vector2 *)jarg2;
27372   if (!arg2) {
27373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27374     return 0;
27375   }
27376   {
27377     try {
27378       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
27379     } CALL_CATCH_EXCEPTION(0);
27380   }
27381
27382   jresult = (void *)result;
27383   return jresult;
27384 }
27385
27386
27387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
27388   void * jresult ;
27389   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27390   Dali::Vector4 result;
27391
27392   arg1 = (Dali::AlphaFunction *)jarg1;
27393   {
27394     try {
27395       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
27396     } CALL_CATCH_EXCEPTION(0);
27397   }
27398
27399   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
27400   return jresult;
27401 }
27402
27403
27404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
27405   void * jresult ;
27406   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27407   Dali::AlphaFunctionPrototype result;
27408
27409   arg1 = (Dali::AlphaFunction *)jarg1;
27410   {
27411     try {
27412       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
27413     } CALL_CATCH_EXCEPTION(0);
27414   }
27415
27416   jresult = (void *)result;
27417   return jresult;
27418 }
27419
27420
27421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
27422   int jresult ;
27423   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27424   Dali::AlphaFunction::BuiltinFunction result;
27425
27426   arg1 = (Dali::AlphaFunction *)jarg1;
27427   {
27428     try {
27429       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
27430     } CALL_CATCH_EXCEPTION(0);
27431   }
27432
27433   jresult = (int)result;
27434   return jresult;
27435 }
27436
27437
27438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
27439   int jresult ;
27440   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27441   Dali::AlphaFunction::Mode result;
27442
27443   arg1 = (Dali::AlphaFunction *)jarg1;
27444   {
27445     try {
27446       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
27447     } CALL_CATCH_EXCEPTION(0);
27448   }
27449
27450   jresult = (int)result;
27451   return jresult;
27452 }
27453
27454
27455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
27456   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
27457
27458   arg1 = (Dali::AlphaFunction *)jarg1;
27459   {
27460     try {
27461       delete arg1;
27462     } CALL_CATCH_EXCEPTION();
27463   }
27464
27465 }
27466
27467
27468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
27469   void * jresult ;
27470   Dali::KeyFrames result;
27471
27472   {
27473     try {
27474       result = Dali::KeyFrames::New();
27475     } CALL_CATCH_EXCEPTION(0);
27476   }
27477
27478   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
27484   void * jresult ;
27485   Dali::BaseHandle arg1 ;
27486   Dali::BaseHandle *argp1 ;
27487   Dali::KeyFrames result;
27488
27489   argp1 = (Dali::BaseHandle *)jarg1;
27490   if (!argp1) {
27491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27492     return 0;
27493   }
27494   arg1 = *argp1;
27495   {
27496     try {
27497       result = Dali::KeyFrames::DownCast(arg1);
27498     } CALL_CATCH_EXCEPTION(0);
27499   }
27500
27501   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
27502   return jresult;
27503 }
27504
27505
27506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
27507   void * jresult ;
27508   Dali::KeyFrames *result = 0 ;
27509
27510   {
27511     try {
27512       result = (Dali::KeyFrames *)new Dali::KeyFrames();
27513     } CALL_CATCH_EXCEPTION(0);
27514   }
27515
27516   jresult = (void *)result;
27517   return jresult;
27518 }
27519
27520
27521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
27522   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
27523
27524   arg1 = (Dali::KeyFrames *)jarg1;
27525   {
27526     try {
27527       delete arg1;
27528     } CALL_CATCH_EXCEPTION();
27529   }
27530
27531 }
27532
27533
27534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
27535   void * jresult ;
27536   Dali::KeyFrames *arg1 = 0 ;
27537   Dali::KeyFrames *result = 0 ;
27538
27539   arg1 = (Dali::KeyFrames *)jarg1;
27540   if (!arg1) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
27542     return 0;
27543   }
27544   {
27545     try {
27546       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
27547     } CALL_CATCH_EXCEPTION(0);
27548   }
27549
27550   jresult = (void *)result;
27551   return jresult;
27552 }
27553
27554
27555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
27556   void * jresult ;
27557   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
27558   Dali::KeyFrames *arg2 = 0 ;
27559   Dali::KeyFrames *result = 0 ;
27560
27561   arg1 = (Dali::KeyFrames *)jarg1;
27562   arg2 = (Dali::KeyFrames *)jarg2;
27563   if (!arg2) {
27564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
27565     return 0;
27566   }
27567   {
27568     try {
27569       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
27570     } CALL_CATCH_EXCEPTION(0);
27571   }
27572
27573   jresult = (void *)result;
27574   return jresult;
27575 }
27576
27577
27578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
27579   int jresult ;
27580   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
27581   Dali::Property::Type result;
27582
27583   arg1 = (Dali::KeyFrames *)jarg1;
27584   {
27585     try {
27586       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
27587     } CALL_CATCH_EXCEPTION(0);
27588   }
27589
27590   jresult = (int)result;
27591   return jresult;
27592 }
27593
27594
27595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
27596   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
27597   float arg2 ;
27598   Dali::Property::Value arg3 ;
27599   Dali::Property::Value *argp3 ;
27600
27601   arg1 = (Dali::KeyFrames *)jarg1;
27602   arg2 = (float)jarg2;
27603   argp3 = (Dali::Property::Value *)jarg3;
27604   if (!argp3) {
27605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27606     return ;
27607   }
27608   arg3 = *argp3;
27609   {
27610     try {
27611       (arg1)->Add(arg2,arg3);
27612     } CALL_CATCH_EXCEPTION();
27613   }
27614
27615 }
27616
27617
27618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27619   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
27620   float arg2 ;
27621   Dali::Property::Value arg3 ;
27622   Dali::AlphaFunction arg4 ;
27623   Dali::Property::Value *argp3 ;
27624   Dali::AlphaFunction *argp4 ;
27625
27626   arg1 = (Dali::KeyFrames *)jarg1;
27627   arg2 = (float)jarg2;
27628   argp3 = (Dali::Property::Value *)jarg3;
27629   if (!argp3) {
27630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27631     return ;
27632   }
27633   arg3 = *argp3;
27634   argp4 = (Dali::AlphaFunction *)jarg4;
27635   if (!argp4) {
27636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
27637     return ;
27638   }
27639   arg4 = *argp4;
27640   {
27641     try {
27642       (arg1)->Add(arg2,arg3,arg4);
27643     } CALL_CATCH_EXCEPTION();
27644   }
27645
27646 }
27647
27648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
27649 {
27650   return (unsigned int) Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
27651 }
27652
27653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
27654 {
27655   Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
27656 }
27657
27658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
27659   int jresult ;
27660   int result;
27661
27662   result = (int)Dali::Path::Property::POINTS;
27663   jresult = (int)result;
27664   return jresult;
27665 }
27666
27667
27668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
27669   int jresult ;
27670   int result;
27671
27672   result = (int)Dali::Path::Property::CONTROL_POINTS;
27673   jresult = (int)result;
27674   return jresult;
27675 }
27676
27677
27678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
27679   void * jresult ;
27680   Dali::Path::Property *result = 0 ;
27681
27682   {
27683     try {
27684       result = (Dali::Path::Property *)new Dali::Path::Property();
27685     } CALL_CATCH_EXCEPTION(0);
27686   }
27687
27688   jresult = (void *)result;
27689   return jresult;
27690 }
27691
27692
27693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
27694   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
27695
27696   arg1 = (Dali::Path::Property *)jarg1;
27697   {
27698     try {
27699       delete arg1;
27700     } CALL_CATCH_EXCEPTION();
27701   }
27702
27703 }
27704
27705
27706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
27707   void * jresult ;
27708   Dali::Path result;
27709
27710   {
27711     try {
27712       result = Dali::Path::New();
27713     } CALL_CATCH_EXCEPTION(0);
27714   }
27715
27716   jresult = new Dali::Path((const Dali::Path &)result);
27717   return jresult;
27718 }
27719
27720
27721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
27722   void * jresult ;
27723   Dali::BaseHandle arg1 ;
27724   Dali::BaseHandle *argp1 ;
27725   Dali::Path result;
27726
27727   argp1 = (Dali::BaseHandle *)jarg1;
27728   if (!argp1) {
27729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27730     return 0;
27731   }
27732   arg1 = *argp1;
27733   {
27734     try {
27735       result = Dali::Path::DownCast(arg1);
27736     } CALL_CATCH_EXCEPTION(0);
27737   }
27738
27739   jresult = new Dali::Path((const Dali::Path &)result);
27740   return jresult;
27741 }
27742
27743
27744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
27745   void * jresult ;
27746   Dali::Path *result = 0 ;
27747
27748   {
27749     try {
27750       result = (Dali::Path *)new Dali::Path();
27751     } CALL_CATCH_EXCEPTION(0);
27752   }
27753
27754   jresult = (void *)result;
27755   return jresult;
27756 }
27757
27758
27759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
27760   Dali::Path *arg1 = (Dali::Path *) 0 ;
27761
27762   arg1 = (Dali::Path *)jarg1;
27763   {
27764     try {
27765       delete arg1;
27766     } CALL_CATCH_EXCEPTION();
27767   }
27768
27769 }
27770
27771
27772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
27773   void * jresult ;
27774   Dali::Path *arg1 = 0 ;
27775   Dali::Path *result = 0 ;
27776
27777   arg1 = (Dali::Path *)jarg1;
27778   if (!arg1) {
27779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
27780     return 0;
27781   }
27782   {
27783     try {
27784       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
27785     } CALL_CATCH_EXCEPTION(0);
27786   }
27787
27788   jresult = (void *)result;
27789   return jresult;
27790 }
27791
27792
27793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
27794   void * jresult ;
27795   Dali::Path *arg1 = (Dali::Path *) 0 ;
27796   Dali::Path *arg2 = 0 ;
27797   Dali::Path *result = 0 ;
27798
27799   arg1 = (Dali::Path *)jarg1;
27800   arg2 = (Dali::Path *)jarg2;
27801   if (!arg2) {
27802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
27803     return 0;
27804   }
27805   {
27806     try {
27807       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
27808     } CALL_CATCH_EXCEPTION(0);
27809   }
27810
27811   jresult = (void *)result;
27812   return jresult;
27813 }
27814
27815
27816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
27817   Dali::Path *arg1 = (Dali::Path *) 0 ;
27818   Dali::Vector3 *arg2 = 0 ;
27819
27820   arg1 = (Dali::Path *)jarg1;
27821   arg2 = (Dali::Vector3 *)jarg2;
27822   if (!arg2) {
27823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27824     return ;
27825   }
27826   {
27827     try {
27828       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
27829     } CALL_CATCH_EXCEPTION();
27830   }
27831
27832 }
27833
27834
27835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
27836   Dali::Path *arg1 = (Dali::Path *) 0 ;
27837   Dali::Vector3 *arg2 = 0 ;
27838
27839   arg1 = (Dali::Path *)jarg1;
27840   arg2 = (Dali::Vector3 *)jarg2;
27841   if (!arg2) {
27842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27843     return ;
27844   }
27845   {
27846     try {
27847       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
27848     } CALL_CATCH_EXCEPTION();
27849   }
27850
27851 }
27852
27853
27854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
27855   Dali::Path *arg1 = (Dali::Path *) 0 ;
27856   float arg2 ;
27857
27858   arg1 = (Dali::Path *)jarg1;
27859   arg2 = (float)jarg2;
27860   {
27861     try {
27862       (arg1)->GenerateControlPoints(arg2);
27863     } CALL_CATCH_EXCEPTION();
27864   }
27865
27866 }
27867
27868
27869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27870   Dali::Path *arg1 = (Dali::Path *) 0 ;
27871   float arg2 ;
27872   Dali::Vector3 *arg3 = 0 ;
27873   Dali::Vector3 *arg4 = 0 ;
27874
27875   arg1 = (Dali::Path *)jarg1;
27876   arg2 = (float)jarg2;
27877   arg3 = (Dali::Vector3 *)jarg3;
27878   if (!arg3) {
27879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27880     return ;
27881   }
27882   arg4 = (Dali::Vector3 *)jarg4;
27883   if (!arg4) {
27884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27885     return ;
27886   }
27887   {
27888     try {
27889       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
27890     } CALL_CATCH_EXCEPTION();
27891   }
27892
27893 }
27894
27895
27896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
27897   void * jresult ;
27898   Dali::Path *arg1 = (Dali::Path *) 0 ;
27899   size_t arg2 ;
27900   Dali::Vector3 *result = 0 ;
27901
27902   arg1 = (Dali::Path *)jarg1;
27903   arg2 = (size_t)jarg2;
27904   {
27905     try {
27906       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
27907     } CALL_CATCH_EXCEPTION(0);
27908   }
27909
27910   jresult = (void *)result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
27916   void * jresult ;
27917   Dali::Path *arg1 = (Dali::Path *) 0 ;
27918   size_t arg2 ;
27919   Dali::Vector3 *result = 0 ;
27920
27921   arg1 = (Dali::Path *)jarg1;
27922   arg2 = (size_t)jarg2;
27923   {
27924     try {
27925       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
27926     } CALL_CATCH_EXCEPTION(0);
27927   }
27928
27929   jresult = (void *)result;
27930   return jresult;
27931 }
27932
27933
27934 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27935   unsigned long jresult ;
27936   Dali::Path *arg1 = (Dali::Path *) 0 ;
27937   size_t result;
27938
27939   arg1 = (Dali::Path *)jarg1;
27940   {
27941     try {
27942       result = ((Dali::Path const *)arg1)->GetPointCount();
27943     } CALL_CATCH_EXCEPTION(0);
27944   }
27945
27946   jresult = (unsigned long)result;
27947   return jresult;
27948 }
27949
27950
27951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27952   void * jresult ;
27953   float arg1 ;
27954   Dali::TimePeriod *result = 0 ;
27955
27956   arg1 = (float)jarg1;
27957   {
27958     try {
27959       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27960     } CALL_CATCH_EXCEPTION(0);
27961   }
27962
27963   jresult = (void *)result;
27964   return jresult;
27965 }
27966
27967
27968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27969   void * jresult ;
27970   float arg1 ;
27971   float arg2 ;
27972   Dali::TimePeriod *result = 0 ;
27973
27974   arg1 = (float)jarg1;
27975   arg2 = (float)jarg2;
27976   {
27977     try {
27978       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27979     } CALL_CATCH_EXCEPTION(0);
27980   }
27981
27982   jresult = (void *)result;
27983   return jresult;
27984 }
27985
27986
27987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27988   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27989
27990   arg1 = (Dali::TimePeriod *)jarg1;
27991   {
27992     try {
27993       delete arg1;
27994     } CALL_CATCH_EXCEPTION();
27995   }
27996
27997 }
27998
27999
28000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
28001   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28002   float arg2 ;
28003
28004   arg1 = (Dali::TimePeriod *)jarg1;
28005   arg2 = (float)jarg2;
28006   if (arg1) (arg1)->delaySeconds = arg2;
28007 }
28008
28009
28010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
28011   float jresult ;
28012   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28013   float result;
28014
28015   arg1 = (Dali::TimePeriod *)jarg1;
28016   result = (float) ((arg1)->delaySeconds);
28017   jresult = result;
28018   return jresult;
28019 }
28020
28021
28022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
28023   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28024   float arg2 ;
28025
28026   arg1 = (Dali::TimePeriod *)jarg1;
28027   arg2 = (float)jarg2;
28028   if (arg1) (arg1)->durationSeconds = arg2;
28029 }
28030
28031
28032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
28033   float jresult ;
28034   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
28035   float result;
28036
28037   arg1 = (Dali::TimePeriod *)jarg1;
28038   result = (float) ((arg1)->durationSeconds);
28039   jresult = result;
28040   return jresult;
28041 }
28042
28043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
28044   int jresult ;
28045   int result;
28046
28047   result = (int)Dali::LinearConstrainer::Property::VALUE;
28048   jresult = (int)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
28054   int jresult ;
28055   int result;
28056
28057   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
28058   jresult = (int)result;
28059   return jresult;
28060 }
28061
28062
28063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
28064   void * jresult ;
28065   Dali::LinearConstrainer::Property *result = 0 ;
28066
28067   {
28068     try {
28069       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
28070     } CALL_CATCH_EXCEPTION(0);
28071   }
28072
28073   jresult = (void *)result;
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
28079   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
28080
28081   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
28082   {
28083     try {
28084       delete arg1;
28085     } CALL_CATCH_EXCEPTION();
28086   }
28087
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
28092   void * jresult ;
28093   Dali::LinearConstrainer result;
28094
28095   {
28096     try {
28097       result = Dali::LinearConstrainer::New();
28098     } CALL_CATCH_EXCEPTION(0);
28099   }
28100
28101   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
28107   void * jresult ;
28108   Dali::BaseHandle arg1 ;
28109   Dali::BaseHandle *argp1 ;
28110   Dali::LinearConstrainer result;
28111
28112   argp1 = (Dali::BaseHandle *)jarg1;
28113   if (!argp1) {
28114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28115     return 0;
28116   }
28117   arg1 = *argp1;
28118   {
28119     try {
28120       result = Dali::LinearConstrainer::DownCast(arg1);
28121     } CALL_CATCH_EXCEPTION(0);
28122   }
28123
28124   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
28125   return jresult;
28126 }
28127
28128
28129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
28130   void * jresult ;
28131   Dali::LinearConstrainer *result = 0 ;
28132
28133   {
28134     try {
28135       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
28136     } CALL_CATCH_EXCEPTION(0);
28137   }
28138
28139   jresult = (void *)result;
28140   return jresult;
28141 }
28142
28143
28144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
28145   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28146
28147   arg1 = (Dali::LinearConstrainer *)jarg1;
28148   {
28149     try {
28150       delete arg1;
28151     } CALL_CATCH_EXCEPTION();
28152   }
28153
28154 }
28155
28156
28157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
28158   void * jresult ;
28159   Dali::LinearConstrainer *arg1 = 0 ;
28160   Dali::LinearConstrainer *result = 0 ;
28161
28162   arg1 = (Dali::LinearConstrainer *)jarg1;
28163   if (!arg1) {
28164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
28165     return 0;
28166   }
28167   {
28168     try {
28169       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
28170     } CALL_CATCH_EXCEPTION(0);
28171   }
28172
28173   jresult = (void *)result;
28174   return jresult;
28175 }
28176
28177
28178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
28179   void * jresult ;
28180   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28181   Dali::LinearConstrainer *arg2 = 0 ;
28182   Dali::LinearConstrainer *result = 0 ;
28183
28184   arg1 = (Dali::LinearConstrainer *)jarg1;
28185   arg2 = (Dali::LinearConstrainer *)jarg2;
28186   if (!arg2) {
28187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
28188     return 0;
28189   }
28190   {
28191     try {
28192       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
28193     } CALL_CATCH_EXCEPTION(0);
28194   }
28195
28196   jresult = (void *)result;
28197   return jresult;
28198 }
28199
28200
28201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
28202   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28203   SwigValueWrapper< Dali::Property > arg2 ;
28204   SwigValueWrapper< Dali::Property > arg3 ;
28205   Dali::Vector2 *arg4 = 0 ;
28206   Dali::Vector2 *arg5 = 0 ;
28207   Dali::Property *argp2 ;
28208   Dali::Property *argp3 ;
28209
28210   arg1 = (Dali::LinearConstrainer *)jarg1;
28211   argp2 = (Dali::Property *)jarg2;
28212   if (!argp2) {
28213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28214     return ;
28215   }
28216   arg2 = *argp2;
28217   argp3 = (Dali::Property *)jarg3;
28218   if (!argp3) {
28219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28220     return ;
28221   }
28222   arg3 = *argp3;
28223   arg4 = (Dali::Vector2 *)jarg4;
28224   if (!arg4) {
28225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28226     return ;
28227   }
28228   arg5 = (Dali::Vector2 *)jarg5;
28229   if (!arg5) {
28230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28231     return ;
28232   }
28233   {
28234     try {
28235       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
28236     } CALL_CATCH_EXCEPTION();
28237   }
28238
28239 }
28240
28241
28242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
28243   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28244   SwigValueWrapper< Dali::Property > arg2 ;
28245   SwigValueWrapper< Dali::Property > arg3 ;
28246   Dali::Vector2 *arg4 = 0 ;
28247   Dali::Property *argp2 ;
28248   Dali::Property *argp3 ;
28249
28250   arg1 = (Dali::LinearConstrainer *)jarg1;
28251   argp2 = (Dali::Property *)jarg2;
28252   if (!argp2) {
28253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28254     return ;
28255   }
28256   arg2 = *argp2;
28257   argp3 = (Dali::Property *)jarg3;
28258   if (!argp3) {
28259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28260     return ;
28261   }
28262   arg3 = *argp3;
28263   arg4 = (Dali::Vector2 *)jarg4;
28264   if (!arg4) {
28265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28266     return ;
28267   }
28268   {
28269     try {
28270       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
28271     } CALL_CATCH_EXCEPTION();
28272   }
28273
28274 }
28275
28276
28277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
28278   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
28279   Dali::Handle *arg2 = 0 ;
28280
28281   arg1 = (Dali::LinearConstrainer *)jarg1;
28282   arg2 = (Dali::Handle *)jarg2;
28283   if (!arg2) {
28284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
28285     return ;
28286   }
28287   {
28288     try {
28289       (arg1)->Remove(*arg2);
28290     } CALL_CATCH_EXCEPTION();
28291   }
28292
28293 }
28294
28295
28296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
28297   int jresult ;
28298   int result;
28299
28300   result = (int)Dali::PathConstrainer::Property::FORWARD;
28301   jresult = (int)result;
28302   return jresult;
28303 }
28304
28305
28306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
28307   int jresult ;
28308   int result;
28309
28310   result = (int)Dali::PathConstrainer::Property::POINTS;
28311   jresult = (int)result;
28312   return jresult;
28313 }
28314
28315
28316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
28317   int jresult ;
28318   int result;
28319
28320   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
28321   jresult = (int)result;
28322   return jresult;
28323 }
28324
28325
28326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
28327   void * jresult ;
28328   Dali::PathConstrainer::Property *result = 0 ;
28329
28330   {
28331     try {
28332       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
28333     } CALL_CATCH_EXCEPTION(0);
28334   }
28335
28336   jresult = (void *)result;
28337   return jresult;
28338 }
28339
28340
28341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
28342   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
28343
28344   arg1 = (Dali::PathConstrainer::Property *)jarg1;
28345   {
28346     try {
28347       delete arg1;
28348     } CALL_CATCH_EXCEPTION();
28349   }
28350
28351 }
28352
28353
28354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
28355   void * jresult ;
28356   Dali::PathConstrainer result;
28357
28358   {
28359     try {
28360       result = Dali::PathConstrainer::New();
28361     } CALL_CATCH_EXCEPTION(0);
28362   }
28363
28364   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
28365   return jresult;
28366 }
28367
28368
28369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
28370   void * jresult ;
28371   Dali::BaseHandle arg1 ;
28372   Dali::BaseHandle *argp1 ;
28373   Dali::PathConstrainer result;
28374
28375   argp1 = (Dali::BaseHandle *)jarg1;
28376   if (!argp1) {
28377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28378     return 0;
28379   }
28380   arg1 = *argp1;
28381   {
28382     try {
28383       result = Dali::PathConstrainer::DownCast(arg1);
28384     } CALL_CATCH_EXCEPTION(0);
28385   }
28386
28387   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
28388   return jresult;
28389 }
28390
28391
28392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
28393   void * jresult ;
28394   Dali::PathConstrainer *result = 0 ;
28395
28396   {
28397     try {
28398       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
28399     } CALL_CATCH_EXCEPTION(0);
28400   }
28401
28402   jresult = (void *)result;
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
28408   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28409
28410   arg1 = (Dali::PathConstrainer *)jarg1;
28411   {
28412     try {
28413       delete arg1;
28414     } CALL_CATCH_EXCEPTION();
28415   }
28416
28417 }
28418
28419
28420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
28421   void * jresult ;
28422   Dali::PathConstrainer *arg1 = 0 ;
28423   Dali::PathConstrainer *result = 0 ;
28424
28425   arg1 = (Dali::PathConstrainer *)jarg1;
28426   if (!arg1) {
28427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
28428     return 0;
28429   }
28430   {
28431     try {
28432       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
28433     } CALL_CATCH_EXCEPTION(0);
28434   }
28435
28436   jresult = (void *)result;
28437   return jresult;
28438 }
28439
28440
28441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
28442   void * jresult ;
28443   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28444   Dali::PathConstrainer *arg2 = 0 ;
28445   Dali::PathConstrainer *result = 0 ;
28446
28447   arg1 = (Dali::PathConstrainer *)jarg1;
28448   arg2 = (Dali::PathConstrainer *)jarg2;
28449   if (!arg2) {
28450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
28451     return 0;
28452   }
28453   {
28454     try {
28455       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
28456     } CALL_CATCH_EXCEPTION(0);
28457   }
28458
28459   jresult = (void *)result;
28460   return jresult;
28461 }
28462
28463
28464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
28465   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28466   SwigValueWrapper< Dali::Property > arg2 ;
28467   SwigValueWrapper< Dali::Property > arg3 ;
28468   Dali::Vector2 *arg4 = 0 ;
28469   Dali::Vector2 *arg5 = 0 ;
28470   Dali::Property *argp2 ;
28471   Dali::Property *argp3 ;
28472
28473   arg1 = (Dali::PathConstrainer *)jarg1;
28474   argp2 = (Dali::Property *)jarg2;
28475   if (!argp2) {
28476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28477     return ;
28478   }
28479   arg2 = *argp2;
28480   argp3 = (Dali::Property *)jarg3;
28481   if (!argp3) {
28482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28483     return ;
28484   }
28485   arg3 = *argp3;
28486   arg4 = (Dali::Vector2 *)jarg4;
28487   if (!arg4) {
28488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28489     return ;
28490   }
28491   arg5 = (Dali::Vector2 *)jarg5;
28492   if (!arg5) {
28493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28494     return ;
28495   }
28496   {
28497     try {
28498       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
28499     } CALL_CATCH_EXCEPTION();
28500   }
28501
28502 }
28503
28504
28505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
28506   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28507   SwigValueWrapper< Dali::Property > arg2 ;
28508   SwigValueWrapper< Dali::Property > arg3 ;
28509   Dali::Vector2 *arg4 = 0 ;
28510   Dali::Property *argp2 ;
28511   Dali::Property *argp3 ;
28512
28513   arg1 = (Dali::PathConstrainer *)jarg1;
28514   argp2 = (Dali::Property *)jarg2;
28515   if (!argp2) {
28516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28517     return ;
28518   }
28519   arg2 = *argp2;
28520   argp3 = (Dali::Property *)jarg3;
28521   if (!argp3) {
28522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
28523     return ;
28524   }
28525   arg3 = *argp3;
28526   arg4 = (Dali::Vector2 *)jarg4;
28527   if (!arg4) {
28528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28529     return ;
28530   }
28531   {
28532     try {
28533       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
28534     } CALL_CATCH_EXCEPTION();
28535   }
28536
28537 }
28538
28539
28540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
28541   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
28542   Dali::Handle *arg2 = 0 ;
28543
28544   arg1 = (Dali::PathConstrainer *)jarg1;
28545   arg2 = (Dali::Handle *)jarg2;
28546   if (!arg2) {
28547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
28548     return ;
28549   }
28550   {
28551     try {
28552       (arg1)->Remove(*arg2);
28553     } CALL_CATCH_EXCEPTION();
28554   }
28555
28556 }
28557
28558
28559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
28560   int jresult ;
28561   Dali::FittingMode::Type result;
28562
28563   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
28564   jresult = (int)result;
28565   return jresult;
28566 }
28567
28568
28569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
28570   int jresult ;
28571   Dali::SamplingMode::Type result;
28572
28573   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
28574   jresult = (int)result;
28575   return jresult;
28576 }
28577
28578
28579 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
28580   bool jresult ;
28581   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28582   bool result;
28583
28584   arg1 = (Dali::NativeImageInterface *)jarg1;
28585   {
28586     try {
28587       result = (bool)(arg1)->CreateResource();
28588     } CALL_CATCH_EXCEPTION(0);
28589   }
28590
28591   jresult = result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
28597   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28598
28599   arg1 = (Dali::NativeImageInterface *)jarg1;
28600   {
28601     try {
28602       (arg1)->DestroyResource();
28603     } CALL_CATCH_EXCEPTION();
28604   }
28605
28606 }
28607
28608
28609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
28610   unsigned int jresult ;
28611   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28612   unsigned int result;
28613
28614   arg1 = (Dali::NativeImageInterface *)jarg1;
28615   {
28616     try {
28617       result = (unsigned int)(arg1)->TargetTexture();
28618     } CALL_CATCH_EXCEPTION(0);
28619   }
28620
28621   jresult = result;
28622   return jresult;
28623 }
28624
28625
28626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
28627   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28628
28629   arg1 = (Dali::NativeImageInterface *)jarg1;
28630   {
28631     try {
28632       (arg1)->PrepareTexture();
28633     } CALL_CATCH_EXCEPTION();
28634   }
28635
28636 }
28637
28638
28639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
28640   unsigned int jresult ;
28641   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28642   unsigned int result;
28643
28644   arg1 = (Dali::NativeImageInterface *)jarg1;
28645   {
28646     try {
28647       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
28648     } CALL_CATCH_EXCEPTION(0);
28649   }
28650
28651   jresult = result;
28652   return jresult;
28653 }
28654
28655
28656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
28657   unsigned int jresult ;
28658   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28659   unsigned int result;
28660
28661   arg1 = (Dali::NativeImageInterface *)jarg1;
28662   {
28663     try {
28664       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
28665     } CALL_CATCH_EXCEPTION(0);
28666   }
28667
28668   jresult = result;
28669   return jresult;
28670 }
28671
28672
28673 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
28674   bool jresult ;
28675   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
28676   bool result;
28677
28678   arg1 = (Dali::NativeImageInterface *)jarg1;
28679   {
28680     try {
28681       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
28682     } CALL_CATCH_EXCEPTION(0);
28683   }
28684
28685   jresult = result;
28686   return jresult;
28687 }
28688
28689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
28690   int jresult ;
28691   int result;
28692
28693   result = (int)Dali::CameraActor::Property::TYPE;
28694   jresult = (int)result;
28695   return jresult;
28696 }
28697
28698
28699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
28700   int jresult ;
28701   int result;
28702
28703   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
28704   jresult = (int)result;
28705   return jresult;
28706 }
28707
28708
28709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
28710   int jresult ;
28711   int result;
28712
28713   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
28714   jresult = (int)result;
28715   return jresult;
28716 }
28717
28718
28719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
28720   int jresult ;
28721   int result;
28722
28723   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
28724   jresult = (int)result;
28725   return jresult;
28726 }
28727
28728
28729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
28730   int jresult ;
28731   int result;
28732
28733   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
28734   jresult = (int)result;
28735   return jresult;
28736 }
28737
28738
28739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
28740   int jresult ;
28741   int result;
28742
28743   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
28744   jresult = (int)result;
28745   return jresult;
28746 }
28747
28748
28749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
28750   int jresult ;
28751   int result;
28752
28753   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
28754   jresult = (int)result;
28755   return jresult;
28756 }
28757
28758
28759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
28760   int jresult ;
28761   int result;
28762
28763   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
28764   jresult = (int)result;
28765   return jresult;
28766 }
28767
28768
28769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
28770   int jresult ;
28771   int result;
28772
28773   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
28774   jresult = (int)result;
28775   return jresult;
28776 }
28777
28778
28779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
28780   int jresult ;
28781   int result;
28782
28783   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
28784   jresult = (int)result;
28785   return jresult;
28786 }
28787
28788
28789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
28790   int jresult ;
28791   int result;
28792
28793   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
28794   jresult = (int)result;
28795   return jresult;
28796 }
28797
28798
28799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
28800   int jresult ;
28801   int result;
28802
28803   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
28804   jresult = (int)result;
28805   return jresult;
28806 }
28807
28808
28809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
28810   int jresult ;
28811   int result;
28812
28813   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
28814   jresult = (int)result;
28815   return jresult;
28816 }
28817
28818
28819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
28820   int jresult ;
28821   int result;
28822
28823   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
28824   jresult = (int)result;
28825   return jresult;
28826 }
28827
28828
28829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
28830   void * jresult ;
28831   Dali::CameraActor::Property *result = 0 ;
28832
28833   {
28834     try {
28835       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
28836     } CALL_CATCH_EXCEPTION(0);
28837   }
28838
28839   jresult = (void *)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
28845   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
28846
28847   arg1 = (Dali::CameraActor::Property *)jarg1;
28848   {
28849     try {
28850       delete arg1;
28851     } CALL_CATCH_EXCEPTION();
28852   }
28853
28854 }
28855
28856
28857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
28858   void * jresult ;
28859   Dali::CameraActor *result = 0 ;
28860
28861   {
28862     try {
28863       result = (Dali::CameraActor *)new Dali::CameraActor();
28864     } CALL_CATCH_EXCEPTION(0);
28865   }
28866
28867   jresult = (void *)result;
28868   return jresult;
28869 }
28870
28871
28872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
28873   void * jresult ;
28874   Dali::CameraActor result;
28875
28876   {
28877     try {
28878       result = Dali::CameraActor::New();
28879     } CALL_CATCH_EXCEPTION(0);
28880   }
28881
28882   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28883   return jresult;
28884 }
28885
28886
28887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
28888   void * jresult ;
28889   Dali::Size *arg1 = 0 ;
28890   Dali::CameraActor result;
28891
28892   arg1 = (Dali::Size *)jarg1;
28893   if (!arg1) {
28894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28895     return 0;
28896   }
28897   {
28898     try {
28899       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
28900     } CALL_CATCH_EXCEPTION(0);
28901   }
28902
28903   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28904   return jresult;
28905 }
28906
28907
28908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
28909   void * jresult ;
28910   Dali::BaseHandle arg1 ;
28911   Dali::BaseHandle *argp1 ;
28912   Dali::CameraActor result;
28913
28914   argp1 = (Dali::BaseHandle *)jarg1;
28915   if (!argp1) {
28916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28917     return 0;
28918   }
28919   arg1 = *argp1;
28920   {
28921     try {
28922       result = Dali::CameraActor::DownCast(arg1);
28923     } CALL_CATCH_EXCEPTION(0);
28924   }
28925
28926   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
28932   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28933
28934   arg1 = (Dali::CameraActor *)jarg1;
28935   {
28936     try {
28937       delete arg1;
28938     } CALL_CATCH_EXCEPTION();
28939   }
28940
28941 }
28942
28943
28944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28945   void * jresult ;
28946   Dali::CameraActor *arg1 = 0 ;
28947   Dali::CameraActor *result = 0 ;
28948
28949   arg1 = (Dali::CameraActor *)jarg1;
28950   if (!arg1) {
28951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28952     return 0;
28953   }
28954   {
28955     try {
28956       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28957     } CALL_CATCH_EXCEPTION(0);
28958   }
28959
28960   jresult = (void *)result;
28961   return jresult;
28962 }
28963
28964
28965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28966   void * jresult ;
28967   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28968   Dali::CameraActor *arg2 = 0 ;
28969   Dali::CameraActor *result = 0 ;
28970
28971   arg1 = (Dali::CameraActor *)jarg1;
28972   arg2 = (Dali::CameraActor *)jarg2;
28973   if (!arg2) {
28974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28975     return 0;
28976   }
28977   {
28978     try {
28979       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28980     } CALL_CATCH_EXCEPTION(0);
28981   }
28982
28983   jresult = (void *)result;
28984   return jresult;
28985 }
28986
28987
28988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28989   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28990   Dali::Camera::Type arg2 ;
28991
28992   arg1 = (Dali::CameraActor *)jarg1;
28993   arg2 = (Dali::Camera::Type)jarg2;
28994   {
28995     try {
28996       (arg1)->SetType(arg2);
28997     } CALL_CATCH_EXCEPTION();
28998   }
28999
29000 }
29001
29002
29003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
29004   int jresult ;
29005   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29006   Dali::Camera::Type result;
29007
29008   arg1 = (Dali::CameraActor *)jarg1;
29009   {
29010     try {
29011       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
29012     } CALL_CATCH_EXCEPTION(0);
29013   }
29014
29015   jresult = (int)result;
29016   return jresult;
29017 }
29018
29019
29020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
29021   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29022   Dali::Camera::ProjectionMode arg2 ;
29023
29024   arg1 = (Dali::CameraActor *)jarg1;
29025   arg2 = (Dali::Camera::ProjectionMode)jarg2;
29026   {
29027     try {
29028       (arg1)->SetProjectionMode(arg2);
29029     } CALL_CATCH_EXCEPTION();
29030   }
29031
29032 }
29033
29034
29035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
29036   int jresult ;
29037   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29038   Dali::Camera::ProjectionMode result;
29039
29040   arg1 = (Dali::CameraActor *)jarg1;
29041   {
29042     try {
29043       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
29044     } CALL_CATCH_EXCEPTION(0);
29045   }
29046
29047   jresult = (int)result;
29048   return jresult;
29049 }
29050
29051
29052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
29053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29054   float arg2 ;
29055
29056   arg1 = (Dali::CameraActor *)jarg1;
29057   arg2 = (float)jarg2;
29058   {
29059     try {
29060       (arg1)->SetFieldOfView(arg2);
29061     } CALL_CATCH_EXCEPTION();
29062   }
29063
29064 }
29065
29066
29067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
29068   float jresult ;
29069   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29070   float result;
29071
29072   arg1 = (Dali::CameraActor *)jarg1;
29073   {
29074     try {
29075       result = (float)(arg1)->GetFieldOfView();
29076     } CALL_CATCH_EXCEPTION(0);
29077   }
29078
29079   jresult = result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
29085   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29086   float arg2 ;
29087
29088   arg1 = (Dali::CameraActor *)jarg1;
29089   arg2 = (float)jarg2;
29090   {
29091     try {
29092       (arg1)->SetAspectRatio(arg2);
29093     } CALL_CATCH_EXCEPTION();
29094   }
29095
29096 }
29097
29098
29099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
29100   float jresult ;
29101   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29102   float result;
29103
29104   arg1 = (Dali::CameraActor *)jarg1;
29105   {
29106     try {
29107       result = (float)(arg1)->GetAspectRatio();
29108     } CALL_CATCH_EXCEPTION(0);
29109   }
29110
29111   jresult = result;
29112   return jresult;
29113 }
29114
29115
29116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
29117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29118   float arg2 ;
29119
29120   arg1 = (Dali::CameraActor *)jarg1;
29121   arg2 = (float)jarg2;
29122   {
29123     try {
29124       (arg1)->SetNearClippingPlane(arg2);
29125     } CALL_CATCH_EXCEPTION();
29126   }
29127
29128 }
29129
29130
29131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
29132   float jresult ;
29133   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29134   float result;
29135
29136   arg1 = (Dali::CameraActor *)jarg1;
29137   {
29138     try {
29139       result = (float)(arg1)->GetNearClippingPlane();
29140     } CALL_CATCH_EXCEPTION(0);
29141   }
29142
29143   jresult = result;
29144   return jresult;
29145 }
29146
29147
29148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
29149   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29150   float arg2 ;
29151
29152   arg1 = (Dali::CameraActor *)jarg1;
29153   arg2 = (float)jarg2;
29154   {
29155     try {
29156       (arg1)->SetFarClippingPlane(arg2);
29157     } CALL_CATCH_EXCEPTION();
29158   }
29159
29160 }
29161
29162
29163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
29164   float jresult ;
29165   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29166   float result;
29167
29168   arg1 = (Dali::CameraActor *)jarg1;
29169   {
29170     try {
29171       result = (float)(arg1)->GetFarClippingPlane();
29172     } CALL_CATCH_EXCEPTION(0);
29173   }
29174
29175   jresult = result;
29176   return jresult;
29177 }
29178
29179
29180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
29181   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29182   Dali::Vector3 *arg2 = 0 ;
29183
29184   arg1 = (Dali::CameraActor *)jarg1;
29185   arg2 = (Dali::Vector3 *)jarg2;
29186   if (!arg2) {
29187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29188     return ;
29189   }
29190   {
29191     try {
29192       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
29193     } CALL_CATCH_EXCEPTION();
29194   }
29195
29196 }
29197
29198
29199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
29200   void * jresult ;
29201   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29202   Dali::Vector3 result;
29203
29204   arg1 = (Dali::CameraActor *)jarg1;
29205   {
29206     try {
29207       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
29208     } CALL_CATCH_EXCEPTION(0);
29209   }
29210
29211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29212   return jresult;
29213 }
29214
29215
29216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
29217   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29218   bool arg2 ;
29219
29220   arg1 = (Dali::CameraActor *)jarg1;
29221   arg2 = jarg2 ? true : false;
29222   {
29223     try {
29224       (arg1)->SetInvertYAxis(arg2);
29225     } CALL_CATCH_EXCEPTION();
29226   }
29227
29228 }
29229
29230
29231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
29232   bool jresult ;
29233   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29234   bool result;
29235
29236   arg1 = (Dali::CameraActor *)jarg1;
29237   {
29238     try {
29239       result = (bool)(arg1)->GetInvertYAxis();
29240     } CALL_CATCH_EXCEPTION(0);
29241   }
29242
29243   jresult = result;
29244   return jresult;
29245 }
29246
29247
29248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
29249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29250   Dali::Size *arg2 = 0 ;
29251
29252   arg1 = (Dali::CameraActor *)jarg1;
29253   arg2 = (Dali::Size *)jarg2;
29254   if (!arg2) {
29255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29256     return ;
29257   }
29258   {
29259     try {
29260       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
29261     } CALL_CATCH_EXCEPTION();
29262   }
29263
29264 }
29265
29266
29267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
29268   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29269   Dali::Size *arg2 = 0 ;
29270
29271   arg1 = (Dali::CameraActor *)jarg1;
29272   arg2 = (Dali::Size *)jarg2;
29273   if (!arg2) {
29274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
29275     return ;
29276   }
29277   {
29278     try {
29279       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
29280     } CALL_CATCH_EXCEPTION();
29281   }
29282
29283 }
29284
29285
29286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
29287   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
29288   float arg2 ;
29289   float arg3 ;
29290   float arg4 ;
29291   float arg5 ;
29292   float arg6 ;
29293   float arg7 ;
29294
29295   arg1 = (Dali::CameraActor *)jarg1;
29296   arg2 = (float)jarg2;
29297   arg3 = (float)jarg3;
29298   arg4 = (float)jarg4;
29299   arg5 = (float)jarg5;
29300   arg6 = (float)jarg6;
29301   arg7 = (float)jarg7;
29302   {
29303     try {
29304       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
29305     } CALL_CATCH_EXCEPTION();
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
29312   void * jresult ;
29313   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29314
29315   {
29316     try {
29317       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
29318     } CALL_CATCH_EXCEPTION(0);
29319   }
29320
29321   jresult = (void *)result;
29322   return jresult;
29323 }
29324
29325
29326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
29327   void * jresult ;
29328   std::string arg1 ;
29329   Dali::Property::Value arg2 ;
29330   Dali::Property::Value *argp2 ;
29331   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29332
29333   if (!jarg1) {
29334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29335     return 0;
29336   }
29337   (&arg1)->assign(jarg1);
29338   argp2 = (Dali::Property::Value *)jarg2;
29339   if (!argp2) {
29340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
29341     return 0;
29342   }
29343   arg2 = *argp2;
29344   {
29345     try {
29346       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
29347     } CALL_CATCH_EXCEPTION(0);
29348   }
29349
29350   jresult = (void *)result;
29351   return jresult;
29352 }
29353
29354
29355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
29356   void * jresult ;
29357   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
29358   std::pair< std::string,Dali::Property::Value > *result = 0 ;
29359
29360   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29361   if (!arg1) {
29362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
29363     return 0;
29364   }
29365   {
29366     try {
29367       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);
29368     } CALL_CATCH_EXCEPTION(0);
29369   }
29370
29371   jresult = (void *)result;
29372   return jresult;
29373 }
29374
29375
29376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
29377   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29378   std::string *arg2 = 0 ;
29379
29380   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29381   if (!jarg2) {
29382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29383     return ;
29384   }
29385   std::string arg2_str(jarg2);
29386   arg2 = &arg2_str;
29387   if (arg1) (arg1)->first = *arg2;
29388
29389   //argout typemap for const std::string&
29390
29391 }
29392
29393
29394 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
29395   char * jresult ;
29396   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29397   std::string *result = 0 ;
29398
29399   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29400   result = (std::string *) & ((arg1)->first);
29401   jresult = SWIG_csharp_string_callback(result->c_str());
29402   return jresult;
29403 }
29404
29405
29406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
29407   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29408   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
29409
29410   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29411   arg2 = (Dali::Property::Value *)jarg2;
29412   if (arg1) (arg1)->second = *arg2;
29413 }
29414
29415
29416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
29417   void * jresult ;
29418   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29419   Dali::Property::Value *result = 0 ;
29420
29421   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29422   result = (Dali::Property::Value *)& ((arg1)->second);
29423   jresult = (void *)result;
29424   return jresult;
29425 }
29426
29427
29428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
29429   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
29430
29431   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
29432   {
29433     try {
29434       delete arg1;
29435     } CALL_CATCH_EXCEPTION();
29436   }
29437
29438 }
29439
29440
29441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
29442   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29443
29444   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29445   {
29446     try {
29447       (arg1)->clear();
29448     } CALL_CATCH_EXCEPTION();
29449   }
29450
29451 }
29452
29453
29454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
29455   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29456   Dali::TouchPoint *arg2 = 0 ;
29457
29458   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29459   arg2 = (Dali::TouchPoint *)jarg2;
29460   if (!arg2) {
29461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29462     return ;
29463   }
29464   {
29465     try {
29466       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
29467     } CALL_CATCH_EXCEPTION();
29468   }
29469
29470 }
29471
29472
29473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
29474   unsigned long jresult ;
29475   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29476   std::vector< Dali::TouchPoint >::size_type result;
29477
29478   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29479   {
29480     try {
29481       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
29482     } CALL_CATCH_EXCEPTION(0);
29483   }
29484
29485   jresult = (unsigned long)result;
29486   return jresult;
29487 }
29488
29489
29490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
29491   unsigned long jresult ;
29492   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29493   std::vector< Dali::TouchPoint >::size_type result;
29494
29495   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29496   {
29497     try {
29498       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
29499     } CALL_CATCH_EXCEPTION(0);
29500   }
29501
29502   jresult = (unsigned long)result;
29503   return jresult;
29504 }
29505
29506
29507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
29508   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29509   std::vector< Dali::TouchPoint >::size_type arg2 ;
29510
29511   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29512   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
29513   {
29514     try {
29515       (arg1)->reserve(arg2);
29516     } CALL_CATCH_EXCEPTION();
29517   }
29518
29519 }
29520
29521
29522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
29523   void * jresult ;
29524   std::vector< Dali::TouchPoint > *result = 0 ;
29525
29526   {
29527     try {
29528       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
29529     } CALL_CATCH_EXCEPTION(0);
29530   }
29531
29532   jresult = (void *)result;
29533   return jresult;
29534 }
29535
29536
29537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
29538   void * jresult ;
29539   std::vector< Dali::TouchPoint > *arg1 = 0 ;
29540   std::vector< Dali::TouchPoint > *result = 0 ;
29541
29542   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29543   if (!arg1) {
29544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29545     return 0;
29546   }
29547   {
29548     try {
29549       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
29550     } CALL_CATCH_EXCEPTION(0);
29551   }
29552
29553   jresult = (void *)result;
29554   return jresult;
29555 }
29556
29557
29558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
29559   void * jresult ;
29560   int arg1 ;
29561   std::vector< Dali::TouchPoint > *result = 0 ;
29562
29563   arg1 = (int)jarg1;
29564   {
29565     try {
29566       try {
29567         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
29568       }
29569       catch(std::out_of_range &_e) {
29570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29571         return 0;
29572       }
29573
29574     } CALL_CATCH_EXCEPTION(0);
29575   }
29576
29577   jresult = (void *)result;
29578   return jresult;
29579 }
29580
29581
29582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
29583   void * jresult ;
29584   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29585   int arg2 ;
29586   SwigValueWrapper< Dali::TouchPoint > result;
29587
29588   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29589   arg2 = (int)jarg2;
29590   {
29591     try {
29592       try {
29593         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
29594       }
29595       catch(std::out_of_range &_e) {
29596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29597         return 0;
29598       }
29599
29600     } CALL_CATCH_EXCEPTION(0);
29601   }
29602
29603   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
29604   return jresult;
29605 }
29606
29607
29608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
29609   void * jresult ;
29610   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29611   int arg2 ;
29612   Dali::TouchPoint *result = 0 ;
29613
29614   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29615   arg2 = (int)jarg2;
29616   {
29617     try {
29618       try {
29619         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
29620       }
29621       catch(std::out_of_range &_e) {
29622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29623         return 0;
29624       }
29625
29626     } CALL_CATCH_EXCEPTION(0);
29627   }
29628
29629   jresult = (void *)result;
29630   return jresult;
29631 }
29632
29633
29634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
29635   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29636   int arg2 ;
29637   Dali::TouchPoint *arg3 = 0 ;
29638
29639   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29640   arg2 = (int)jarg2;
29641   arg3 = (Dali::TouchPoint *)jarg3;
29642   if (!arg3) {
29643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29644     return ;
29645   }
29646   {
29647     try {
29648       try {
29649         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
29650       }
29651       catch(std::out_of_range &_e) {
29652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29653         return ;
29654       }
29655
29656     } CALL_CATCH_EXCEPTION();
29657   }
29658
29659 }
29660
29661
29662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
29663   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29664   std::vector< Dali::TouchPoint > *arg2 = 0 ;
29665
29666   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29667   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
29668   if (!arg2) {
29669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29670     return ;
29671   }
29672   {
29673     try {
29674       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
29675     } CALL_CATCH_EXCEPTION();
29676   }
29677
29678 }
29679
29680
29681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
29682   void * jresult ;
29683   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29684   int arg2 ;
29685   int arg3 ;
29686   std::vector< Dali::TouchPoint > *result = 0 ;
29687
29688   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29689   arg2 = (int)jarg2;
29690   arg3 = (int)jarg3;
29691   {
29692     try {
29693       try {
29694         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
29695       }
29696       catch(std::out_of_range &_e) {
29697         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29698         return 0;
29699       }
29700       catch(std::invalid_argument &_e) {
29701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29702         return 0;
29703       }
29704
29705     } CALL_CATCH_EXCEPTION(0);
29706   }
29707
29708   jresult = (void *)result;
29709   return jresult;
29710 }
29711
29712
29713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
29714   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29715   int arg2 ;
29716   Dali::TouchPoint *arg3 = 0 ;
29717
29718   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29719   arg2 = (int)jarg2;
29720   arg3 = (Dali::TouchPoint *)jarg3;
29721   if (!arg3) {
29722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29723     return ;
29724   }
29725   {
29726     try {
29727       try {
29728         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
29729       }
29730       catch(std::out_of_range &_e) {
29731         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29732         return ;
29733       }
29734
29735     } CALL_CATCH_EXCEPTION();
29736   }
29737
29738 }
29739
29740
29741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
29742   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29743   int arg2 ;
29744   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29745
29746   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29747   arg2 = (int)jarg2;
29748   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29749   if (!arg3) {
29750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29751     return ;
29752   }
29753   {
29754     try {
29755       try {
29756         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29757       }
29758       catch(std::out_of_range &_e) {
29759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29760         return ;
29761       }
29762
29763     } CALL_CATCH_EXCEPTION();
29764   }
29765
29766 }
29767
29768
29769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
29770   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29771   int arg2 ;
29772
29773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29774   arg2 = (int)jarg2;
29775   {
29776     try {
29777       try {
29778         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
29779       }
29780       catch(std::out_of_range &_e) {
29781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29782         return ;
29783       }
29784
29785     } CALL_CATCH_EXCEPTION();
29786   }
29787
29788 }
29789
29790
29791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
29792   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29793   int arg2 ;
29794   int arg3 ;
29795
29796   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29797   arg2 = (int)jarg2;
29798   arg3 = (int)jarg3;
29799   {
29800     try {
29801       try {
29802         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
29803       }
29804       catch(std::out_of_range &_e) {
29805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29806         return ;
29807       }
29808       catch(std::invalid_argument &_e) {
29809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29810         return ;
29811       }
29812
29813     } CALL_CATCH_EXCEPTION();
29814   }
29815
29816 }
29817
29818
29819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
29820   void * jresult ;
29821   Dali::TouchPoint *arg1 = 0 ;
29822   int arg2 ;
29823   std::vector< Dali::TouchPoint > *result = 0 ;
29824
29825   arg1 = (Dali::TouchPoint *)jarg1;
29826   if (!arg1) {
29827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29828     return 0;
29829   }
29830   arg2 = (int)jarg2;
29831   {
29832     try {
29833       try {
29834         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
29835       }
29836       catch(std::out_of_range &_e) {
29837         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29838         return 0;
29839       }
29840
29841     } CALL_CATCH_EXCEPTION(0);
29842   }
29843
29844   jresult = (void *)result;
29845   return jresult;
29846 }
29847
29848
29849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
29850   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29851
29852   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29853   {
29854     try {
29855       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
29856     } CALL_CATCH_EXCEPTION();
29857   }
29858
29859 }
29860
29861
29862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
29863   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29864   int arg2 ;
29865   int arg3 ;
29866
29867   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29868   arg2 = (int)jarg2;
29869   arg3 = (int)jarg3;
29870   {
29871     try {
29872       try {
29873         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
29874       }
29875       catch(std::out_of_range &_e) {
29876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29877         return ;
29878       }
29879       catch(std::invalid_argument &_e) {
29880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29881         return ;
29882       }
29883
29884     } CALL_CATCH_EXCEPTION();
29885   }
29886
29887 }
29888
29889
29890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
29891   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29892   int arg2 ;
29893   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29894
29895   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29896   arg2 = (int)jarg2;
29897   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29898   if (!arg3) {
29899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29900     return ;
29901   }
29902   {
29903     try {
29904       try {
29905         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29906       }
29907       catch(std::out_of_range &_e) {
29908         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29909         return ;
29910       }
29911
29912     } CALL_CATCH_EXCEPTION();
29913   }
29914
29915 }
29916
29917
29918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
29919   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29920
29921   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29922   {
29923     try {
29924       delete arg1;
29925     } CALL_CATCH_EXCEPTION();
29926   }
29927
29928 }
29929
29930
29931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
29932   void * jresult ;
29933   Dali::Rect< int > *result = 0 ;
29934
29935   {
29936     try {
29937       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29938     } CALL_CATCH_EXCEPTION(0);
29939   }
29940
29941   jresult = (void *)result;
29942   return jresult;
29943 }
29944
29945
29946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29947   void * jresult ;
29948   int arg1 ;
29949   int arg2 ;
29950   int arg3 ;
29951   int arg4 ;
29952   Dali::Rect< int > *result = 0 ;
29953
29954   arg1 = (int)jarg1;
29955   arg2 = (int)jarg2;
29956   arg3 = (int)jarg3;
29957   arg4 = (int)jarg4;
29958   {
29959     try {
29960       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29961     } CALL_CATCH_EXCEPTION(0);
29962   }
29963
29964   jresult = (void *)result;
29965   return jresult;
29966 }
29967
29968
29969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29970   void * jresult ;
29971   Dali::Rect< int > *arg1 = 0 ;
29972   Dali::Rect< int > *result = 0 ;
29973
29974   arg1 = (Dali::Rect< int > *)jarg1;
29975   if (!arg1) {
29976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29977     return 0;
29978   }
29979   {
29980     try {
29981       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29982     } CALL_CATCH_EXCEPTION(0);
29983   }
29984
29985   jresult = (void *)result;
29986   return jresult;
29987 }
29988
29989
29990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29991   void * jresult ;
29992   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29993   Dali::Rect< int > *arg2 = 0 ;
29994   Dali::Rect< int > *result = 0 ;
29995
29996   arg1 = (Dali::Rect< int > *)jarg1;
29997   arg2 = (Dali::Rect< int > *)jarg2;
29998   if (!arg2) {
29999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30000     return 0;
30001   }
30002   {
30003     try {
30004       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
30005     } CALL_CATCH_EXCEPTION(0);
30006   }
30007
30008   jresult = (void *)result;
30009   return jresult;
30010 }
30011
30012
30013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
30014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30015   int arg2 ;
30016   int arg3 ;
30017   int arg4 ;
30018   int arg5 ;
30019
30020   arg1 = (Dali::Rect< int > *)jarg1;
30021   arg2 = (int)jarg2;
30022   arg3 = (int)jarg3;
30023   arg4 = (int)jarg4;
30024   arg5 = (int)jarg5;
30025   {
30026     try {
30027       (arg1)->Set(arg2,arg3,arg4,arg5);
30028     } CALL_CATCH_EXCEPTION();
30029   }
30030
30031 }
30032
30033
30034 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
30035   bool jresult ;
30036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30037   bool result;
30038
30039   arg1 = (Dali::Rect< int > *)jarg1;
30040   {
30041     try {
30042       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
30043     } CALL_CATCH_EXCEPTION(0);
30044   }
30045
30046   jresult = result;
30047   return jresult;
30048 }
30049
30050
30051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
30052   int jresult ;
30053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30054   int result;
30055
30056   arg1 = (Dali::Rect< int > *)jarg1;
30057   {
30058     try {
30059       result = (int)((Dali::Rect< int > const *)arg1)->Left();
30060     } CALL_CATCH_EXCEPTION(0);
30061   }
30062
30063   jresult = result;
30064   return jresult;
30065 }
30066
30067
30068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
30069   int jresult ;
30070   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30071   int result;
30072
30073   arg1 = (Dali::Rect< int > *)jarg1;
30074   {
30075     try {
30076       result = (int)((Dali::Rect< int > const *)arg1)->Right();
30077     } CALL_CATCH_EXCEPTION(0);
30078   }
30079
30080   jresult = result;
30081   return jresult;
30082 }
30083
30084
30085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
30086   int jresult ;
30087   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30088   int result;
30089
30090   arg1 = (Dali::Rect< int > *)jarg1;
30091   {
30092     try {
30093       result = (int)((Dali::Rect< int > const *)arg1)->Top();
30094     } CALL_CATCH_EXCEPTION(0);
30095   }
30096
30097   jresult = result;
30098   return jresult;
30099 }
30100
30101
30102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
30103   int jresult ;
30104   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30105   int result;
30106
30107   arg1 = (Dali::Rect< int > *)jarg1;
30108   {
30109     try {
30110       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
30111     } CALL_CATCH_EXCEPTION(0);
30112   }
30113
30114   jresult = result;
30115   return jresult;
30116 }
30117
30118
30119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
30120   int jresult ;
30121   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30122   int result;
30123
30124   arg1 = (Dali::Rect< int > *)jarg1;
30125   {
30126     try {
30127       result = (int)((Dali::Rect< int > const *)arg1)->Area();
30128     } CALL_CATCH_EXCEPTION(0);
30129   }
30130
30131   jresult = result;
30132   return jresult;
30133 }
30134
30135
30136 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
30137   bool jresult ;
30138   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30139   Dali::Rect< int > *arg2 = 0 ;
30140   bool result;
30141
30142   arg1 = (Dali::Rect< int > *)jarg1;
30143   arg2 = (Dali::Rect< int > *)jarg2;
30144   if (!arg2) {
30145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30146     return 0;
30147   }
30148   {
30149     try {
30150       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
30151     } CALL_CATCH_EXCEPTION(0);
30152   }
30153
30154   jresult = result;
30155   return jresult;
30156 }
30157
30158
30159 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
30160   bool jresult ;
30161   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30162   Dali::Rect< int > *arg2 = 0 ;
30163   bool result;
30164
30165   arg1 = (Dali::Rect< int > *)jarg1;
30166   arg2 = (Dali::Rect< int > *)jarg2;
30167   if (!arg2) {
30168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
30169     return 0;
30170   }
30171   {
30172     try {
30173       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
30174     } CALL_CATCH_EXCEPTION(0);
30175   }
30176
30177   jresult = result;
30178   return jresult;
30179 }
30180
30181
30182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
30183   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30184   int arg2 ;
30185
30186   arg1 = (Dali::Rect< int > *)jarg1;
30187   arg2 = (int)jarg2;
30188   if (arg1) (arg1)->x = arg2;
30189 }
30190
30191
30192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
30193   int jresult ;
30194   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30195   int result;
30196
30197   arg1 = (Dali::Rect< int > *)jarg1;
30198   result = (int) ((arg1)->x);
30199   jresult = result;
30200   return jresult;
30201 }
30202
30203
30204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
30205   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30206   int arg2 ;
30207
30208   arg1 = (Dali::Rect< int > *)jarg1;
30209   arg2 = (int)jarg2;
30210   if (arg1) (arg1)->left = arg2;
30211 }
30212
30213
30214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
30215   int jresult ;
30216   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30217   int result;
30218
30219   arg1 = (Dali::Rect< int > *)jarg1;
30220   result = (int) ((arg1)->left);
30221   jresult = result;
30222   return jresult;
30223 }
30224
30225
30226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
30227   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30228   int arg2 ;
30229
30230   arg1 = (Dali::Rect< int > *)jarg1;
30231   arg2 = (int)jarg2;
30232   if (arg1) (arg1)->y = arg2;
30233 }
30234
30235
30236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
30237   int jresult ;
30238   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30239   int result;
30240
30241   arg1 = (Dali::Rect< int > *)jarg1;
30242   result = (int) ((arg1)->y);
30243   jresult = result;
30244   return jresult;
30245 }
30246
30247
30248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
30249   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30250   int arg2 ;
30251
30252   arg1 = (Dali::Rect< int > *)jarg1;
30253   arg2 = (int)jarg2;
30254   if (arg1) (arg1)->right = arg2;
30255 }
30256
30257
30258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
30259   int jresult ;
30260   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30261   int result;
30262
30263   arg1 = (Dali::Rect< int > *)jarg1;
30264   result = (int) ((arg1)->right);
30265   jresult = result;
30266   return jresult;
30267 }
30268
30269
30270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
30271   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30272   int arg2 ;
30273
30274   arg1 = (Dali::Rect< int > *)jarg1;
30275   arg2 = (int)jarg2;
30276   if (arg1) (arg1)->width = arg2;
30277 }
30278
30279
30280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
30281   int jresult ;
30282   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30283   int result;
30284
30285   arg1 = (Dali::Rect< int > *)jarg1;
30286   result = (int) ((arg1)->width);
30287   jresult = result;
30288   return jresult;
30289 }
30290
30291
30292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
30293   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30294   int arg2 ;
30295
30296   arg1 = (Dali::Rect< int > *)jarg1;
30297   arg2 = (int)jarg2;
30298   if (arg1) (arg1)->bottom = arg2;
30299 }
30300
30301
30302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
30303   int jresult ;
30304   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30305   int result;
30306
30307   arg1 = (Dali::Rect< int > *)jarg1;
30308   result = (int) ((arg1)->bottom);
30309   jresult = result;
30310   return jresult;
30311 }
30312
30313
30314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
30315   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30316   int arg2 ;
30317
30318   arg1 = (Dali::Rect< int > *)jarg1;
30319   arg2 = (int)jarg2;
30320   if (arg1) (arg1)->height = arg2;
30321 }
30322
30323
30324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
30325   int jresult ;
30326   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30327   int result;
30328
30329   arg1 = (Dali::Rect< int > *)jarg1;
30330   result = (int) ((arg1)->height);
30331   jresult = result;
30332   return jresult;
30333 }
30334
30335
30336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
30337   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30338   int arg2 ;
30339
30340   arg1 = (Dali::Rect< int > *)jarg1;
30341   arg2 = (int)jarg2;
30342   if (arg1) (arg1)->top = arg2;
30343 }
30344
30345
30346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
30347   int jresult ;
30348   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30349   int result;
30350
30351   arg1 = (Dali::Rect< int > *)jarg1;
30352   result = (int) ((arg1)->top);
30353   jresult = result;
30354   return jresult;
30355 }
30356
30357
30358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
30359   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
30360
30361   arg1 = (Dali::Rect< int > *)jarg1;
30362   {
30363     try {
30364       delete arg1;
30365     } CALL_CATCH_EXCEPTION();
30366   }
30367
30368 }
30369
30370
30371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
30372   void * jresult ;
30373   Dali::Rect< float > *result = 0 ;
30374
30375   {
30376     try {
30377       result = (Dali::Rect< float > *)new Dali::Rect< float >();
30378     } CALL_CATCH_EXCEPTION(0);
30379   }
30380
30381   jresult = (void *)result;
30382   return jresult;
30383 }
30384
30385
30386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
30387   void * jresult ;
30388   float arg1 ;
30389   float arg2 ;
30390   float arg3 ;
30391   float arg4 ;
30392   Dali::Rect< float > *result = 0 ;
30393
30394   arg1 = (float)jarg1;
30395   arg2 = (float)jarg2;
30396   arg3 = (float)jarg4;
30397   arg4 = (float)jarg3;
30398   {
30399     try {
30400       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
30401     } CALL_CATCH_EXCEPTION(0);
30402   }
30403
30404   jresult = (void *)result;
30405   return jresult;
30406 }
30407
30408
30409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
30410   void * jresult ;
30411   Dali::Rect< float > *arg1 = 0 ;
30412   Dali::Rect< float > *result = 0 ;
30413
30414   arg1 = (Dali::Rect< float > *)jarg1;
30415   if (!arg1) {
30416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
30417     return 0;
30418   }
30419   {
30420     try {
30421       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
30422     } CALL_CATCH_EXCEPTION(0);
30423   }
30424
30425   jresult = (void *)result;
30426   return jresult;
30427 }
30428
30429
30430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
30431   void * jresult ;
30432   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30433   Dali::Rect< float > *arg2 = 0 ;
30434   Dali::Rect< float > *result = 0 ;
30435
30436   arg1 = (Dali::Rect< float > *)jarg1;
30437   arg2 = (Dali::Rect< float > *)jarg2;
30438   if (!arg2) {
30439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
30440     return 0;
30441   }
30442   {
30443     try {
30444       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
30445     } CALL_CATCH_EXCEPTION(0);
30446   }
30447
30448   jresult = (void *)result;
30449   return jresult;
30450 }
30451
30452
30453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
30454   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30455   float arg2 ;
30456   float arg3 ;
30457   float arg4 ;
30458   float arg5 ;
30459
30460   arg1 = (Dali::Rect< float > *)jarg1;
30461   arg2 = (float)jarg2;
30462   arg3 = (float)jarg3;
30463   arg4 = (float)jarg5;
30464   arg5 = (float)jarg4;
30465   {
30466     try {
30467       (arg1)->Set(arg2,arg3,arg4,arg5);
30468     } CALL_CATCH_EXCEPTION();
30469   }
30470
30471 }
30472
30473
30474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
30475   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30476   float arg2 ;
30477
30478   arg1 = (Dali::Rect< float > *)jarg1;
30479   arg2 = (float)jarg2;
30480   if (arg1) (arg1)->left = arg2;
30481 }
30482
30483
30484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
30485   float jresult ;
30486   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30487   float result;
30488
30489   arg1 = (Dali::Rect< float > *)jarg1;
30490   result = (float) ((arg1)->left);
30491   jresult = result;
30492   return jresult;
30493 }
30494
30495
30496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
30497   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30498   float arg2 ;
30499
30500   arg1 = (Dali::Rect< float > *)jarg1;
30501   arg2 = (float)jarg2;
30502   if (arg1) (arg1)->left = arg2;
30503 }
30504
30505
30506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
30507   float jresult ;
30508   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30509   float result;
30510
30511   arg1 = (Dali::Rect< float > *)jarg1;
30512   result = (float) ((arg1)->left);
30513   jresult = result;
30514   return jresult;
30515 }
30516
30517
30518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
30519   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30520   float arg2 ;
30521
30522   arg1 = (Dali::Rect< float > *)jarg1;
30523   arg2 = (float)jarg2;
30524   if (arg1) (arg1)->right = arg2;
30525 }
30526
30527
30528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
30529   float jresult ;
30530   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30531   float result;
30532
30533   arg1 = (Dali::Rect< float > *)jarg1;
30534   result = (float) ((arg1)->right);
30535   jresult = result;
30536   return jresult;
30537 }
30538
30539
30540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
30541   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30542   float arg2 ;
30543
30544   arg1 = (Dali::Rect< float > *)jarg1;
30545   arg2 = (float)jarg2;
30546   if (arg1) (arg1)->right = arg2;
30547 }
30548
30549
30550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
30551   float jresult ;
30552   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30553   float result;
30554
30555   arg1 = (Dali::Rect< float > *)jarg1;
30556   result = (float) ((arg1)->right);
30557   jresult = result;
30558   return jresult;
30559 }
30560
30561
30562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
30563   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30564   float arg2 ;
30565
30566   arg1 = (Dali::Rect< float > *)jarg1;
30567   arg2 = (float)jarg2;
30568   if (arg1) (arg1)->bottom = arg2;
30569 }
30570
30571
30572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
30573   float jresult ;
30574   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30575   float result;
30576
30577   arg1 = (Dali::Rect< float > *)jarg1;
30578   result = (float) ((arg1)->bottom);
30579   jresult = result;
30580   return jresult;
30581 }
30582
30583
30584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
30585   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30586   float arg2 ;
30587
30588   arg1 = (Dali::Rect< float > *)jarg1;
30589   arg2 = (float)jarg2;
30590   if (arg1) (arg1)->top = arg2;
30591 }
30592
30593
30594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
30595   float jresult ;
30596   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30597   float result;
30598
30599   arg1 = (Dali::Rect< float > *)jarg1;
30600   result = (float) ((arg1)->top);
30601   jresult = result;
30602   return jresult;
30603 }
30604
30605
30606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
30607   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
30608
30609   arg1 = (Dali::Rect< float > *)jarg1;
30610   {
30611     try {
30612       delete arg1;
30613     } CALL_CATCH_EXCEPTION();
30614   }
30615
30616 }
30617
30618
30619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
30620   int jresult ;
30621   int result;
30622
30623   result = (int)Dali::Vector< int >::BaseType;
30624   jresult = (int)result;
30625   return jresult;
30626 }
30627
30628
30629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
30630   void * jresult ;
30631   Dali::Vector< int > *result = 0 ;
30632
30633   {
30634     try {
30635       result = (Dali::Vector< int > *)new Dali::Vector< int >();
30636     } CALL_CATCH_EXCEPTION(0);
30637   }
30638
30639   jresult = (void *)result;
30640   return jresult;
30641 }
30642
30643
30644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
30645   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30646
30647   arg1 = (Dali::Vector< int > *)jarg1;
30648   {
30649     try {
30650       delete arg1;
30651     } CALL_CATCH_EXCEPTION();
30652   }
30653
30654 }
30655
30656
30657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
30658   void * jresult ;
30659   Dali::Vector< int > *arg1 = 0 ;
30660   Dali::Vector< int > *result = 0 ;
30661
30662   arg1 = (Dali::Vector< int > *)jarg1;
30663   if (!arg1) {
30664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
30665     return 0;
30666   }
30667   {
30668     try {
30669       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
30670     } CALL_CATCH_EXCEPTION(0);
30671   }
30672
30673   jresult = (void *)result;
30674   return jresult;
30675 }
30676
30677
30678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
30679   void * jresult ;
30680   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30681   Dali::Vector< int > *arg2 = 0 ;
30682   Dali::Vector< int > *result = 0 ;
30683
30684   arg1 = (Dali::Vector< int > *)jarg1;
30685   arg2 = (Dali::Vector< int > *)jarg2;
30686   if (!arg2) {
30687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
30688     return 0;
30689   }
30690   {
30691     try {
30692       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
30693     } CALL_CATCH_EXCEPTION(0);
30694   }
30695
30696   jresult = (void *)result;
30697   return jresult;
30698 }
30699
30700
30701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
30702   void * jresult ;
30703   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30704   Dali::Vector< int >::Iterator result;
30705
30706   arg1 = (Dali::Vector< int > *)jarg1;
30707   {
30708     try {
30709       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
30710     } CALL_CATCH_EXCEPTION(0);
30711   }
30712
30713   jresult = (void *)result;
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
30719   void * jresult ;
30720   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30721   Dali::Vector< int >::Iterator result;
30722
30723   arg1 = (Dali::Vector< int > *)jarg1;
30724   {
30725     try {
30726       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
30727     } CALL_CATCH_EXCEPTION(0);
30728   }
30729
30730   jresult = (void *)result;
30731   return jresult;
30732 }
30733
30734
30735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30736   void * jresult ;
30737   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30738   Dali::Vector< int >::SizeType arg2 ;
30739   Dali::Vector< int >::ItemType *result = 0 ;
30740
30741   arg1 = (Dali::Vector< int > *)jarg1;
30742   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30743   {
30744     try {
30745       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
30746     } CALL_CATCH_EXCEPTION(0);
30747   }
30748
30749   jresult = (void *)result;
30750   return jresult;
30751 }
30752
30753
30754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
30755   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30756   Dali::Vector< int >::ItemType *arg2 = 0 ;
30757   Dali::Vector< int >::ItemType temp2 ;
30758
30759   arg1 = (Dali::Vector< int > *)jarg1;
30760   temp2 = (Dali::Vector< int >::ItemType)jarg2;
30761   arg2 = &temp2;
30762   {
30763     try {
30764       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
30765     } CALL_CATCH_EXCEPTION();
30766   }
30767
30768 }
30769
30770
30771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
30772   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30773   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30774   Dali::Vector< int >::ItemType *arg3 = 0 ;
30775   Dali::Vector< int >::ItemType temp3 ;
30776
30777   arg1 = (Dali::Vector< int > *)jarg1;
30778   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30779   temp3 = (Dali::Vector< int >::ItemType)jarg3;
30780   arg3 = &temp3;
30781   {
30782     try {
30783       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
30784     } CALL_CATCH_EXCEPTION();
30785   }
30786
30787 }
30788
30789
30790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30791   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30792   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30793   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30794   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
30795
30796   arg1 = (Dali::Vector< int > *)jarg1;
30797   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30798   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30799   arg4 = (Dali::Vector< int >::Iterator)jarg4;
30800   {
30801     try {
30802       (arg1)->Insert(arg2,arg3,arg4);
30803     } CALL_CATCH_EXCEPTION();
30804   }
30805
30806 }
30807
30808
30809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
30810   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30811   Dali::Vector< int >::SizeType arg2 ;
30812
30813   arg1 = (Dali::Vector< int > *)jarg1;
30814   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30815   {
30816     try {
30817       (arg1)->Reserve(arg2);
30818     } CALL_CATCH_EXCEPTION();
30819   }
30820
30821 }
30822
30823
30824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30825   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30826   Dali::Vector< int >::SizeType arg2 ;
30827
30828   arg1 = (Dali::Vector< int > *)jarg1;
30829   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30830   {
30831     try {
30832       (arg1)->Resize(arg2);
30833     } CALL_CATCH_EXCEPTION();
30834   }
30835
30836 }
30837
30838
30839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
30840   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30841   Dali::Vector< int >::SizeType arg2 ;
30842   Dali::Vector< int >::ItemType *arg3 = 0 ;
30843   Dali::Vector< int >::ItemType temp3 ;
30844
30845   arg1 = (Dali::Vector< int > *)jarg1;
30846   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30847   temp3 = (Dali::Vector< int >::ItemType)jarg3;
30848   arg3 = &temp3;
30849   {
30850     try {
30851       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
30852     } CALL_CATCH_EXCEPTION();
30853   }
30854
30855 }
30856
30857
30858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
30859   void * jresult ;
30860   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30861   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30862   Dali::Vector< int >::Iterator result;
30863
30864   arg1 = (Dali::Vector< int > *)jarg1;
30865   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30866   {
30867     try {
30868       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
30869     } CALL_CATCH_EXCEPTION(0);
30870   }
30871
30872   jresult = (void *)result;
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30878   void * jresult ;
30879   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30880   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30881   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30882   Dali::Vector< int >::Iterator result;
30883
30884   arg1 = (Dali::Vector< int > *)jarg1;
30885   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30886   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30887   {
30888     try {
30889       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
30890     } CALL_CATCH_EXCEPTION(0);
30891   }
30892
30893   jresult = (void *)result;
30894   return jresult;
30895 }
30896
30897
30898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
30899   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30900   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30901
30902   arg1 = (Dali::Vector< int > *)jarg1;
30903   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30904   {
30905     try {
30906       (arg1)->Remove(arg2);
30907     } CALL_CATCH_EXCEPTION();
30908   }
30909
30910 }
30911
30912
30913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
30914   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30915   Dali::Vector< int > *arg2 = 0 ;
30916
30917   arg1 = (Dali::Vector< int > *)jarg1;
30918   arg2 = (Dali::Vector< int > *)jarg2;
30919   if (!arg2) {
30920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
30921     return ;
30922   }
30923   {
30924     try {
30925       (arg1)->Swap(*arg2);
30926     } CALL_CATCH_EXCEPTION();
30927   }
30928
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30933   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30934
30935   arg1 = (Dali::Vector< int > *)jarg1;
30936   {
30937     try {
30938       (arg1)->Clear();
30939     } CALL_CATCH_EXCEPTION();
30940   }
30941
30942 }
30943
30944
30945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30946   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30947
30948   arg1 = (Dali::Vector< int > *)jarg1;
30949   {
30950     try {
30951       (arg1)->Release();
30952     } CALL_CATCH_EXCEPTION();
30953   }
30954
30955 }
30956
30957
30958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30959   int jresult ;
30960   int result;
30961
30962   result = (int)Dali::Vector< float >::BaseType;
30963   jresult = (int)result;
30964   return jresult;
30965 }
30966
30967
30968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30969   void * jresult ;
30970   Dali::Vector< float > *result = 0 ;
30971
30972   {
30973     try {
30974       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30975     } CALL_CATCH_EXCEPTION(0);
30976   }
30977
30978   jresult = (void *)result;
30979   return jresult;
30980 }
30981
30982
30983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30984   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30985
30986   arg1 = (Dali::Vector< float > *)jarg1;
30987   {
30988     try {
30989       delete arg1;
30990     } CALL_CATCH_EXCEPTION();
30991   }
30992
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30997   void * jresult ;
30998   Dali::Vector< float > *arg1 = 0 ;
30999   Dali::Vector< float > *result = 0 ;
31000
31001   arg1 = (Dali::Vector< float > *)jarg1;
31002   if (!arg1) {
31003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31004     return 0;
31005   }
31006   {
31007     try {
31008       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
31009     } CALL_CATCH_EXCEPTION(0);
31010   }
31011
31012   jresult = (void *)result;
31013   return jresult;
31014 }
31015
31016
31017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
31018   void * jresult ;
31019   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31020   Dali::Vector< float > *arg2 = 0 ;
31021   Dali::Vector< float > *result = 0 ;
31022
31023   arg1 = (Dali::Vector< float > *)jarg1;
31024   arg2 = (Dali::Vector< float > *)jarg2;
31025   if (!arg2) {
31026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
31027     return 0;
31028   }
31029   {
31030     try {
31031       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
31032     } CALL_CATCH_EXCEPTION(0);
31033   }
31034
31035   jresult = (void *)result;
31036   return jresult;
31037 }
31038
31039
31040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
31041   void * jresult ;
31042   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31043   Dali::Vector< float >::Iterator result;
31044
31045   arg1 = (Dali::Vector< float > *)jarg1;
31046   {
31047     try {
31048       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
31049     } CALL_CATCH_EXCEPTION(0);
31050   }
31051
31052   jresult = (void *)result;
31053   return jresult;
31054 }
31055
31056
31057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
31058   void * jresult ;
31059   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31060   Dali::Vector< float >::Iterator result;
31061
31062   arg1 = (Dali::Vector< float > *)jarg1;
31063   {
31064     try {
31065       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
31066     } CALL_CATCH_EXCEPTION(0);
31067   }
31068
31069   jresult = (void *)result;
31070   return jresult;
31071 }
31072
31073
31074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31075   void * jresult ;
31076   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31077   Dali::Vector< float >::SizeType arg2 ;
31078   Dali::Vector< float >::ItemType *result = 0 ;
31079
31080   arg1 = (Dali::Vector< float > *)jarg1;
31081   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31082   {
31083     try {
31084       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
31085     } CALL_CATCH_EXCEPTION(0);
31086   }
31087
31088   jresult = (void *)result;
31089   return jresult;
31090 }
31091
31092
31093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
31094   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31095   Dali::Vector< float >::ItemType *arg2 = 0 ;
31096   Dali::Vector< float >::ItemType temp2 ;
31097
31098   arg1 = (Dali::Vector< float > *)jarg1;
31099   temp2 = (Dali::Vector< float >::ItemType)jarg2;
31100   arg2 = &temp2;
31101   {
31102     try {
31103       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
31104     } CALL_CATCH_EXCEPTION();
31105   }
31106
31107 }
31108
31109
31110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
31111   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31112   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31113   Dali::Vector< float >::ItemType *arg3 = 0 ;
31114   Dali::Vector< float >::ItemType temp3 ;
31115
31116   arg1 = (Dali::Vector< float > *)jarg1;
31117   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31118   temp3 = (Dali::Vector< float >::ItemType)jarg3;
31119   arg3 = &temp3;
31120   {
31121     try {
31122       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
31123     } CALL_CATCH_EXCEPTION();
31124   }
31125
31126 }
31127
31128
31129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31130   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31131   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31132   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
31133   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
31134
31135   arg1 = (Dali::Vector< float > *)jarg1;
31136   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31137   arg3 = (Dali::Vector< float >::Iterator)jarg3;
31138   arg4 = (Dali::Vector< float >::Iterator)jarg4;
31139   {
31140     try {
31141       (arg1)->Insert(arg2,arg3,arg4);
31142     } CALL_CATCH_EXCEPTION();
31143   }
31144
31145 }
31146
31147
31148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
31149   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31150   Dali::Vector< float >::SizeType arg2 ;
31151
31152   arg1 = (Dali::Vector< float > *)jarg1;
31153   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31154   {
31155     try {
31156       (arg1)->Reserve(arg2);
31157     } CALL_CATCH_EXCEPTION();
31158   }
31159
31160 }
31161
31162 //// ========================= end of part 2 =============================
31163
31164 //// ========================== start part 3 ===============================
31165
31166
31167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31168   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31169   Dali::Vector< float >::SizeType arg2 ;
31170
31171   arg1 = (Dali::Vector< float > *)jarg1;
31172   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31173   {
31174     try {
31175       (arg1)->Resize(arg2);
31176     } CALL_CATCH_EXCEPTION();
31177   }
31178
31179 }
31180
31181
31182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
31183   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31184   Dali::Vector< float >::SizeType arg2 ;
31185   Dali::Vector< float >::ItemType *arg3 = 0 ;
31186   Dali::Vector< float >::ItemType temp3 ;
31187
31188   arg1 = (Dali::Vector< float > *)jarg1;
31189   arg2 = (Dali::Vector< float >::SizeType)jarg2;
31190   temp3 = (Dali::Vector< float >::ItemType)jarg3;
31191   arg3 = &temp3;
31192   {
31193     try {
31194       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
31195     } CALL_CATCH_EXCEPTION();
31196   }
31197
31198 }
31199
31200
31201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
31202   void * jresult ;
31203   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31204   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31205   Dali::Vector< float >::Iterator result;
31206
31207   arg1 = (Dali::Vector< float > *)jarg1;
31208   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31209   {
31210     try {
31211       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
31212     } CALL_CATCH_EXCEPTION(0);
31213   }
31214
31215   jresult = (void *)result;
31216   return jresult;
31217 }
31218
31219
31220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31221   void * jresult ;
31222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31223   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31224   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
31225   Dali::Vector< float >::Iterator result;
31226
31227   arg1 = (Dali::Vector< float > *)jarg1;
31228   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31229   arg3 = (Dali::Vector< float >::Iterator)jarg3;
31230   {
31231     try {
31232       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
31233     } CALL_CATCH_EXCEPTION(0);
31234   }
31235
31236   jresult = (void *)result;
31237   return jresult;
31238 }
31239
31240
31241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
31242   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31243   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
31244
31245   arg1 = (Dali::Vector< float > *)jarg1;
31246   arg2 = (Dali::Vector< float >::Iterator)jarg2;
31247   {
31248     try {
31249       (arg1)->Remove(arg2);
31250     } CALL_CATCH_EXCEPTION();
31251   }
31252
31253 }
31254
31255
31256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
31257   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31258   Dali::Vector< float > *arg2 = 0 ;
31259
31260   arg1 = (Dali::Vector< float > *)jarg1;
31261   arg2 = (Dali::Vector< float > *)jarg2;
31262   if (!arg2) {
31263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
31264     return ;
31265   }
31266   {
31267     try {
31268       (arg1)->Swap(*arg2);
31269     } CALL_CATCH_EXCEPTION();
31270   }
31271
31272 }
31273
31274
31275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
31276   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31277
31278   arg1 = (Dali::Vector< float > *)jarg1;
31279   {
31280     try {
31281       (arg1)->Clear();
31282     } CALL_CATCH_EXCEPTION();
31283   }
31284
31285 }
31286
31287
31288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
31289   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
31290
31291   arg1 = (Dali::Vector< float > *)jarg1;
31292   {
31293     try {
31294       (arg1)->Release();
31295     } CALL_CATCH_EXCEPTION();
31296   }
31297
31298 }
31299
31300
31301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
31302   int jresult ;
31303   int result;
31304
31305   result = (int)Dali::Vector< unsigned char >::BaseType;
31306   jresult = (int)result;
31307   return jresult;
31308 }
31309
31310
31311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
31312   void * jresult ;
31313   Dali::Vector< unsigned char > *result = 0 ;
31314
31315   {
31316     try {
31317       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
31318     } CALL_CATCH_EXCEPTION(0);
31319   }
31320
31321   jresult = (void *)result;
31322   return jresult;
31323 }
31324
31325
31326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
31327   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31328
31329   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31330   {
31331     try {
31332       delete arg1;
31333     } CALL_CATCH_EXCEPTION();
31334   }
31335
31336 }
31337
31338
31339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
31340   void * jresult ;
31341   Dali::Vector< unsigned char > *arg1 = 0 ;
31342   Dali::Vector< unsigned char > *result = 0 ;
31343
31344   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31345   if (!arg1) {
31346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
31347     return 0;
31348   }
31349   {
31350     try {
31351       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
31352     } CALL_CATCH_EXCEPTION(0);
31353   }
31354
31355   jresult = (void *)result;
31356   return jresult;
31357 }
31358
31359
31360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
31361   void * jresult ;
31362   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31363   Dali::Vector< unsigned char > *arg2 = 0 ;
31364   Dali::Vector< unsigned char > *result = 0 ;
31365
31366   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31367   arg2 = (Dali::Vector< unsigned char > *)jarg2;
31368   if (!arg2) {
31369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
31370     return 0;
31371   }
31372   {
31373     try {
31374       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
31375     } CALL_CATCH_EXCEPTION(0);
31376   }
31377
31378   jresult = (void *)result;
31379   return jresult;
31380 }
31381
31382
31383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
31384   void * jresult ;
31385   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31386   Dali::Vector< unsigned char >::Iterator result;
31387
31388   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31389   {
31390     try {
31391       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
31392     } CALL_CATCH_EXCEPTION(0);
31393   }
31394
31395   jresult = (void *)result;
31396   return jresult;
31397 }
31398
31399
31400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
31401   void * jresult ;
31402   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31403   Dali::Vector< unsigned char >::Iterator result;
31404
31405   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31406   {
31407     try {
31408       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
31409     } CALL_CATCH_EXCEPTION(0);
31410   }
31411
31412   jresult = (void *)result;
31413   return jresult;
31414 }
31415
31416
31417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31418   void * jresult ;
31419   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31420   Dali::Vector< unsigned char >::SizeType arg2 ;
31421   Dali::Vector< unsigned char >::ItemType *result = 0 ;
31422
31423   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31424   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
31425   {
31426     try {
31427       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
31428     } CALL_CATCH_EXCEPTION(0);
31429   }
31430
31431   jresult = (void *)result;
31432   return jresult;
31433 }
31434
31435
31436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
31437   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31438   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
31439   Dali::Vector< unsigned char >::ItemType temp2 ;
31440
31441   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31442   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
31443   arg2 = &temp2;
31444   {
31445     try {
31446       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
31447     } CALL_CATCH_EXCEPTION();
31448   }
31449
31450 }
31451
31452
31453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
31454   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31455   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31456   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
31457   Dali::Vector< unsigned char >::ItemType temp3 ;
31458
31459   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31460   arg2 = jarg2;
31461   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
31462   arg3 = &temp3;
31463   {
31464     try {
31465       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
31466     } CALL_CATCH_EXCEPTION();
31467   }
31468
31469
31470
31471 }
31472
31473
31474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
31475   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31476   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31477   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31478   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31479
31480   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31481   arg2 = jarg2;
31482   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
31483   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
31484   {
31485     try {
31486       (arg1)->Insert(arg2,arg3,arg4);
31487     } CALL_CATCH_EXCEPTION();
31488   }
31489
31490
31491
31492 }
31493
31494
31495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
31496   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31497   Dali::Vector< unsigned char >::SizeType arg2 ;
31498
31499   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31500   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
31501   {
31502     try {
31503       (arg1)->Reserve(arg2);
31504     } CALL_CATCH_EXCEPTION();
31505   }
31506
31507 }
31508
31509
31510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31511   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31512   Dali::Vector< unsigned char >::SizeType arg2 ;
31513
31514   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31515   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
31516   {
31517     try {
31518       (arg1)->Resize(arg2);
31519     } CALL_CATCH_EXCEPTION();
31520   }
31521
31522 }
31523
31524
31525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
31526   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31527   Dali::Vector< unsigned char >::SizeType arg2 ;
31528   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
31529   Dali::Vector< unsigned char >::ItemType temp3 ;
31530
31531   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31532   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
31533   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
31534   arg3 = &temp3;
31535   {
31536     try {
31537       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
31538     } CALL_CATCH_EXCEPTION();
31539   }
31540
31541 }
31542
31543
31544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
31545   void * jresult ;
31546   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31547   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31548   Dali::Vector< unsigned char >::Iterator result;
31549
31550   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31551   arg2 = jarg2;
31552   {
31553     try {
31554       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
31555     } CALL_CATCH_EXCEPTION(0);
31556   }
31557
31558   jresult = (void *)result;
31559
31560
31561   return jresult;
31562 }
31563
31564
31565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
31566   void * jresult ;
31567   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31568   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31569   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31570   Dali::Vector< unsigned char >::Iterator result;
31571
31572   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31573   arg2 = jarg2;
31574   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
31575   {
31576     try {
31577       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
31578     } CALL_CATCH_EXCEPTION(0);
31579   }
31580
31581   jresult = (void *)result;
31582
31583
31584   return jresult;
31585 }
31586
31587
31588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
31589   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31590   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
31591
31592   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31593   arg2 = jarg2;
31594   {
31595     try {
31596       (arg1)->Remove(arg2);
31597     } CALL_CATCH_EXCEPTION();
31598   }
31599
31600
31601
31602 }
31603
31604
31605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
31606   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31607   Dali::Vector< unsigned char > *arg2 = 0 ;
31608
31609   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31610   arg2 = (Dali::Vector< unsigned char > *)jarg2;
31611   if (!arg2) {
31612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
31613     return ;
31614   }
31615   {
31616     try {
31617       (arg1)->Swap(*arg2);
31618     } CALL_CATCH_EXCEPTION();
31619   }
31620
31621 }
31622
31623
31624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
31625   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31626
31627   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31628   {
31629     try {
31630       (arg1)->Clear();
31631     } CALL_CATCH_EXCEPTION();
31632   }
31633
31634 }
31635
31636
31637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
31638   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
31639
31640   arg1 = (Dali::Vector< unsigned char > *)jarg1;
31641   {
31642     try {
31643       (arg1)->Release();
31644     } CALL_CATCH_EXCEPTION();
31645   }
31646
31647 }
31648
31649
31650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
31651   int jresult ;
31652   int result;
31653
31654   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
31655   jresult = (int)result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
31661   void * jresult ;
31662   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
31663
31664   {
31665     try {
31666       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
31667     } CALL_CATCH_EXCEPTION(0);
31668   }
31669
31670   jresult = (void *)result;
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
31676   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31677
31678   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31679   {
31680     try {
31681       delete arg1;
31682     } CALL_CATCH_EXCEPTION();
31683   }
31684
31685 }
31686
31687
31688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
31689   void * jresult ;
31690   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
31691   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
31692
31693   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31694   if (!arg1) {
31695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
31696     return 0;
31697   }
31698   {
31699     try {
31700       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
31701     } CALL_CATCH_EXCEPTION(0);
31702   }
31703
31704   jresult = (void *)result;
31705   return jresult;
31706 }
31707
31708
31709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
31710   void * jresult ;
31711   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31712   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31713   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
31714
31715   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31716   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31717   if (!arg2) {
31718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
31719     return 0;
31720   }
31721   {
31722     try {
31723       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
31724     } CALL_CATCH_EXCEPTION(0);
31725   }
31726
31727   jresult = (void *)result;
31728   return jresult;
31729 }
31730
31731
31732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
31733   void * jresult ;
31734   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31735   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31736
31737   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31738   {
31739     try {
31740       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
31741     } CALL_CATCH_EXCEPTION(0);
31742   }
31743
31744   jresult = (void *)result;
31745   return jresult;
31746 }
31747
31748
31749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
31750   void * jresult ;
31751   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31752   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31753
31754   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31755   {
31756     try {
31757       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
31758     } CALL_CATCH_EXCEPTION(0);
31759   }
31760
31761   jresult = (void *)result;
31762   return jresult;
31763 }
31764
31765
31766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
31767   void * jresult ;
31768   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31769   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31770   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
31771
31772   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31773   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31774   {
31775     try {
31776       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
31777     } CALL_CATCH_EXCEPTION(0);
31778   }
31779
31780   jresult = (void *)result;
31781   return jresult;
31782 }
31783
31784
31785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
31786   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31787   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
31788
31789   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31790   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
31791   if (!arg2) {
31792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31793     return ;
31794   }
31795   {
31796     try {
31797       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
31798     } CALL_CATCH_EXCEPTION();
31799   }
31800
31801 }
31802
31803
31804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
31805   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31806   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31807   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31808
31809   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31810   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31811   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31812   if (!arg3) {
31813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31814     return ;
31815   }
31816   {
31817     try {
31818       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31819     } CALL_CATCH_EXCEPTION();
31820   }
31821
31822 }
31823
31824
31825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31826   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31827   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31828   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31829   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31830
31831   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31832   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31833   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31834   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
31835   {
31836     try {
31837       (arg1)->Insert(arg2,arg3,arg4);
31838     } CALL_CATCH_EXCEPTION();
31839   }
31840
31841 }
31842
31843
31844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
31845   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31846   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31847
31848   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31849   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31850   {
31851     try {
31852       (arg1)->Reserve(arg2);
31853     } CALL_CATCH_EXCEPTION();
31854   }
31855
31856 }
31857
31858
31859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31860   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31861   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31862
31863   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31864   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31865   {
31866     try {
31867       (arg1)->Resize(arg2);
31868     } CALL_CATCH_EXCEPTION();
31869   }
31870
31871 }
31872
31873
31874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
31875   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31876   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31877   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31878
31879   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31880   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31881   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31882   if (!arg3) {
31883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31884     return ;
31885   }
31886   {
31887     try {
31888       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31889     } CALL_CATCH_EXCEPTION();
31890   }
31891
31892 }
31893
31894
31895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
31896   void * jresult ;
31897   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31898   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31899   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31900
31901   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31902   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31903   {
31904     try {
31905       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
31906     } CALL_CATCH_EXCEPTION(0);
31907   }
31908
31909   jresult = (void *)result;
31910   return jresult;
31911 }
31912
31913
31914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31915   void * jresult ;
31916   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31917   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31918   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31919   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31920
31921   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31922   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31923   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31924   {
31925     try {
31926       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
31927     } CALL_CATCH_EXCEPTION(0);
31928   }
31929
31930   jresult = (void *)result;
31931   return jresult;
31932 }
31933
31934
31935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31936   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31937   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31938
31939   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31940   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31941   {
31942     try {
31943       (arg1)->Remove(arg2);
31944     } CALL_CATCH_EXCEPTION();
31945   }
31946
31947 }
31948
31949
31950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31951   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31952   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31953
31954   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31955   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31956   if (!arg2) {
31957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31958     return ;
31959   }
31960   {
31961     try {
31962       (arg1)->Swap(*arg2);
31963     } CALL_CATCH_EXCEPTION();
31964   }
31965
31966 }
31967
31968
31969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31970   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31971
31972   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31973   {
31974     try {
31975       (arg1)->Clear();
31976     } CALL_CATCH_EXCEPTION();
31977   }
31978
31979 }
31980
31981
31982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31983   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31984
31985   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31986   {
31987     try {
31988       (arg1)->Release();
31989     } CALL_CATCH_EXCEPTION();
31990   }
31991
31992 }
31993
31994
31995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31996   void * jresult ;
31997   Dali::Signal< void () > *result = 0 ;
31998
31999   {
32000     try {
32001       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
32002     } CALL_CATCH_EXCEPTION(0);
32003   }
32004
32005   jresult = (void *)result;
32006   return jresult;
32007 }
32008
32009
32010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
32011   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32012
32013   arg1 = (Dali::Signal< void () > *)jarg1;
32014   {
32015     try {
32016       delete arg1;
32017     } CALL_CATCH_EXCEPTION();
32018   }
32019
32020 }
32021
32022
32023 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
32024   bool jresult ;
32025   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32026   bool result;
32027
32028   arg1 = (Dali::Signal< void () > *)jarg1;
32029   {
32030     try {
32031       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
32032     } CALL_CATCH_EXCEPTION(0);
32033   }
32034
32035   jresult = result;
32036   return jresult;
32037 }
32038
32039
32040 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
32041   unsigned long jresult ;
32042   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32043   std::size_t result;
32044
32045   arg1 = (Dali::Signal< void () > *)jarg1;
32046   {
32047     try {
32048       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
32049     } CALL_CATCH_EXCEPTION(0);
32050   }
32051
32052   jresult = (unsigned long)result;
32053   return jresult;
32054 }
32055
32056
32057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
32058   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32059   void (*arg2)() = (void (*)()) 0 ;
32060
32061   arg1 = (Dali::Signal< void () > *)jarg1;
32062   arg2 = (void (*)())jarg2;
32063   {
32064     try {
32065       (arg1)->Connect(arg2);
32066     } CALL_CATCH_EXCEPTION();
32067   }
32068
32069 }
32070
32071
32072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
32073   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32074   void (*arg2)() = (void (*)()) 0 ;
32075
32076   arg1 = (Dali::Signal< void () > *)jarg1;
32077   arg2 = (void (*)())jarg2;
32078   {
32079     try {
32080       (arg1)->Disconnect(arg2);
32081     } CALL_CATCH_EXCEPTION();
32082   }
32083
32084 }
32085
32086
32087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
32088   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32089   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
32090   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
32091
32092   arg1 = (Dali::Signal< void () > *)jarg1;
32093   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
32094   arg3 = (Dali::FunctorDelegate *)jarg3;
32095   {
32096     try {
32097       (arg1)->Connect(arg2,arg3);
32098     } CALL_CATCH_EXCEPTION();
32099   }
32100
32101 }
32102
32103
32104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
32105   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
32106
32107   arg1 = (Dali::Signal< void () > *)jarg1;
32108   {
32109     try {
32110       (arg1)->Emit();
32111     } CALL_CATCH_EXCEPTION();
32112   }
32113
32114 }
32115
32116
32117 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
32118   bool jresult ;
32119   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32120   bool result;
32121
32122   arg1 = (Dali::Signal< void (float) > *)jarg1;
32123   {
32124     try {
32125       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
32126     } CALL_CATCH_EXCEPTION(0);
32127   }
32128
32129   jresult = result;
32130   return jresult;
32131 }
32132
32133
32134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
32135   unsigned long jresult ;
32136   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32137   std::size_t result;
32138
32139   arg1 = (Dali::Signal< void (float) > *)jarg1;
32140   {
32141     try {
32142       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
32143     } CALL_CATCH_EXCEPTION(0);
32144   }
32145
32146   jresult = (unsigned long)result;
32147   return jresult;
32148 }
32149
32150
32151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
32152   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32153   void (*arg2)(float) = (void (*)(float)) 0 ;
32154
32155   arg1 = (Dali::Signal< void (float) > *)jarg1;
32156   arg2 = (void (*)(float))jarg2;
32157   {
32158     try {
32159       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
32160     } CALL_CATCH_EXCEPTION();
32161   }
32162
32163 }
32164
32165
32166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
32167   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32168   void (*arg2)(float) = (void (*)(float)) 0 ;
32169
32170   arg1 = (Dali::Signal< void (float) > *)jarg1;
32171   arg2 = (void (*)(float))jarg2;
32172   {
32173     try {
32174       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
32175     } CALL_CATCH_EXCEPTION();
32176   }
32177
32178 }
32179
32180
32181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
32182   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32183   float arg2 ;
32184
32185   arg1 = (Dali::Signal< void (float) > *)jarg1;
32186   arg2 = (float)jarg2;
32187   {
32188     try {
32189       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
32190     } CALL_CATCH_EXCEPTION();
32191   }
32192
32193 }
32194
32195
32196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
32197   void * jresult ;
32198   Dali::Signal< void (float) > *result = 0 ;
32199
32200   {
32201     try {
32202       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
32203     } CALL_CATCH_EXCEPTION(0);
32204   }
32205
32206   jresult = (void *)result;
32207   return jresult;
32208 }
32209
32210
32211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
32212   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
32213
32214   arg1 = (Dali::Signal< void (float) > *)jarg1;
32215   {
32216     try {
32217       delete arg1;
32218     } CALL_CATCH_EXCEPTION();
32219   }
32220
32221 }
32222
32223
32224 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
32225   bool jresult ;
32226   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32227   bool result;
32228
32229   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32230   {
32231     try {
32232       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
32233     } CALL_CATCH_EXCEPTION(0);
32234   }
32235
32236   jresult = result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
32242   unsigned long jresult ;
32243   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32244   std::size_t result;
32245
32246   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32247   {
32248     try {
32249       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
32250     } CALL_CATCH_EXCEPTION(0);
32251   }
32252
32253   jresult = (unsigned long)result;
32254   return jresult;
32255 }
32256
32257
32258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
32259   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32260   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
32261
32262   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32263   arg2 = (void (*)(Dali::BaseHandle))jarg2;
32264   {
32265     try {
32266       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
32267     } CALL_CATCH_EXCEPTION();
32268   }
32269
32270 }
32271
32272
32273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
32274   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32275   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
32276
32277   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32278   arg2 = (void (*)(Dali::BaseHandle))jarg2;
32279   {
32280     try {
32281       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
32282     } CALL_CATCH_EXCEPTION();
32283   }
32284
32285 }
32286
32287
32288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
32289   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32290   Dali::BaseHandle arg2 ;
32291   Dali::BaseHandle *argp2 ;
32292
32293   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32294   argp2 = (Dali::BaseHandle *)jarg2;
32295   if (!argp2) {
32296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32297     return ;
32298   }
32299   arg2 = *argp2;
32300   {
32301     try {
32302       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
32303     } CALL_CATCH_EXCEPTION();
32304   }
32305
32306 }
32307
32308
32309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
32310   void * jresult ;
32311   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
32312
32313   {
32314     try {
32315       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
32316     } CALL_CATCH_EXCEPTION(0);
32317   }
32318
32319   jresult = (void *)result;
32320   return jresult;
32321 }
32322
32323
32324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
32325   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
32326
32327   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
32328   {
32329     try {
32330       delete arg1;
32331     } CALL_CATCH_EXCEPTION();
32332   }
32333
32334 }
32335
32336
32337 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
32338   bool jresult ;
32339   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32340   bool result;
32341
32342   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32343   {
32344     try {
32345       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
32346     } CALL_CATCH_EXCEPTION(0);
32347   }
32348
32349   jresult = result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
32355   unsigned long jresult ;
32356   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32357   std::size_t result;
32358
32359   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32360   {
32361     try {
32362       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
32363     } CALL_CATCH_EXCEPTION(0);
32364   }
32365
32366   jresult = (unsigned long)result;
32367   return jresult;
32368 }
32369
32370
32371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
32372   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32373   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
32374
32375   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32376   arg2 = (void (*)(Dali::RefObject const *))jarg2;
32377   {
32378     try {
32379       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
32380     } CALL_CATCH_EXCEPTION();
32381   }
32382
32383 }
32384
32385
32386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
32387   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32388   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
32389
32390   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32391   arg2 = (void (*)(Dali::RefObject const *))jarg2;
32392   {
32393     try {
32394       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
32395     } CALL_CATCH_EXCEPTION();
32396   }
32397
32398 }
32399
32400
32401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
32402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32403   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
32404
32405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32406   arg2 = (Dali::RefObject *)jarg2;
32407   {
32408     try {
32409       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
32410     } CALL_CATCH_EXCEPTION();
32411   }
32412
32413 }
32414
32415
32416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
32417   void * jresult ;
32418   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
32419
32420   {
32421     try {
32422       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
32423     } CALL_CATCH_EXCEPTION(0);
32424   }
32425
32426   jresult = (void *)result;
32427   return jresult;
32428 }
32429
32430
32431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
32432   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
32433
32434   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
32435   {
32436     try {
32437       delete arg1;
32438     } CALL_CATCH_EXCEPTION();
32439   }
32440
32441 }
32442
32443
32444 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
32445   bool jresult ;
32446   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32447   bool result;
32448
32449   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32450   {
32451     try {
32452       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
32453     } CALL_CATCH_EXCEPTION(0);
32454   }
32455
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
32462   unsigned long jresult ;
32463   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32464   std::size_t result;
32465
32466   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32467   {
32468     try {
32469       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
32470     } CALL_CATCH_EXCEPTION(0);
32471   }
32472
32473   jresult = (unsigned long)result;
32474   return jresult;
32475 }
32476
32477
32478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
32479   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32480   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
32481
32482   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32483   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
32484   {
32485     try {
32486       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
32487     } CALL_CATCH_EXCEPTION();
32488   }
32489
32490 }
32491
32492
32493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
32494   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32495   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
32496
32497   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32498   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
32499   {
32500     try {
32501       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
32502     } CALL_CATCH_EXCEPTION();
32503   }
32504
32505 }
32506
32507
32508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
32509   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32510   Dali::PropertyNotification *arg2 = 0 ;
32511
32512   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32513   arg2 = (Dali::PropertyNotification *)jarg2;
32514   if (!arg2) {
32515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
32516     return ;
32517   }
32518   {
32519     try {
32520       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
32521     } CALL_CATCH_EXCEPTION();
32522   }
32523
32524 }
32525
32526
32527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
32528   void * jresult ;
32529   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
32530
32531   {
32532     try {
32533       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
32534     } CALL_CATCH_EXCEPTION(0);
32535   }
32536
32537   jresult = (void *)result;
32538   return jresult;
32539 }
32540
32541
32542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
32543   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
32544
32545   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
32546   {
32547     try {
32548       delete arg1;
32549     } CALL_CATCH_EXCEPTION();
32550   }
32551
32552 }
32553
32554
32555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
32556   void * jresult ;
32557   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
32558
32559   {
32560     try {
32561       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
32562     } CALL_CATCH_EXCEPTION(0);
32563   }
32564
32565   jresult = (void *)result;
32566   return jresult;
32567 }
32568
32569
32570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
32571   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
32572
32573   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
32574   {
32575     try {
32576       delete arg1;
32577     } CALL_CATCH_EXCEPTION();
32578   }
32579
32580 }
32581
32582
32583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
32584   bool jresult ;
32585   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32586   bool result;
32587
32588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32589   {
32590     try {
32591       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
32592     } CALL_CATCH_EXCEPTION(0);
32593   }
32594
32595   jresult = result;
32596   return jresult;
32597 }
32598
32599
32600 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32601   unsigned long jresult ;
32602   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32603   std::size_t result;
32604
32605   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32606   {
32607     try {
32608       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
32609     } CALL_CATCH_EXCEPTION(0);
32610   }
32611
32612   jresult = (unsigned long)result;
32613   return jresult;
32614 }
32615
32616
32617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32618   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32619   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
32620
32621   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32622   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
32623   {
32624     try {
32625       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32626     } CALL_CATCH_EXCEPTION();
32627   }
32628
32629 }
32630
32631
32632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32633   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32634   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
32635
32636   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32637   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
32638   {
32639     try {
32640       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32641     } CALL_CATCH_EXCEPTION();
32642   }
32643
32644 }
32645
32646
32647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32648   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32649   Dali::Actor arg2 ;
32650   Dali::LongPressGesture *arg3 = 0 ;
32651   Dali::Actor *argp2 ;
32652
32653   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32654   argp2 = (Dali::Actor *)jarg2;
32655   if (!argp2) {
32656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32657     return ;
32658   }
32659   arg2 = *argp2;
32660   arg3 = (Dali::LongPressGesture *)jarg3;
32661   if (!arg3) {
32662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32663     return ;
32664   }
32665   {
32666     try {
32667       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
32668     } CALL_CATCH_EXCEPTION();
32669   }
32670
32671 }
32672
32673
32674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
32675   void * jresult ;
32676   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
32677
32678   {
32679     try {
32680       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
32681     } CALL_CATCH_EXCEPTION(0);
32682   }
32683
32684   jresult = (void *)result;
32685   return jresult;
32686 }
32687
32688
32689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
32690   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
32691
32692   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
32693   {
32694     try {
32695       delete arg1;
32696     } CALL_CATCH_EXCEPTION();
32697   }
32698
32699 }
32700
32701
32702 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
32703   bool jresult ;
32704   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32705   bool result;
32706
32707   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32708   {
32709     try {
32710       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
32711     } CALL_CATCH_EXCEPTION(0);
32712   }
32713
32714   jresult = result;
32715   return jresult;
32716 }
32717
32718
32719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
32720   unsigned long jresult ;
32721   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32722   std::size_t result;
32723
32724   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32725   {
32726     try {
32727       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
32728     } CALL_CATCH_EXCEPTION(0);
32729   }
32730
32731   jresult = (unsigned long)result;
32732   return jresult;
32733 }
32734
32735
32736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
32737   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32738   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
32739
32740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32741   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
32742   {
32743     try {
32744       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32745     } CALL_CATCH_EXCEPTION();
32746   }
32747
32748 }
32749
32750
32751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
32752   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32753   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
32754
32755   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32756   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
32757   {
32758     try {
32759       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32760     } CALL_CATCH_EXCEPTION();
32761   }
32762
32763 }
32764
32765
32766 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32767   bool jresult ;
32768   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32769   Dali::Actor arg2 ;
32770   Dali::TouchEvent *arg3 = 0 ;
32771   Dali::Actor *argp2 ;
32772   bool result;
32773
32774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32775   argp2 = (Dali::Actor *)jarg2;
32776   if (!argp2) {
32777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32778     return 0;
32779   }
32780   arg2 = *argp2;
32781   arg3 = (Dali::TouchEvent *)jarg3;
32782   if (!arg3) {
32783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32784     return 0;
32785   }
32786   {
32787     try {
32788       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
32789     } CALL_CATCH_EXCEPTION(0);
32790   }
32791
32792   jresult = result;
32793   return jresult;
32794 }
32795
32796
32797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
32798   void * jresult ;
32799   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
32800
32801   {
32802     try {
32803       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
32804     } CALL_CATCH_EXCEPTION(0);
32805   }
32806
32807   jresult = (void *)result;
32808   return jresult;
32809 }
32810
32811
32812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
32813   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32814
32815   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32816   {
32817     try {
32818       delete arg1;
32819     } CALL_CATCH_EXCEPTION();
32820   }
32821
32822 }
32823
32824
32825 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
32826   bool jresult ;
32827   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32828   bool result;
32829
32830   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32831   {
32832     try {
32833       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
32834     } CALL_CATCH_EXCEPTION(0);
32835   }
32836
32837   jresult = result;
32838   return jresult;
32839 }
32840
32841
32842 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
32843   unsigned long jresult ;
32844   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32845   std::size_t result;
32846
32847   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32848   {
32849     try {
32850       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
32851     } CALL_CATCH_EXCEPTION(0);
32852   }
32853
32854   jresult = (unsigned long)result;
32855   return jresult;
32856 }
32857
32858
32859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
32860   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32861   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32862
32863   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32864   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32865   {
32866     try {
32867       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32868     } CALL_CATCH_EXCEPTION();
32869   }
32870
32871 }
32872
32873
32874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
32875   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32876   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32877
32878   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32879   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32880   {
32881     try {
32882       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32883     } CALL_CATCH_EXCEPTION();
32884   }
32885
32886 }
32887
32888
32889 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32890   bool jresult ;
32891   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32892   Dali::Actor arg2 ;
32893   Dali::HoverEvent *arg3 = 0 ;
32894   Dali::Actor *argp2 ;
32895   bool result;
32896
32897   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32898   argp2 = (Dali::Actor *)jarg2;
32899   if (!argp2) {
32900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32901     return 0;
32902   }
32903   arg2 = *argp2;
32904   arg3 = (Dali::HoverEvent *)jarg3;
32905   if (!arg3) {
32906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32907     return 0;
32908   }
32909   {
32910     try {
32911       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
32912     } CALL_CATCH_EXCEPTION(0);
32913   }
32914
32915   jresult = result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
32921   void * jresult ;
32922   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
32923
32924   {
32925     try {
32926       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
32927     } CALL_CATCH_EXCEPTION(0);
32928   }
32929
32930   jresult = (void *)result;
32931   return jresult;
32932 }
32933
32934
32935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32936   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32937
32938   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32939   {
32940     try {
32941       delete arg1;
32942     } CALL_CATCH_EXCEPTION();
32943   }
32944
32945 }
32946
32947
32948 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32949   bool jresult ;
32950   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32951   bool result;
32952
32953   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32954   {
32955     try {
32956       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
32957     } CALL_CATCH_EXCEPTION(0);
32958   }
32959
32960   jresult = result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32966   unsigned long jresult ;
32967   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32968   std::size_t result;
32969
32970   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32971   {
32972     try {
32973       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
32974     } CALL_CATCH_EXCEPTION(0);
32975   }
32976
32977   jresult = (unsigned long)result;
32978   return jresult;
32979 }
32980
32981
32982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32983   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32984   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32985
32986   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32987   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32988   {
32989     try {
32990       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32991     } CALL_CATCH_EXCEPTION();
32992   }
32993
32994 }
32995
32996
32997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32998   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32999   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
33000
33001   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33002   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
33003   {
33004     try {
33005       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33006     } CALL_CATCH_EXCEPTION();
33007   }
33008
33009 }
33010
33011
33012 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33013   bool jresult ;
33014   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33015   Dali::Actor arg2 ;
33016   Dali::WheelEvent *arg3 = 0 ;
33017   Dali::Actor *argp2 ;
33018   bool result;
33019
33020   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33021   argp2 = (Dali::Actor *)jarg2;
33022   if (!argp2) {
33023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33024     return 0;
33025   }
33026   arg2 = *argp2;
33027   arg3 = (Dali::WheelEvent *)jarg3;
33028   if (!arg3) {
33029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
33030     return 0;
33031   }
33032   {
33033     try {
33034       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
33035     } CALL_CATCH_EXCEPTION(0);
33036   }
33037
33038   jresult = result;
33039   return jresult;
33040 }
33041
33042
33043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
33044   void * jresult ;
33045   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
33046
33047   {
33048     try {
33049       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
33050     } CALL_CATCH_EXCEPTION(0);
33051   }
33052
33053   jresult = (void *)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
33059   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
33060
33061   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
33062   {
33063     try {
33064       delete arg1;
33065     } CALL_CATCH_EXCEPTION();
33066   }
33067
33068 }
33069
33070
33071 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
33072   bool jresult ;
33073   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33074   bool result;
33075
33076   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33077   {
33078     try {
33079       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
33080     } CALL_CATCH_EXCEPTION(0);
33081   }
33082
33083   jresult = result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
33089   unsigned long jresult ;
33090   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33091   std::size_t result;
33092
33093   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33094   {
33095     try {
33096       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
33097     } CALL_CATCH_EXCEPTION(0);
33098   }
33099
33100   jresult = (unsigned long)result;
33101   return jresult;
33102 }
33103
33104
33105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
33106   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33107   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
33108
33109   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33110   arg2 = (void (*)(Dali::Actor))jarg2;
33111   {
33112     try {
33113       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
33114     } CALL_CATCH_EXCEPTION();
33115   }
33116
33117 }
33118
33119
33120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
33121   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33122   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
33123
33124   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33125   arg2 = (void (*)(Dali::Actor))jarg2;
33126   {
33127     try {
33128       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
33129     } CALL_CATCH_EXCEPTION();
33130   }
33131
33132 }
33133
33134
33135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
33136   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33137   Dali::Actor arg2 ;
33138   Dali::Actor *argp2 ;
33139
33140   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33141   argp2 = (Dali::Actor *)jarg2;
33142   if (!argp2) {
33143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33144     return ;
33145   }
33146   arg2 = *argp2;
33147   {
33148     try {
33149       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
33150     } CALL_CATCH_EXCEPTION();
33151   }
33152
33153 }
33154
33155
33156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
33157   void * jresult ;
33158   Dali::Signal< void (Dali::Actor) > *result = 0 ;
33159
33160   {
33161     try {
33162       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
33163     } CALL_CATCH_EXCEPTION(0);
33164   }
33165
33166   jresult = (void *)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
33172   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
33173
33174   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
33175   {
33176     try {
33177       delete arg1;
33178     } CALL_CATCH_EXCEPTION();
33179   }
33180
33181 }
33182
33183
33184 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
33185   bool jresult ;
33186   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33187   bool result;
33188
33189   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33190   {
33191     try {
33192       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
33193     } CALL_CATCH_EXCEPTION(0);
33194   }
33195
33196   jresult = result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
33202   unsigned long jresult ;
33203   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33204   std::size_t result;
33205
33206   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33207   {
33208     try {
33209       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
33210     } CALL_CATCH_EXCEPTION(0);
33211   }
33212
33213   jresult = (unsigned long)result;
33214   return jresult;
33215 }
33216
33217
33218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
33219   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33220   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
33221
33222   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33223   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
33224   {
33225     try {
33226       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33227     } CALL_CATCH_EXCEPTION();
33228   }
33229
33230 }
33231
33232
33233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
33234   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33235   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
33236
33237   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33238   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
33239   {
33240     try {
33241       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33242     } CALL_CATCH_EXCEPTION();
33243   }
33244
33245 }
33246
33247
33248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
33249   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33250   Dali::KeyEvent *arg2 = 0 ;
33251
33252   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33253   arg2 = (Dali::KeyEvent *)jarg2;
33254   if (!arg2) {
33255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
33256     return ;
33257   }
33258   {
33259     try {
33260       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
33261     } CALL_CATCH_EXCEPTION();
33262   }
33263
33264 }
33265
33266
33267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
33268   void * jresult ;
33269   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
33270
33271   {
33272     try {
33273       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
33274     } CALL_CATCH_EXCEPTION(0);
33275   }
33276
33277   jresult = (void *)result;
33278   return jresult;
33279 }
33280
33281
33282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
33283   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
33284
33285   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
33286   {
33287     try {
33288       delete arg1;
33289     } CALL_CATCH_EXCEPTION();
33290   }
33291
33292 }
33293
33294
33295 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
33296   bool jresult ;
33297   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33298   bool result;
33299
33300   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33301   {
33302     try {
33303       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
33304     } CALL_CATCH_EXCEPTION(0);
33305   }
33306
33307   jresult = result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
33313   unsigned long jresult ;
33314   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33315   std::size_t result;
33316
33317   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33318   {
33319     try {
33320       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
33321     } CALL_CATCH_EXCEPTION(0);
33322   }
33323
33324   jresult = (unsigned long)result;
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
33330   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33331   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
33332
33333   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33334   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
33335   {
33336     try {
33337       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33338     } CALL_CATCH_EXCEPTION();
33339   }
33340
33341 }
33342
33343
33344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
33345   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33346   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
33347
33348   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33349   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
33350   {
33351     try {
33352       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33353     } CALL_CATCH_EXCEPTION();
33354   }
33355
33356 }
33357
33358
33359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
33360   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33361   Dali::TouchEvent *arg2 = 0 ;
33362
33363   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33364   arg2 = (Dali::TouchEvent *)jarg2;
33365   if (!arg2) {
33366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33367     return ;
33368   }
33369   {
33370     try {
33371       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
33372     } CALL_CATCH_EXCEPTION();
33373   }
33374
33375 }
33376
33377
33378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
33379   void * jresult ;
33380   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
33381
33382   {
33383     try {
33384       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
33385     } CALL_CATCH_EXCEPTION(0);
33386   }
33387
33388   jresult = (void *)result;
33389   return jresult;
33390 }
33391
33392
33393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
33394   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
33395
33396   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
33397   {
33398     try {
33399       delete arg1;
33400     } CALL_CATCH_EXCEPTION();
33401   }
33402
33403 }
33404
33405
33406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
33407   bool jresult ;
33408   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33409   bool result;
33410
33411   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33412   {
33413     try {
33414       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
33415     } CALL_CATCH_EXCEPTION(0);
33416   }
33417
33418   jresult = result;
33419   return jresult;
33420 }
33421
33422
33423 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
33424   unsigned long jresult ;
33425   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33426   std::size_t result;
33427
33428   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33429   {
33430     try {
33431       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
33432     } CALL_CATCH_EXCEPTION(0);
33433   }
33434
33435   jresult = (unsigned long)result;
33436   return jresult;
33437 }
33438
33439
33440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
33441   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33442   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
33443
33444   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33445   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
33446   {
33447     try {
33448       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33449     } CALL_CATCH_EXCEPTION();
33450   }
33451
33452 }
33453
33454
33455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
33456   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33457   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
33458
33459   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33460   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
33461   {
33462     try {
33463       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33464     } CALL_CATCH_EXCEPTION();
33465   }
33466
33467 }
33468
33469
33470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
33471   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33472   Dali::WheelEvent *arg2 = 0 ;
33473
33474   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33475   arg2 = (Dali::WheelEvent *)jarg2;
33476   if (!arg2) {
33477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
33478     return ;
33479   }
33480   {
33481     try {
33482       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
33483     } CALL_CATCH_EXCEPTION();
33484   }
33485
33486 }
33487
33488
33489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
33490   void * jresult ;
33491   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
33492
33493   {
33494     try {
33495       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
33496     } CALL_CATCH_EXCEPTION(0);
33497   }
33498
33499   jresult = (void *)result;
33500   return jresult;
33501 }
33502
33503
33504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
33505   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
33506
33507   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
33508   {
33509     try {
33510       delete arg1;
33511     } CALL_CATCH_EXCEPTION();
33512   }
33513
33514 }
33515
33516
33517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
33518   void * jresult ;
33519   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
33520
33521   {
33522     try {
33523       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
33524     } CALL_CATCH_EXCEPTION(0);
33525   }
33526
33527   jresult = (void *)result;
33528   return jresult;
33529 }
33530
33531
33532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
33533   void * jresult ;
33534   Dali::Radian arg1 ;
33535   Dali::Radian arg2 ;
33536   Dali::Radian *argp1 ;
33537   Dali::Radian *argp2 ;
33538   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
33539
33540   argp1 = (Dali::Radian *)jarg1;
33541   if (!argp1) {
33542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33543     return 0;
33544   }
33545   arg1 = *argp1;
33546   argp2 = (Dali::Radian *)jarg2;
33547   if (!argp2) {
33548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33549     return 0;
33550   }
33551   arg2 = *argp2;
33552   {
33553     try {
33554       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
33555     } CALL_CATCH_EXCEPTION(0);
33556   }
33557
33558   jresult = (void *)result;
33559   return jresult;
33560 }
33561
33562
33563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
33564   void * jresult ;
33565   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
33566   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
33567
33568   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33569   if (!arg1) {
33570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
33571     return 0;
33572   }
33573   {
33574     try {
33575       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
33576     } CALL_CATCH_EXCEPTION(0);
33577   }
33578
33579   jresult = (void *)result;
33580   return jresult;
33581 }
33582
33583
33584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
33585   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
33586   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
33587
33588   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33589   arg2 = (Dali::Radian *)jarg2;
33590   if (arg1) (arg1)->first = *arg2;
33591 }
33592
33593
33594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
33595   void * jresult ;
33596   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
33597   Dali::Radian *result = 0 ;
33598
33599   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33600   result = (Dali::Radian *)& ((arg1)->first);
33601   jresult = (void *)result;
33602   return jresult;
33603 }
33604
33605
33606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
33607   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
33608   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
33609
33610   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33611   arg2 = (Dali::Radian *)jarg2;
33612   if (arg1) (arg1)->second = *arg2;
33613 }
33614
33615
33616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
33617   void * jresult ;
33618   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
33619   Dali::Radian *result = 0 ;
33620
33621   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33622   result = (Dali::Radian *)& ((arg1)->second);
33623   jresult = (void *)result;
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
33629   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
33630
33631   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
33632   {
33633     try {
33634       delete arg1;
33635     } CALL_CATCH_EXCEPTION();
33636   }
33637
33638 }
33639
33640
33641 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
33642   bool jresult ;
33643   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33644   bool result;
33645
33646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33647   {
33648     try {
33649       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);
33650     } CALL_CATCH_EXCEPTION(0);
33651   }
33652
33653   jresult = result;
33654   return jresult;
33655 }
33656
33657
33658 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33659   unsigned long jresult ;
33660   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33661   std::size_t result;
33662
33663   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33664   {
33665     try {
33666       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);
33667     } CALL_CATCH_EXCEPTION(0);
33668   }
33669
33670   jresult = (unsigned long)result;
33671   return jresult;
33672 }
33673
33674
33675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33676   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33677   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
33678
33679   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33680   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
33681   {
33682     try {
33683       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33684     } CALL_CATCH_EXCEPTION();
33685   }
33686
33687 }
33688
33689
33690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33691   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33692   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
33693
33694   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33695   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
33696   {
33697     try {
33698       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33699     } CALL_CATCH_EXCEPTION();
33700   }
33701
33702 }
33703
33704
33705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33706   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33707   Dali::Actor arg2 ;
33708   Dali::PanGesture *arg3 = 0 ;
33709   Dali::Actor *argp2 ;
33710
33711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33712   argp2 = (Dali::Actor *)jarg2;
33713   if (!argp2) {
33714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33715     return ;
33716   }
33717   arg2 = *argp2;
33718   arg3 = (Dali::PanGesture *)jarg3;
33719   if (!arg3) {
33720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
33721     return ;
33722   }
33723   {
33724     try {
33725       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
33726     } CALL_CATCH_EXCEPTION();
33727   }
33728
33729 }
33730
33731
33732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
33733   void * jresult ;
33734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
33735
33736   {
33737     try {
33738       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
33739     } CALL_CATCH_EXCEPTION(0);
33740   }
33741
33742   jresult = (void *)result;
33743   return jresult;
33744 }
33745
33746
33747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
33748   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
33749
33750   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
33751   {
33752     try {
33753       delete arg1;
33754     } CALL_CATCH_EXCEPTION();
33755   }
33756
33757 }
33758
33759
33760 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
33761   bool jresult ;
33762   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33763   bool result;
33764
33765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33766   {
33767     try {
33768       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);
33769     } CALL_CATCH_EXCEPTION(0);
33770   }
33771
33772   jresult = result;
33773   return jresult;
33774 }
33775
33776
33777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33778   unsigned long jresult ;
33779   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33780   std::size_t result;
33781
33782   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33783   {
33784     try {
33785       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);
33786     } CALL_CATCH_EXCEPTION(0);
33787   }
33788
33789   jresult = (unsigned long)result;
33790   return jresult;
33791 }
33792
33793
33794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33795   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33796   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
33797
33798   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33799   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
33800   {
33801     try {
33802       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33803     } CALL_CATCH_EXCEPTION();
33804   }
33805
33806 }
33807
33808
33809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33810   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33811   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
33812
33813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33814   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
33815   {
33816     try {
33817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33818     } CALL_CATCH_EXCEPTION();
33819   }
33820
33821 }
33822
33823
33824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33825   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33826   Dali::Actor arg2 ;
33827   Dali::PinchGesture *arg3 = 0 ;
33828   Dali::Actor *argp2 ;
33829
33830   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33831   argp2 = (Dali::Actor *)jarg2;
33832   if (!argp2) {
33833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33834     return ;
33835   }
33836   arg2 = *argp2;
33837   arg3 = (Dali::PinchGesture *)jarg3;
33838   if (!arg3) {
33839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
33840     return ;
33841   }
33842   {
33843     try {
33844       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
33845     } CALL_CATCH_EXCEPTION();
33846   }
33847
33848 }
33849
33850
33851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
33852   void * jresult ;
33853   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
33854
33855   {
33856     try {
33857       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
33858     } CALL_CATCH_EXCEPTION(0);
33859   }
33860
33861   jresult = (void *)result;
33862   return jresult;
33863 }
33864
33865
33866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
33867   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33868
33869   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33870   {
33871     try {
33872       delete arg1;
33873     } CALL_CATCH_EXCEPTION();
33874   }
33875
33876 }
33877
33878
33879 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
33880   bool jresult ;
33881   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33882   bool result;
33883
33884   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33885   {
33886     try {
33887       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);
33888     } CALL_CATCH_EXCEPTION(0);
33889   }
33890
33891   jresult = result;
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33897   unsigned long jresult ;
33898   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33899   std::size_t result;
33900
33901   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33902   {
33903     try {
33904       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);
33905     } CALL_CATCH_EXCEPTION(0);
33906   }
33907
33908   jresult = (unsigned long)result;
33909   return jresult;
33910 }
33911
33912
33913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33914   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33915   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33916
33917   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33918   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33919   {
33920     try {
33921       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33922     } CALL_CATCH_EXCEPTION();
33923   }
33924
33925 }
33926
33927
33928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33929   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33930   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33931
33932   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33933   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33934   {
33935     try {
33936       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33937     } CALL_CATCH_EXCEPTION();
33938   }
33939
33940 }
33941
33942
33943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33944   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33945   Dali::Actor arg2 ;
33946   Dali::TapGesture *arg3 = 0 ;
33947   Dali::Actor *argp2 ;
33948
33949   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33950   argp2 = (Dali::Actor *)jarg2;
33951   if (!argp2) {
33952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33953     return ;
33954   }
33955   arg2 = *argp2;
33956   arg3 = (Dali::TapGesture *)jarg3;
33957   if (!arg3) {
33958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33959     return ;
33960   }
33961   {
33962     try {
33963       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33964     } CALL_CATCH_EXCEPTION();
33965   }
33966
33967 }
33968
33969
33970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33971   void * jresult ;
33972   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33973
33974   {
33975     try {
33976       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33977     } CALL_CATCH_EXCEPTION(0);
33978   }
33979
33980   jresult = (void *)result;
33981   return jresult;
33982 }
33983
33984
33985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33986   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33987
33988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33989   {
33990     try {
33991       delete arg1;
33992     } CALL_CATCH_EXCEPTION();
33993   }
33994
33995 }
33996
33997
33998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33999   bool jresult ;
34000   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34001   bool result = false;
34002
34003   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34004   {
34005     try {
34006       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
34007     } CALL_CATCH_EXCEPTION(0);
34008   }
34009   jresult = result;
34010   return jresult;
34011 }
34012
34013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
34014   unsigned long jresult ;
34015   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34016   std::size_t result = 0;
34017
34018   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34019   {
34020     try {
34021       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);
34022     }CALL_CATCH_EXCEPTION(0);
34023   }
34024   jresult = (unsigned long)result;
34025   return jresult;
34026 }
34027
34028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
34029   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34030   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34031
34032   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34033   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34034   {
34035     try {
34036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
34037     } CALL_CATCH_EXCEPTION();
34038   }
34039 }
34040
34041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
34042   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34043   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
34044
34045   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34046   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
34047   {
34048     try {
34049       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
34050     } CALL_CATCH_EXCEPTION();
34051   }
34052 }
34053
34054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
34055   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34056   Dali::Actor arg2 ;
34057   //bool arg3 ;
34058   Dali::LayoutDirection::Type arg4 ;
34059   Dali::Actor *argp2 ;
34060
34061   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34062   argp2 = (Dali::Actor *)jarg2;
34063   if (!argp2) {
34064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34065     return ;
34066   }
34067   arg2 = *argp2;
34068   //arg3 = jarg3 ? true : false;
34069   arg4 = (Dali::LayoutDirection::Type)jarg4;
34070   {
34071     try {
34072       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
34073     } CALL_CATCH_EXCEPTION();
34074   }
34075 }
34076
34077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
34078   void * jresult ;
34079   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
34080
34081   {
34082     try {
34083       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
34084     } CALL_CATCH_EXCEPTION(0);
34085   }
34086   jresult = (void *)result;
34087   return jresult;
34088 }
34089
34090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
34091   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
34092
34093   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
34094   {
34095     try {
34096       delete arg1;
34097     } CALL_CATCH_EXCEPTION();
34098   }
34099 }
34100
34101
34102 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
34103   bool jresult ;
34104   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34105   bool result = false;
34106
34107   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34108   {
34109     try {
34110       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
34111     } CALL_CATCH_EXCEPTION(0);
34112   }
34113   jresult = result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
34119   unsigned long jresult ;
34120   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34121   std::size_t result;
34122
34123   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34124   {
34125     try {
34126       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
34127     } CALL_CATCH_EXCEPTION(0);
34128   }
34129
34130   jresult = (unsigned long)result;
34131   return jresult;
34132 }
34133
34134
34135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
34136   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34137   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
34138
34139   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34140   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
34141   {
34142     try {
34143       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
34144     } CALL_CATCH_EXCEPTION();
34145   }
34146
34147 }
34148
34149
34150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
34151   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34152   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
34153
34154   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34155   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
34156   {
34157     try {
34158       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
34159     } CALL_CATCH_EXCEPTION();
34160   }
34161
34162 }
34163
34164
34165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3, int jarg4) {
34166   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34167   Dali::Actor arg2 ;
34168   bool arg3 ;
34169   Dali::DevelActor::VisibilityChange::Type arg4 ;
34170   Dali::Actor *argp2 ;
34171
34172   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34173   argp2 = (Dali::Actor *)jarg2;
34174   if (!argp2) {
34175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34176     return ;
34177   }
34178   arg2 = *argp2;
34179   arg3 = jarg3 ? true : false;
34180   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
34181   {
34182     try {
34183       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
34184     } CALL_CATCH_EXCEPTION();
34185   }
34186
34187 }
34188
34189
34190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
34191   void * jresult ;
34192   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
34193
34194   {
34195     try {
34196       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
34197     } CALL_CATCH_EXCEPTION(0);
34198   }
34199
34200   jresult = (void *)result;
34201   return jresult;
34202 }
34203
34204
34205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
34206   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
34207
34208   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
34209   {
34210     try {
34211       delete arg1;
34212     } CALL_CATCH_EXCEPTION();
34213   }
34214
34215 }
34216
34217
34218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
34219   void * jresult ;
34220   Dali::Timer *result = 0 ;
34221
34222   {
34223     try {
34224       result = (Dali::Timer *)new Dali::Timer();
34225     } CALL_CATCH_EXCEPTION(0);
34226   }
34227
34228   jresult = (void *)result;
34229   return jresult;
34230 }
34231
34232
34233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
34234   void * jresult ;
34235   unsigned int arg1 ;
34236   Dali::Timer result;
34237
34238   arg1 = (unsigned int)jarg1;
34239   {
34240     try {
34241       result = Dali::Timer::New(arg1);
34242     } CALL_CATCH_EXCEPTION(0);
34243   }
34244
34245   jresult = new Dali::Timer((const Dali::Timer &)result);
34246   return jresult;
34247 }
34248
34249
34250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
34251   void * jresult ;
34252   Dali::Timer *arg1 = 0 ;
34253   Dali::Timer *result = 0 ;
34254
34255   arg1 = (Dali::Timer *)jarg1;
34256   if (!arg1) {
34257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
34258     return 0;
34259   }
34260   {
34261     try {
34262       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
34263     } CALL_CATCH_EXCEPTION(0);
34264   }
34265
34266   jresult = (void *)result;
34267   return jresult;
34268 }
34269
34270
34271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
34272   void * jresult ;
34273   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34274   Dali::Timer *arg2 = 0 ;
34275   Dali::Timer *result = 0 ;
34276
34277   arg1 = (Dali::Timer *)jarg1;
34278   arg2 = (Dali::Timer *)jarg2;
34279   if (!arg2) {
34280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
34281     return 0;
34282   }
34283   {
34284     try {
34285       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
34286     } CALL_CATCH_EXCEPTION(0);
34287   }
34288
34289   jresult = (void *)result;
34290   return jresult;
34291 }
34292
34293
34294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
34295   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34296
34297   arg1 = (Dali::Timer *)jarg1;
34298   {
34299     try {
34300       delete arg1;
34301     } CALL_CATCH_EXCEPTION();
34302   }
34303
34304 }
34305
34306
34307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
34308   void * jresult ;
34309   Dali::BaseHandle arg1 ;
34310   Dali::BaseHandle *argp1 ;
34311   Dali::Timer result;
34312
34313   argp1 = (Dali::BaseHandle *)jarg1;
34314   if (!argp1) {
34315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34316     return 0;
34317   }
34318   arg1 = *argp1;
34319   {
34320     try {
34321       result = Dali::Timer::DownCast(arg1);
34322     } CALL_CATCH_EXCEPTION(0);
34323   }
34324
34325   jresult = new Dali::Timer((const Dali::Timer &)result);
34326   return jresult;
34327 }
34328
34329
34330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
34331   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34332
34333   arg1 = (Dali::Timer *)jarg1;
34334   {
34335     try {
34336       (arg1)->Start();
34337     } CALL_CATCH_EXCEPTION();
34338   }
34339
34340 }
34341
34342
34343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
34344   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34345
34346   arg1 = (Dali::Timer *)jarg1;
34347   {
34348     try {
34349       (arg1)->Stop();
34350     } CALL_CATCH_EXCEPTION();
34351   }
34352
34353 }
34354
34355
34356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
34357   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34358   unsigned int arg2 ;
34359
34360   arg1 = (Dali::Timer *)jarg1;
34361   arg2 = (unsigned int)jarg2;
34362   {
34363     try {
34364       (arg1)->SetInterval(arg2);
34365     } CALL_CATCH_EXCEPTION();
34366   }
34367
34368 }
34369
34370
34371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
34372   unsigned int jresult ;
34373   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34374   unsigned int result;
34375
34376   arg1 = (Dali::Timer *)jarg1;
34377   {
34378     try {
34379       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
34380     } CALL_CATCH_EXCEPTION(0);
34381   }
34382
34383   jresult = result;
34384   return jresult;
34385 }
34386
34387
34388 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
34389   bool jresult ;
34390   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34391   bool result;
34392
34393   arg1 = (Dali::Timer *)jarg1;
34394   {
34395     try {
34396       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
34397     } CALL_CATCH_EXCEPTION(0);
34398   }
34399
34400   jresult = result;
34401   return jresult;
34402 }
34403
34404
34405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
34406   void * jresult ;
34407   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
34408   Dali::Timer::TimerSignalType *result = 0 ;
34409
34410   arg1 = (Dali::Timer *)jarg1;
34411   {
34412     try {
34413       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
34414     } CALL_CATCH_EXCEPTION(0);
34415   }
34416
34417   jresult = (void *)result;
34418   return jresult;
34419 }
34420
34421
34422 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
34423   bool jresult ;
34424   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34425   bool result;
34426
34427   arg1 = (Dali::Signal< bool () > *)jarg1;
34428   {
34429     try {
34430       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
34431     } CALL_CATCH_EXCEPTION(0);
34432   }
34433
34434   jresult = result;
34435   return jresult;
34436 }
34437
34438
34439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
34440   unsigned long jresult ;
34441   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34442   std::size_t result;
34443
34444   arg1 = (Dali::Signal< bool () > *)jarg1;
34445   {
34446     try {
34447       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
34448     } CALL_CATCH_EXCEPTION(0);
34449   }
34450
34451   jresult = (unsigned long)result;
34452   return jresult;
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
34457   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34458   bool (*arg2)() = (bool (*)()) 0 ;
34459
34460   arg1 = (Dali::Signal< bool () > *)jarg1;
34461   arg2 = (bool (*)())jarg2;
34462   {
34463     try {
34464       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
34465     } CALL_CATCH_EXCEPTION();
34466   }
34467
34468 }
34469
34470
34471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
34472   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34473   bool (*arg2)() = (bool (*)()) 0 ;
34474
34475   arg1 = (Dali::Signal< bool () > *)jarg1;
34476   arg2 = (bool (*)())jarg2;
34477   {
34478     try {
34479       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
34480     } CALL_CATCH_EXCEPTION();
34481   }
34482
34483 }
34484
34485
34486 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
34487   bool jresult ;
34488   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34489   bool result;
34490
34491   arg1 = (Dali::Signal< bool () > *)jarg1;
34492   {
34493     try {
34494       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
34495     } CALL_CATCH_EXCEPTION(0);
34496   }
34497
34498   jresult = result;
34499   return jresult;
34500 }
34501
34502
34503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
34504   void * jresult ;
34505   Dali::Signal< bool () > *result = 0 ;
34506
34507   {
34508     try {
34509       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
34510     } CALL_CATCH_EXCEPTION(0);
34511   }
34512
34513   jresult = (void *)result;
34514   return jresult;
34515 }
34516
34517
34518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
34519   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
34520
34521   arg1 = (Dali::Signal< bool () > *)jarg1;
34522   {
34523     try {
34524       delete arg1;
34525     } CALL_CATCH_EXCEPTION();
34526   }
34527
34528 }
34529
34530
34531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
34532   int jresult ;
34533   int result;
34534
34535   {
34536     try {
34537       result = (int)Dali::Toolkit::Visual::Property::TYPE;
34538     } CALL_CATCH_EXCEPTION(0);
34539   }
34540
34541   jresult = (int)result;
34542   return jresult;
34543 }
34544
34545
34546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
34547   int jresult ;
34548   int result;
34549
34550   {
34551     try {
34552       result = (int)Dali::Toolkit::Visual::Property::SHADER;
34553     } CALL_CATCH_EXCEPTION(0);
34554   }
34555
34556   jresult = (int)result;
34557   return jresult;
34558 }
34559
34560
34561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
34562   int jresult ;
34563   int result;
34564
34565   {
34566     try {
34567       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
34568     } CALL_CATCH_EXCEPTION(0);
34569   }
34570
34571   jresult = (int)result;
34572   return jresult;
34573 }
34574
34575
34576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
34577   int jresult ;
34578   int result;
34579
34580   {
34581     try {
34582       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
34583     } CALL_CATCH_EXCEPTION(0);
34584   }
34585
34586   jresult = (int)result;
34587   return jresult;
34588 }
34589
34590
34591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
34592   int jresult ;
34593   int result;
34594
34595   {
34596     try {
34597       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
34598     } CALL_CATCH_EXCEPTION(0);
34599   }
34600
34601   jresult = (int)result;
34602   return jresult;
34603 }
34604
34605
34606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
34607   int jresult ;
34608   int result;
34609
34610   {
34611     try {
34612       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
34613     } CALL_CATCH_EXCEPTION(0);
34614   }
34615
34616   jresult = (int)result;
34617   return jresult;
34618 }
34619
34620
34621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
34622   int jresult ;
34623   int result;
34624
34625   {
34626     try {
34627       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
34628     } CALL_CATCH_EXCEPTION(0);
34629   }
34630
34631   jresult = (int)result;
34632   return jresult;
34633 }
34634
34635
34636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
34637   int jresult ;
34638   int result;
34639
34640   {
34641     try {
34642       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
34643     } CALL_CATCH_EXCEPTION(0);
34644   }
34645
34646   jresult = (int)result;
34647   return jresult;
34648 }
34649
34650
34651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
34652   int jresult ;
34653   int result;
34654
34655   {
34656     try {
34657       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
34658     } CALL_CATCH_EXCEPTION(0);
34659   }
34660
34661   jresult = (int)result;
34662   return jresult;
34663 }
34664
34665
34666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
34667   int jresult ;
34668   int result;
34669
34670   {
34671     try {
34672       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
34673     } CALL_CATCH_EXCEPTION(0);
34674   }
34675
34676   jresult = (int)result;
34677   return jresult;
34678 }
34679
34680
34681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
34682   int jresult ;
34683   int result;
34684
34685   {
34686     try {
34687       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
34688     } CALL_CATCH_EXCEPTION(0);
34689   }
34690
34691   jresult = (int)result;
34692   return jresult;
34693 }
34694
34695
34696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
34697   int jresult ;
34698   int result;
34699
34700   {
34701     try {
34702       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
34703     } CALL_CATCH_EXCEPTION(0);
34704   }
34705
34706   jresult = (int)result;
34707   return jresult;
34708 }
34709
34710
34711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
34712   int jresult ;
34713   int result;
34714
34715   {
34716     try {
34717       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
34718     } CALL_CATCH_EXCEPTION(0);
34719   }
34720
34721   jresult = (int)result;
34722   return jresult;
34723 }
34724
34725
34726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
34727   int jresult ;
34728   int result;
34729
34730   {
34731     try {
34732       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
34733     } CALL_CATCH_EXCEPTION(0);
34734   }
34735
34736   jresult = (int)result;
34737   return jresult;
34738 }
34739
34740
34741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
34742   int jresult ;
34743   int result;
34744
34745   {
34746     try {
34747       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
34748     } CALL_CATCH_EXCEPTION(0);
34749   }
34750
34751   jresult = (int)result;
34752   return jresult;
34753 }
34754
34755
34756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
34757   int jresult ;
34758   int result;
34759
34760   {
34761     try {
34762       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
34763     } CALL_CATCH_EXCEPTION(0);
34764   }
34765
34766   jresult = (int)result;
34767   return jresult;
34768 }
34769
34770
34771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
34772   int jresult ;
34773   int result;
34774
34775   {
34776     try {
34777       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
34778     } CALL_CATCH_EXCEPTION(0);
34779   }
34780
34781   jresult = (int)result;
34782   return jresult;
34783 }
34784
34785
34786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
34787   int jresult ;
34788   int result;
34789
34790   {
34791     try {
34792       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
34793     } CALL_CATCH_EXCEPTION(0);
34794   }
34795
34796   jresult = (int)result;
34797   return jresult;
34798 }
34799
34800
34801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
34802   int jresult ;
34803   int result;
34804
34805   {
34806     try {
34807       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
34808     } CALL_CATCH_EXCEPTION(0);
34809   }
34810
34811   jresult = (int)result;
34812   return jresult;
34813 }
34814
34815
34816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
34817   int jresult ;
34818   int result;
34819
34820   {
34821     try {
34822       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
34823     } CALL_CATCH_EXCEPTION(0);
34824   }
34825
34826   jresult = (int)result;
34827   return jresult;
34828 }
34829
34830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
34831   int jresult ;
34832   int result;
34833
34834   {
34835     try {
34836       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
34837     } CALL_CATCH_EXCEPTION(0);
34838   }
34839
34840   jresult = (int)result;
34841   return jresult;
34842 }
34843
34844
34845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
34846   int jresult ;
34847   int result;
34848   {
34849     try
34850     {
34851       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
34852     } CALL_CATCH_EXCEPTION(0);
34853   }
34854
34855   jresult = (int)result;
34856   return jresult;
34857 }
34858
34859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
34860   int jresult ;
34861   int result;
34862   {
34863     try
34864     {
34865       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
34866     } CALL_CATCH_EXCEPTION(0);
34867   }
34868
34869   jresult = (int)result;
34870   return jresult;
34871 }
34872
34873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
34874   int jresult ;
34875   int result;
34876   {
34877     try
34878     {
34879       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
34880     } CALL_CATCH_EXCEPTION(0);
34881   }
34882
34883   jresult = (int)result;
34884   return jresult;
34885 }
34886
34887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
34888   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
34889 }
34890
34891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
34892   int jresult ;
34893   int result;
34894   {
34895     try
34896     {
34897       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
34898     } CALL_CATCH_EXCEPTION(0);
34899   }
34900
34901   jresult = (int)result;
34902   return jresult;
34903 }
34904
34905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
34906   int jresult ;
34907   int result;
34908   {
34909     try
34910     {
34911       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
34912     } CALL_CATCH_EXCEPTION(0);
34913   }
34914
34915   jresult = (int)result;
34916   return jresult;
34917 }
34918
34919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
34920   int jresult ;
34921   int result;
34922
34923   {
34924     try {
34925       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
34926     } CALL_CATCH_EXCEPTION(0);
34927   }
34928
34929   jresult = (int)result;
34930   return jresult;
34931 }
34932
34933
34934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34935   int jresult ;
34936   int result;
34937
34938   {
34939     try {
34940       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34941     } CALL_CATCH_EXCEPTION(0);
34942   }
34943
34944   jresult = (int)result;
34945   return jresult;
34946 }
34947
34948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34949   int jresult ;
34950   int result;
34951   {
34952     try
34953     {
34954       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34955     } CALL_CATCH_EXCEPTION(0);
34956   }
34957
34958   jresult = (int)result;
34959   return jresult;
34960 }
34961
34962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34963   int jresult ;
34964   int result;
34965   {
34966     try
34967     {
34968       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34969     } CALL_CATCH_EXCEPTION(0);
34970   }
34971
34972   jresult = (int)result;
34973   return jresult;
34974 }
34975
34976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34977   int jresult ;
34978   int result;
34979   {
34980     try
34981     {
34982       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34983     } CALL_CATCH_EXCEPTION(0);
34984   }
34985
34986   jresult = (int)result;
34987   return jresult;
34988 }
34989
34990
34991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34992   int jresult ;
34993   int result;
34994   {
34995     try
34996     {
34997       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34998     } CALL_CATCH_EXCEPTION(0);
34999   }
35000
35001   jresult = (int)result;
35002   return jresult;
35003 }
35004
35005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
35006   int jresult ;
35007   int result;
35008   {
35009     try
35010     {
35011       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
35012     } CALL_CATCH_EXCEPTION(0);
35013   }
35014
35015   jresult = (int)result;
35016   return jresult;
35017 }
35018
35019
35020
35021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
35022   int jresult ;
35023   int result;
35024
35025   {
35026     try {
35027       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
35028     } CALL_CATCH_EXCEPTION(0);
35029   }
35030
35031   jresult = (int)result;
35032   return jresult;
35033 }
35034
35035
35036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
35037   int jresult ;
35038   int result;
35039
35040   {
35041     try {
35042       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
35043     } CALL_CATCH_EXCEPTION(0);
35044   }
35045
35046   jresult = (int)result;
35047   return jresult;
35048 }
35049
35050
35051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
35052   int jresult ;
35053   int result;
35054
35055   {
35056     try {
35057       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
35058     } CALL_CATCH_EXCEPTION(0);
35059   }
35060
35061   jresult = (int)result;
35062   return jresult;
35063 }
35064
35065
35066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
35067   int jresult ;
35068   int result;
35069
35070   {
35071     try {
35072       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
35073     } CALL_CATCH_EXCEPTION(0);
35074   }
35075
35076   jresult = (int)result;
35077   return jresult;
35078 }
35079
35080
35081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
35082   int jresult ;
35083   int result;
35084
35085   {
35086     try {
35087       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
35088     } CALL_CATCH_EXCEPTION(0);
35089   }
35090
35091   jresult = (int)result;
35092   return jresult;
35093 }
35094
35095
35096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
35097   int jresult ;
35098   int result;
35099
35100   {
35101     try {
35102       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
35103     } CALL_CATCH_EXCEPTION(0);
35104   }
35105
35106   jresult = (int)result;
35107   return jresult;
35108 }
35109
35110
35111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
35112   int jresult ;
35113   int result;
35114
35115   {
35116     try {
35117       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
35118     } CALL_CATCH_EXCEPTION(0);
35119   }
35120
35121   jresult = (int)result;
35122   return jresult;
35123 }
35124
35125 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
35126   int jresult ;
35127   int result;
35128
35129   {
35130     try {
35131       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
35132     } CALL_CATCH_EXCEPTION(0);
35133   }
35134
35135   jresult = (int)result;
35136   return jresult;
35137 }
35138
35139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
35140   int jresult ;
35141   int result;
35142
35143   {
35144     try {
35145       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
35146     } CALL_CATCH_EXCEPTION(0);
35147   }
35148
35149   jresult = (int)result;
35150   return jresult;
35151 }
35152
35153
35154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
35155   int jresult ;
35156   int result;
35157
35158   {
35159     try {
35160       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
35161     } CALL_CATCH_EXCEPTION(0);
35162   }
35163
35164   jresult = (int)result;
35165   return jresult;
35166 }
35167
35168
35169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
35170   int jresult ;
35171   int result;
35172
35173   {
35174     try {
35175       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
35176     } CALL_CATCH_EXCEPTION(0);
35177   }
35178
35179   jresult = (int)result;
35180   return jresult;
35181 }
35182
35183
35184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
35185   int jresult ;
35186   int result;
35187
35188   {
35189     try {
35190       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
35191     } CALL_CATCH_EXCEPTION(0);
35192   }
35193
35194   jresult = (int)result;
35195   return jresult;
35196 }
35197
35198
35199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
35200   int jresult ;
35201   int result;
35202
35203   {
35204     try {
35205       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
35206     } CALL_CATCH_EXCEPTION(0);
35207   }
35208
35209   jresult = (int)result;
35210   return jresult;
35211 }
35212
35213
35214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
35215   int jresult ;
35216   int result;
35217
35218   {
35219     try {
35220       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
35221     } CALL_CATCH_EXCEPTION(0);
35222   }
35223
35224   jresult = (int)result;
35225   return jresult;
35226 }
35227
35228
35229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
35230   int jresult ;
35231   int result;
35232
35233   {
35234     try {
35235       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
35236     } CALL_CATCH_EXCEPTION(0);
35237   }
35238
35239   jresult = (int)result;
35240   return jresult;
35241 }
35242
35243
35244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
35245   int jresult ;
35246   int result;
35247
35248   {
35249     try {
35250       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
35251     } CALL_CATCH_EXCEPTION(0);
35252   }
35253
35254   jresult = (int)result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
35260   int jresult ;
35261   int result;
35262
35263   {
35264     try {
35265       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
35266     } CALL_CATCH_EXCEPTION(0);
35267   }
35268
35269   jresult = (int)result;
35270   return jresult;
35271 }
35272
35273
35274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
35275   int jresult ;
35276   int result;
35277
35278   {
35279     try {
35280       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
35281     } CALL_CATCH_EXCEPTION(0);
35282   }
35283
35284   jresult = (int)result;
35285   return jresult;
35286 }
35287
35288
35289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
35290   int jresult ;
35291   int result;
35292
35293   {
35294     try {
35295       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
35296     } CALL_CATCH_EXCEPTION(0);
35297   }
35298
35299   jresult = (int)result;
35300   return jresult;
35301 }
35302
35303
35304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
35305   int jresult ;
35306   int result;
35307
35308   {
35309     try {
35310       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
35311     } CALL_CATCH_EXCEPTION(0);
35312   }
35313
35314   jresult = (int)result;
35315   return jresult;
35316 }
35317
35318
35319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
35320   int jresult ;
35321   int result;
35322
35323   {
35324     try {
35325       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
35326     } CALL_CATCH_EXCEPTION(0);
35327   }
35328
35329   jresult = (int)result;
35330   return jresult;
35331 }
35332
35333
35334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
35335   int jresult ;
35336   int result;
35337
35338   {
35339     try {
35340       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
35341     } CALL_CATCH_EXCEPTION(0);
35342   }
35343
35344   jresult = (int)result;
35345   return jresult;
35346 }
35347
35348
35349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
35350   int jresult ;
35351   int result;
35352
35353   {
35354     try {
35355       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
35356     } CALL_CATCH_EXCEPTION(0);
35357   }
35358
35359   jresult = (int)result;
35360   return jresult;
35361 }
35362
35363
35364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
35365   int jresult ;
35366   int result;
35367
35368   {
35369     try {
35370       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
35371     } CALL_CATCH_EXCEPTION(0);
35372   }
35373
35374   jresult = (int)result;
35375   return jresult;
35376 }
35377
35378
35379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
35380   int jresult ;
35381   int result;
35382
35383   {
35384     try {
35385       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
35386     } CALL_CATCH_EXCEPTION(0);
35387   }
35388
35389   jresult = (int)result;
35390   return jresult;
35391 }
35392
35393
35394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
35395   int jresult ;
35396   int result;
35397
35398   {
35399     try {
35400       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
35401     } CALL_CATCH_EXCEPTION(0);
35402   }
35403
35404   jresult = (int)result;
35405   return jresult;
35406 }
35407
35408
35409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
35410   int jresult ;
35411   int result;
35412
35413   {
35414     try {
35415       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
35416     } CALL_CATCH_EXCEPTION(0);
35417   }
35418
35419   jresult = (int)result;
35420   return jresult;
35421 }
35422
35423
35424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
35425   int jresult ;
35426   int result;
35427
35428   {
35429     try {
35430       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
35431     } CALL_CATCH_EXCEPTION(0);
35432   }
35433
35434   jresult = (int)result;
35435   return jresult;
35436 }
35437
35438
35439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
35440   int jresult ;
35441   int result;
35442
35443   {
35444     try {
35445       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
35446     } CALL_CATCH_EXCEPTION(0);
35447   }
35448
35449   jresult = (int)result;
35450   return jresult;
35451 }
35452
35453
35454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
35455   int jresult ;
35456   int result;
35457
35458   {
35459     try {
35460       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
35461     } CALL_CATCH_EXCEPTION(0);
35462   }
35463
35464   jresult = (int)result;
35465   return jresult;
35466 }
35467
35468
35469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
35470   int jresult ;
35471   int result;
35472
35473   {
35474     try {
35475       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
35476     } CALL_CATCH_EXCEPTION(0);
35477   }
35478
35479   jresult = (int)result;
35480   return jresult;
35481 }
35482
35483
35484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
35485   int jresult ;
35486   int result;
35487
35488   {
35489     try {
35490       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
35491     } CALL_CATCH_EXCEPTION(0);
35492   }
35493
35494   jresult = (int)result;
35495   return jresult;
35496 }
35497
35498
35499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
35500   int jresult ;
35501   int result;
35502
35503   {
35504     try {
35505       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
35506     } CALL_CATCH_EXCEPTION(0);
35507   }
35508
35509   jresult = (int)result;
35510   return jresult;
35511 }
35512
35513
35514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
35515   int jresult ;
35516   int result;
35517
35518   {
35519     try {
35520       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
35521     } CALL_CATCH_EXCEPTION(0);
35522   }
35523
35524   jresult = (int)result;
35525   return jresult;
35526 }
35527
35528
35529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
35530   int jresult ;
35531   int result;
35532
35533   {
35534     try {
35535       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
35536     } CALL_CATCH_EXCEPTION(0);
35537   }
35538
35539   jresult = (int)result;
35540   return jresult;
35541 }
35542
35543
35544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
35545   int jresult ;
35546   int result;
35547
35548   {
35549     try {
35550       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
35551     } CALL_CATCH_EXCEPTION(0);
35552   }
35553
35554   jresult = (int)result;
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
35560   void * jresult ;
35561   Dali::Toolkit::Builder *result = 0 ;
35562
35563   {
35564     try {
35565       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
35566     } CALL_CATCH_EXCEPTION(0);
35567   }
35568
35569   jresult = (void *)result;
35570   return jresult;
35571 }
35572
35573
35574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
35575   void * jresult ;
35576   Dali::Toolkit::Builder result;
35577
35578   {
35579     try {
35580       result = Dali::Toolkit::Builder::New();
35581     } CALL_CATCH_EXCEPTION(0);
35582   }
35583
35584   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
35585   return jresult;
35586 }
35587
35588
35589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
35590   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35591
35592   arg1 = (Dali::Toolkit::Builder *)jarg1;
35593   {
35594     try {
35595       delete arg1;
35596     } CALL_CATCH_EXCEPTION();
35597   }
35598
35599 }
35600
35601
35602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
35603   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35604   std::string *arg2 = 0 ;
35605   Dali::Toolkit::Builder::UIFormat arg3 ;
35606
35607   arg1 = (Dali::Toolkit::Builder *)jarg1;
35608   if (!jarg2) {
35609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35610     return ;
35611   }
35612   std::string arg2_str(jarg2);
35613   arg2 = &arg2_str;
35614   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
35615   {
35616     try {
35617       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
35618     } CALL_CATCH_EXCEPTION();
35619   }
35620
35621
35622   //argout typemap for const std::string&
35623
35624 }
35625
35626
35627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
35628   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35629   std::string *arg2 = 0 ;
35630
35631   arg1 = (Dali::Toolkit::Builder *)jarg1;
35632   if (!jarg2) {
35633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35634     return ;
35635   }
35636   std::string arg2_str(jarg2);
35637   arg2 = &arg2_str;
35638   {
35639     try {
35640       (arg1)->LoadFromString((std::string const &)*arg2);
35641     } CALL_CATCH_EXCEPTION();
35642   }
35643
35644
35645   //argout typemap for const std::string&
35646
35647 }
35648
35649
35650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
35651   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35652   Dali::Property::Map *arg2 = 0 ;
35653
35654   arg1 = (Dali::Toolkit::Builder *)jarg1;
35655   arg2 = (Dali::Property::Map *)jarg2;
35656   if (!arg2) {
35657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35658     return ;
35659   }
35660   {
35661     try {
35662       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
35663     } CALL_CATCH_EXCEPTION();
35664   }
35665
35666 }
35667
35668
35669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
35670   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35671   std::string *arg2 = 0 ;
35672   Dali::Property::Value *arg3 = 0 ;
35673
35674   arg1 = (Dali::Toolkit::Builder *)jarg1;
35675   if (!jarg2) {
35676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35677     return ;
35678   }
35679   std::string arg2_str(jarg2);
35680   arg2 = &arg2_str;
35681   arg3 = (Dali::Property::Value *)jarg3;
35682   if (!arg3) {
35683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
35684     return ;
35685   }
35686   {
35687     try {
35688       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
35689     } CALL_CATCH_EXCEPTION();
35690   }
35691
35692
35693   //argout typemap for const std::string&
35694
35695 }
35696
35697
35698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
35699   void * jresult ;
35700   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35701   Dali::Property::Map *result = 0 ;
35702
35703   arg1 = (Dali::Toolkit::Builder *)jarg1;
35704   {
35705     try {
35706       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
35707     } CALL_CATCH_EXCEPTION(0);
35708   }
35709
35710   jresult = (void *)result;
35711   return jresult;
35712 }
35713
35714
35715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
35716   void * jresult ;
35717   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35718   std::string *arg2 = 0 ;
35719   Dali::Property::Value *result = 0 ;
35720
35721   arg1 = (Dali::Toolkit::Builder *)jarg1;
35722   if (!jarg2) {
35723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35724     return 0;
35725   }
35726   std::string arg2_str(jarg2);
35727   arg2 = &arg2_str;
35728   {
35729     try {
35730       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
35731     } CALL_CATCH_EXCEPTION(0);
35732   }
35733
35734   jresult = (void *)result;
35735
35736   //argout typemap for const std::string&
35737
35738   return jresult;
35739 }
35740
35741
35742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
35743   void * jresult ;
35744   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35745   std::string *arg2 = 0 ;
35746   Dali::Animation result;
35747
35748   arg1 = (Dali::Toolkit::Builder *)jarg1;
35749   if (!jarg2) {
35750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35751     return 0;
35752   }
35753   std::string arg2_str(jarg2);
35754   arg2 = &arg2_str;
35755   {
35756     try {
35757       result = (arg1)->CreateAnimation((std::string const &)*arg2);
35758     } CALL_CATCH_EXCEPTION(0);
35759   }
35760
35761   jresult = new Dali::Animation((const Dali::Animation &)result);
35762
35763   //argout typemap for const std::string&
35764
35765   return jresult;
35766 }
35767
35768
35769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35770   void * jresult ;
35771   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35772   std::string *arg2 = 0 ;
35773   Dali::Property::Map *arg3 = 0 ;
35774   Dali::Animation result;
35775
35776   arg1 = (Dali::Toolkit::Builder *)jarg1;
35777   if (!jarg2) {
35778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35779     return 0;
35780   }
35781   std::string arg2_str(jarg2);
35782   arg2 = &arg2_str;
35783   arg3 = (Dali::Property::Map *)jarg3;
35784   if (!arg3) {
35785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35786     return 0;
35787   }
35788   {
35789     try {
35790       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35791     } CALL_CATCH_EXCEPTION(0);
35792   }
35793
35794   jresult = new Dali::Animation((const Dali::Animation &)result);
35795
35796   //argout typemap for const std::string&
35797
35798   return jresult;
35799 }
35800
35801
35802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
35803   void * jresult ;
35804   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35805   std::string *arg2 = 0 ;
35806   Dali::Actor arg3 ;
35807   Dali::Actor *argp3 ;
35808   Dali::Animation result;
35809
35810   arg1 = (Dali::Toolkit::Builder *)jarg1;
35811   if (!jarg2) {
35812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35813     return 0;
35814   }
35815   std::string arg2_str(jarg2);
35816   arg2 = &arg2_str;
35817   argp3 = (Dali::Actor *)jarg3;
35818   if (!argp3) {
35819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35820     return 0;
35821   }
35822   arg3 = *argp3;
35823   {
35824     try {
35825       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
35826     } CALL_CATCH_EXCEPTION(0);
35827   }
35828
35829   jresult = new Dali::Animation((const Dali::Animation &)result);
35830
35831   //argout typemap for const std::string&
35832
35833   return jresult;
35834 }
35835
35836
35837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
35838   void * jresult ;
35839   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35840   std::string *arg2 = 0 ;
35841   Dali::Property::Map *arg3 = 0 ;
35842   Dali::Actor arg4 ;
35843   Dali::Actor *argp4 ;
35844   Dali::Animation result;
35845
35846   arg1 = (Dali::Toolkit::Builder *)jarg1;
35847   if (!jarg2) {
35848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35849     return 0;
35850   }
35851   std::string arg2_str(jarg2);
35852   arg2 = &arg2_str;
35853   arg3 = (Dali::Property::Map *)jarg3;
35854   if (!arg3) {
35855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35856     return 0;
35857   }
35858   argp4 = (Dali::Actor *)jarg4;
35859   if (!argp4) {
35860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35861     return 0;
35862   }
35863   arg4 = *argp4;
35864   {
35865     try {
35866       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
35867     } CALL_CATCH_EXCEPTION(0);
35868   }
35869
35870   jresult = new Dali::Animation((const Dali::Animation &)result);
35871
35872   //argout typemap for const std::string&
35873
35874   return jresult;
35875 }
35876
35877
35878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
35879   void * jresult ;
35880   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35881   std::string *arg2 = 0 ;
35882   Dali::BaseHandle result;
35883
35884   arg1 = (Dali::Toolkit::Builder *)jarg1;
35885   if (!jarg2) {
35886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35887     return 0;
35888   }
35889   std::string arg2_str(jarg2);
35890   arg2 = &arg2_str;
35891   {
35892     try {
35893       result = (arg1)->Create((std::string const &)*arg2);
35894     } CALL_CATCH_EXCEPTION(0);
35895   }
35896
35897   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35898
35899   //argout typemap for const std::string&
35900
35901   return jresult;
35902 }
35903
35904
35905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35906   void * jresult ;
35907   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35908   std::string *arg2 = 0 ;
35909   Dali::Property::Map *arg3 = 0 ;
35910   Dali::BaseHandle result;
35911
35912   arg1 = (Dali::Toolkit::Builder *)jarg1;
35913   if (!jarg2) {
35914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35915     return 0;
35916   }
35917   std::string arg2_str(jarg2);
35918   arg2 = &arg2_str;
35919   arg3 = (Dali::Property::Map *)jarg3;
35920   if (!arg3) {
35921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35922     return 0;
35923   }
35924   {
35925     try {
35926       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35927     } CALL_CATCH_EXCEPTION(0);
35928   }
35929
35930   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35931
35932   //argout typemap for const std::string&
35933
35934   return jresult;
35935 }
35936
35937
35938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35939   void * jresult ;
35940   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35941   std::string *arg2 = 0 ;
35942   Dali::BaseHandle result;
35943
35944   arg1 = (Dali::Toolkit::Builder *)jarg1;
35945   if (!jarg2) {
35946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35947     return 0;
35948   }
35949   std::string arg2_str(jarg2);
35950   arg2 = &arg2_str;
35951   {
35952     try {
35953       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35954     } CALL_CATCH_EXCEPTION(0);
35955   }
35956
35957   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35958
35959   //argout typemap for const std::string&
35960
35961   return jresult;
35962 }
35963
35964
35965 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35966   bool jresult ;
35967   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35968   std::string *arg2 = 0 ;
35969   Dali::Handle *arg3 = 0 ;
35970   bool result;
35971
35972   arg1 = (Dali::Toolkit::Builder *)jarg1;
35973   if (!jarg2) {
35974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35975     return 0;
35976   }
35977   std::string arg2_str(jarg2);
35978   arg2 = &arg2_str;
35979   arg3 = (Dali::Handle *)jarg3;
35980   if (!arg3) {
35981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35982     return 0;
35983   }
35984   {
35985     try {
35986       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35987     } CALL_CATCH_EXCEPTION(0);
35988   }
35989
35990   jresult = result;
35991
35992   //argout typemap for const std::string&
35993
35994   return jresult;
35995 }
35996
35997
35998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35999   bool jresult ;
36000   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36001   Dali::Handle *arg2 = 0 ;
36002   std::string *arg3 = 0 ;
36003   bool result;
36004
36005   arg1 = (Dali::Toolkit::Builder *)jarg1;
36006   arg2 = (Dali::Handle *)jarg2;
36007   if (!arg2) {
36008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
36009     return 0;
36010   }
36011   if (!jarg3) {
36012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36013     return 0;
36014   }
36015   std::string arg3_str(jarg3);
36016   arg3 = &arg3_str;
36017   {
36018     try {
36019       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
36020     } CALL_CATCH_EXCEPTION(0);
36021   }
36022
36023   jresult = result;
36024
36025   //argout typemap for const std::string&
36026
36027   return jresult;
36028 }
36029
36030
36031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
36032   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36033   Dali::Actor arg2 ;
36034   Dali::Actor *argp2 ;
36035
36036   arg1 = (Dali::Toolkit::Builder *)jarg1;
36037   argp2 = (Dali::Actor *)jarg2;
36038   if (!argp2) {
36039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36040     return ;
36041   }
36042   arg2 = *argp2;
36043   {
36044     try {
36045       (arg1)->AddActors(arg2);
36046     } CALL_CATCH_EXCEPTION();
36047   }
36048
36049 }
36050
36051
36052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
36053   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36054   std::string *arg2 = 0 ;
36055   Dali::Actor arg3 ;
36056   Dali::Actor *argp3 ;
36057
36058   arg1 = (Dali::Toolkit::Builder *)jarg1;
36059   if (!jarg2) {
36060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36061     return ;
36062   }
36063   std::string arg2_str(jarg2);
36064   arg2 = &arg2_str;
36065   argp3 = (Dali::Actor *)jarg3;
36066   if (!argp3) {
36067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
36068     return ;
36069   }
36070   arg3 = *argp3;
36071   {
36072     try {
36073       (arg1)->AddActors((std::string const &)*arg2,arg3);
36074     } CALL_CATCH_EXCEPTION();
36075   }
36076
36077
36078   //argout typemap for const std::string&
36079
36080 }
36081
36082
36083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
36084   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36085   std::string *arg2 = 0 ;
36086
36087   arg1 = (Dali::Toolkit::Builder *)jarg1;
36088   if (!jarg2) {
36089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36090     return ;
36091   }
36092   std::string arg2_str(jarg2);
36093   arg2 = &arg2_str;
36094   {
36095     try {
36096       (arg1)->CreateRenderTask((std::string const &)*arg2);
36097     } CALL_CATCH_EXCEPTION();
36098   }
36099
36100
36101   //argout typemap for const std::string&
36102
36103 }
36104
36105
36106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
36107   void * jresult ;
36108   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36109   std::string *arg2 = 0 ;
36110   Dali::Path result;
36111
36112   arg1 = (Dali::Toolkit::Builder *)jarg1;
36113   if (!jarg2) {
36114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36115     return 0;
36116   }
36117   std::string arg2_str(jarg2);
36118   arg2 = &arg2_str;
36119   {
36120     try {
36121       result = (arg1)->GetPath((std::string const &)*arg2);
36122     } CALL_CATCH_EXCEPTION(0);
36123   }
36124
36125   jresult = new Dali::Path((const Dali::Path &)result);
36126
36127   //argout typemap for const std::string&
36128
36129   return jresult;
36130 }
36131
36132
36133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
36134   void * jresult ;
36135   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36136   std::string *arg2 = 0 ;
36137   Dali::PathConstrainer result;
36138
36139   arg1 = (Dali::Toolkit::Builder *)jarg1;
36140   if (!jarg2) {
36141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36142     return 0;
36143   }
36144   std::string arg2_str(jarg2);
36145   arg2 = &arg2_str;
36146   {
36147     try {
36148       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
36149     } CALL_CATCH_EXCEPTION(0);
36150   }
36151
36152   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
36153
36154   //argout typemap for const std::string&
36155
36156   return jresult;
36157 }
36158
36159
36160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
36161   void * jresult ;
36162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36163   std::string *arg2 = 0 ;
36164   Dali::LinearConstrainer result;
36165
36166   arg1 = (Dali::Toolkit::Builder *)jarg1;
36167   if (!jarg2) {
36168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36169     return 0;
36170   }
36171   std::string arg2_str(jarg2);
36172   arg2 = &arg2_str;
36173   {
36174     try {
36175       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
36176     } CALL_CATCH_EXCEPTION(0);
36177   }
36178
36179   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
36180
36181   //argout typemap for const std::string&
36182
36183   return jresult;
36184 }
36185
36186
36187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
36188   void * jresult ;
36189   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
36190   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
36191
36192   arg1 = (Dali::Toolkit::Builder *)jarg1;
36193   {
36194     try {
36195       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
36196     } CALL_CATCH_EXCEPTION(0);
36197   }
36198
36199   jresult = (void *)result;
36200   return jresult;
36201 }
36202
36203
36204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
36205   void * jresult ;
36206   Dali::Toolkit::TransitionData *result = 0 ;
36207
36208   {
36209     try {
36210       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
36211     } CALL_CATCH_EXCEPTION(0);
36212   }
36213
36214   jresult = (void *)result;
36215   return jresult;
36216 }
36217
36218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
36219   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36220
36221   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36222   {
36223     try {
36224       delete arg1;
36225     } CALL_CATCH_EXCEPTION();
36226   }
36227
36228 }
36229
36230
36231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
36232   void * jresult ;
36233   Dali::Property::Map *arg1 = 0 ;
36234   Dali::Toolkit::TransitionData result;
36235
36236   arg1 = (Dali::Property::Map *)jarg1;
36237   if (!arg1) {
36238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36239     return 0;
36240   }
36241   {
36242     try {
36243       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
36244     } CALL_CATCH_EXCEPTION(0);
36245   }
36246
36247   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36248   return jresult;
36249 }
36250
36251
36252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
36253   void * jresult ;
36254   Dali::Property::Array *arg1 = 0 ;
36255   Dali::Toolkit::TransitionData result;
36256
36257   arg1 = (Dali::Property::Array *)jarg1;
36258   if (!arg1) {
36259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
36260     return 0;
36261   }
36262   {
36263     try {
36264       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
36265     } CALL_CATCH_EXCEPTION(0);
36266   }
36267
36268   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36269   return jresult;
36270 }
36271
36272
36273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
36274   void * jresult ;
36275   Dali::BaseHandle arg1 ;
36276   Dali::BaseHandle *argp1 ;
36277   Dali::Toolkit::TransitionData result;
36278
36279   argp1 = (Dali::BaseHandle *)jarg1;
36280   if (!argp1) {
36281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36282     return 0;
36283   }
36284   arg1 = *argp1;
36285   {
36286     try {
36287       result = Dali::Toolkit::TransitionData::DownCast(arg1);
36288     } CALL_CATCH_EXCEPTION(0);
36289   }
36290
36291   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
36292   return jresult;
36293 }
36294
36295
36296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
36297   void * jresult ;
36298   Dali::Toolkit::TransitionData *arg1 = 0 ;
36299   Dali::Toolkit::TransitionData *result = 0 ;
36300
36301   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36302   if (!arg1) {
36303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
36304     return 0;
36305   }
36306   {
36307     try {
36308       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
36309     } CALL_CATCH_EXCEPTION(0);
36310   }
36311
36312   jresult = (void *)result;
36313   return jresult;
36314 }
36315
36316
36317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
36318   void * jresult ;
36319   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36320   Dali::Toolkit::TransitionData *arg2 = 0 ;
36321   Dali::Toolkit::TransitionData *result = 0 ;
36322
36323   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36324   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
36325   if (!arg2) {
36326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
36327     return 0;
36328   }
36329   {
36330     try {
36331       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
36332     } CALL_CATCH_EXCEPTION(0);
36333   }
36334
36335   jresult = (void *)result;
36336   return jresult;
36337 }
36338
36339
36340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
36341   unsigned long jresult ;
36342   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36343   size_t result;
36344
36345   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36346   {
36347     try {
36348       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
36349     } CALL_CATCH_EXCEPTION(0);
36350   }
36351
36352   jresult = (unsigned long)result;
36353   return jresult;
36354 }
36355
36356
36357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
36358   void * jresult ;
36359   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
36360   size_t arg2 ;
36361   Dali::Property::Map result;
36362
36363   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
36364   arg2 = (size_t)jarg2;
36365   {
36366     try {
36367       result = (arg1)->GetAnimatorAt(arg2);
36368     } CALL_CATCH_EXCEPTION(0);
36369   }
36370
36371   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
36377   int jresult ;
36378   int result;
36379
36380   {
36381     try {
36382       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
36383     } CALL_CATCH_EXCEPTION(0);
36384   }
36385
36386   jresult = (int)result;
36387   return jresult;
36388 }
36389
36390
36391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
36392   int jresult ;
36393   int result;
36394
36395   {
36396     try {
36397       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
36398     } CALL_CATCH_EXCEPTION(0);
36399   }
36400
36401   jresult = (int)result;
36402   return jresult;
36403 }
36404
36405
36406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
36407   int jresult ;
36408   int result;
36409
36410   {
36411     try {
36412       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
36413     } CALL_CATCH_EXCEPTION(0);
36414   }
36415
36416   jresult = (int)result;
36417   return jresult;
36418 }
36419
36420
36421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
36422   int jresult ;
36423   int result;
36424
36425   {
36426     try {
36427       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
36428     } CALL_CATCH_EXCEPTION(0);
36429   }
36430
36431   jresult = (int)result;
36432   return jresult;
36433 }
36434
36435
36436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
36437   int jresult ;
36438   int result;
36439
36440   {
36441     try {
36442       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
36443     } CALL_CATCH_EXCEPTION(0);
36444   }
36445
36446   jresult = (int)result;
36447   return jresult;
36448 }
36449
36450
36451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
36452   int jresult ;
36453   int result;
36454
36455   {
36456     try {
36457       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
36458     } CALL_CATCH_EXCEPTION(0);
36459   }
36460
36461   jresult = (int)result;
36462   return jresult;
36463 }
36464
36465
36466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
36467   int jresult ;
36468   int result;
36469
36470   {
36471     try {
36472       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
36473     } CALL_CATCH_EXCEPTION(0);
36474   }
36475
36476   jresult = (int)result;
36477   return jresult;
36478 }
36479
36480
36481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
36482   int jresult ;
36483   int result;
36484
36485   {
36486     try {
36487       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
36488     } CALL_CATCH_EXCEPTION(0);
36489   }
36490
36491   jresult = (int)result;
36492   return jresult;
36493 }
36494
36495
36496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
36497   int jresult ;
36498   int result;
36499
36500   {
36501     try {
36502       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
36503     } CALL_CATCH_EXCEPTION(0);
36504   }
36505
36506   jresult = (int)result;
36507   return jresult;
36508 }
36509
36510
36511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
36512   int jresult ;
36513   int result;
36514
36515   {
36516     try {
36517       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
36518     } CALL_CATCH_EXCEPTION(0);
36519   }
36520
36521   jresult = (int)result;
36522   return jresult;
36523 }
36524
36525
36526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
36527   int jresult ;
36528   int result;
36529
36530   {
36531     try {
36532       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
36533     } CALL_CATCH_EXCEPTION(0);
36534   }
36535
36536   jresult = (int)result;
36537   return jresult;
36538 }
36539
36540
36541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
36542   int jresult ;
36543   int result;
36544
36545   {
36546     try {
36547       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
36548     } CALL_CATCH_EXCEPTION(0);
36549   }
36550
36551   jresult = (int)result;
36552   return jresult;
36553 }
36554
36555
36556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
36557   int jresult ;
36558   int result;
36559
36560   {
36561     try {
36562       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
36563     } CALL_CATCH_EXCEPTION(0);
36564   }
36565
36566   jresult = (int)result;
36567   return jresult;
36568 }
36569
36570
36571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
36572   int jresult ;
36573   int result;
36574
36575   {
36576     try {
36577       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
36578     } CALL_CATCH_EXCEPTION(0);
36579   }
36580
36581   jresult = (int)result;
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
36587   void * jresult ;
36588   Dali::Toolkit::Control result;
36589
36590   {
36591     try {
36592       result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
36593     } CALL_CATCH_EXCEPTION(0);
36594   }
36595
36596   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
36597   return jresult;
36598 }
36599
36600
36601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
36602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36603   std::string *arg2 = 0 ;
36604
36605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36606   if (!jarg2) {
36607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
36608     return ;
36609   }
36610   std::string arg2_str(jarg2);
36611   arg2 = &arg2_str;
36612   {
36613     try {
36614       (arg1)->SetStyleName((std::string const &)*arg2);
36615     } CALL_CATCH_EXCEPTION();
36616   }
36617
36618
36619   //argout typemap for const std::string&
36620
36621 }
36622
36623
36624 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
36625   char * jresult ;
36626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36627   std::string *result = 0 ;
36628
36629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36630   {
36631     try {
36632       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
36633     } CALL_CATCH_EXCEPTION(0);
36634   }
36635
36636   jresult = SWIG_csharp_string_callback(result->c_str());
36637   return jresult;
36638 }
36639
36640
36641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
36642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36643   Dali::Vector4 *arg2 = 0 ;
36644
36645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36646   arg2 = (Dali::Vector4 *)jarg2;
36647   if (!arg2) {
36648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
36649     return ;
36650   }
36651   {
36652     try {
36653       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
36654     } CALL_CATCH_EXCEPTION();
36655   }
36656
36657 }
36658
36659
36660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
36661   void * jresult ;
36662   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
36663   Dali::Vector4 result;
36664
36665   arg1 = (Dali::Handle *)jarg1;
36666   {
36667     try {
36668       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
36669       if (resultMap)
36670       {
36671         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
36672         if(type && type->Get<int>() == Visual::COLOR )
36673         {
36674           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
36675           if (value)
36676           {
36677             result = value->Get<Vector4>();
36678           }
36679         }
36680       }
36681     } CALL_CATCH_EXCEPTION(0);
36682   }
36683
36684   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36685   return jresult;
36686 }
36687
36688
36689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
36690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36691   Dali::Property::Map *arg2 = 0 ;
36692
36693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36694   arg2 = (Dali::Property::Map *)jarg2;
36695   if (!arg2) {
36696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
36697     return ;
36698   }
36699   {
36700     try {
36701       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
36702     } CALL_CATCH_EXCEPTION();
36703   }
36704
36705 }
36706
36707
36708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
36709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36710
36711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36712   {
36713     try {
36714       (arg1)->ClearBackground();
36715     } CALL_CATCH_EXCEPTION();
36716   }
36717
36718 }
36719
36720
36721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
36722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36723   Dali::GestureType::Value arg2 ;
36724
36725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36726   arg2 = (Dali::GestureType::Value)jarg2;
36727   {
36728     try {
36729       (arg1)->EnableGestureDetection(arg2);
36730     } CALL_CATCH_EXCEPTION();
36731   }
36732
36733 }
36734
36735
36736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
36737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36738   Dali::GestureType::Value arg2 ;
36739
36740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36741   arg2 = (Dali::GestureType::Value)jarg2;
36742   {
36743     try {
36744       (arg1)->DisableGestureDetection(arg2);
36745     } CALL_CATCH_EXCEPTION();
36746   }
36747
36748 }
36749
36750
36751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
36752   void * jresult ;
36753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36754   Dali::PinchGestureDetector result;
36755
36756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36757   {
36758     try {
36759       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
36760     } CALL_CATCH_EXCEPTION(0);
36761   }
36762
36763   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36764   return jresult;
36765 }
36766
36767
36768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
36769   void * jresult ;
36770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36771   Dali::PanGestureDetector result;
36772
36773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36774   {
36775     try {
36776       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
36777     } CALL_CATCH_EXCEPTION(0);
36778   }
36779
36780   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
36781   return jresult;
36782 }
36783
36784
36785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
36786   void * jresult ;
36787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36788   Dali::TapGestureDetector result;
36789
36790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36791   {
36792     try {
36793       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
36794     } CALL_CATCH_EXCEPTION(0);
36795   }
36796
36797   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36798   return jresult;
36799 }
36800
36801
36802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
36803   void * jresult ;
36804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36805   Dali::LongPressGestureDetector result;
36806
36807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36808   {
36809     try {
36810       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
36811     } CALL_CATCH_EXCEPTION(0);
36812   }
36813
36814   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) {
36820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36821   bool arg2 ;
36822
36823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36824   arg2 = jarg2 ? true : false;
36825   {
36826     try {
36827       (arg1)->SetKeyboardNavigationSupport(arg2);
36828     } CALL_CATCH_EXCEPTION();
36829   }
36830
36831 }
36832
36833
36834 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
36835   bool jresult ;
36836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36837   bool result;
36838
36839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36840   {
36841     try {
36842       result = (bool)(arg1)->IsKeyboardNavigationSupported();
36843     } CALL_CATCH_EXCEPTION(0);
36844   }
36845
36846   jresult = result;
36847   return jresult;
36848 }
36849
36850
36851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
36852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36853
36854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36855   {
36856     try {
36857       (arg1)->SetKeyInputFocus();
36858     } CALL_CATCH_EXCEPTION();
36859   }
36860
36861 }
36862
36863
36864 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
36865   bool jresult ;
36866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36867   bool result;
36868
36869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36870   {
36871     try {
36872       result = (bool)(arg1)->HasKeyInputFocus();
36873     } CALL_CATCH_EXCEPTION(0);
36874   }
36875
36876   jresult = result;
36877   return jresult;
36878 }
36879
36880
36881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
36882   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36883
36884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36885   {
36886     try {
36887       (arg1)->ClearKeyInputFocus();
36888     } CALL_CATCH_EXCEPTION();
36889   }
36890
36891 }
36892
36893
36894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) {
36895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36896   bool arg2 ;
36897
36898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36899   arg2 = jarg2 ? true : false;
36900   {
36901     try {
36902       (arg1)->SetAsKeyboardFocusGroup(arg2);
36903     } CALL_CATCH_EXCEPTION();
36904   }
36905
36906 }
36907
36908
36909 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
36910   bool jresult ;
36911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36912   bool result;
36913
36914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36915   {
36916     try {
36917       result = (bool)(arg1)->IsKeyboardFocusGroup();
36918     } CALL_CATCH_EXCEPTION(0);
36919   }
36920
36921   jresult = result;
36922   return jresult;
36923 }
36924
36925
36926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
36927   void * jresult ;
36928   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36929   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
36930
36931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36932   {
36933     try {
36934       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36935     } CALL_CATCH_EXCEPTION(0);
36936   }
36937
36938   jresult = (void *)result;
36939   return jresult;
36940 }
36941
36942
36943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36944   void * jresult ;
36945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36946   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36947
36948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36949   {
36950     try {
36951       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36952     } CALL_CATCH_EXCEPTION(0);
36953   }
36954
36955   jresult = (void *)result;
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
36961   void * jresult ;
36962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36963   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36964
36965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36966   {
36967     try {
36968       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36969     } CALL_CATCH_EXCEPTION(0);
36970   }
36971
36972   jresult = (void *)result;
36973   return jresult;
36974 }
36975
36976
36977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36979   int arg2 ;
36980   SwigDirector_ViewImpl *darg = 0;
36981
36982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36983   arg2 = (int)jarg2;
36984   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36985   if(!darg) {
36986     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36987     return;
36988   }
36989   {
36990     try {
36991       if(darg) {
36992         (darg)->OnSceneConnection(arg2);
36993       }
36994     } CALL_CATCH_EXCEPTION();
36995   }
36996
36997 }
36998
36999
37000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
37001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37002   int arg2 ;
37003   SwigDirector_ViewImpl *darg = 0;
37004
37005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37006   arg2 = (int)jarg2;
37007   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37008   if(!darg) {
37009     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37010     return;
37011   }
37012   {
37013     try {
37014       if(darg) {
37015         (darg)->OnSceneConnectionSwigPublic(arg2);
37016       }
37017     } CALL_CATCH_EXCEPTION();
37018   }
37019
37020 }
37021
37022
37023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
37024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37025   SwigDirector_ViewImpl *darg = 0;
37026
37027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37029   if(!darg) {
37030     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37031     return;
37032   }
37033   {
37034     try {
37035       if(darg) {
37036         (darg)->OnSceneDisconnection();
37037       }
37038     } CALL_CATCH_EXCEPTION();
37039   }
37040
37041 }
37042
37043
37044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
37045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37046   SwigDirector_ViewImpl *darg = 0;
37047
37048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37049   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37050   if(!darg) {
37051     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37052     return;
37053   }
37054   {
37055     try {
37056       if(darg) {
37057         (darg)->OnSceneDisconnectionSwigPublic();
37058       }
37059     } CALL_CATCH_EXCEPTION();
37060   }
37061
37062 }
37063
37064
37065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
37066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37067   Dali::Actor *arg2 = 0 ;
37068   SwigDirector_ViewImpl *darg = 0;
37069
37070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37071   arg2 = (Dali::Actor *)jarg2;
37072   if (!arg2) {
37073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37074     return ;
37075   }
37076   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37077   if(!darg) {
37078     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37079     return;
37080   }
37081   {
37082     try {
37083       if(darg) {
37084         (darg)->OnChildAdd(*arg2);
37085       }
37086     } CALL_CATCH_EXCEPTION();
37087   }
37088
37089 }
37090
37091
37092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37094   Dali::Actor *arg2 = 0 ;
37095   SwigDirector_ViewImpl *darg = 0;
37096
37097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37098   arg2 = (Dali::Actor *)jarg2;
37099   if (!arg2) {
37100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37101     return ;
37102   }
37103   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37104   if(!darg) {
37105     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37106     return;
37107   }
37108   {
37109     try {
37110       if(darg) {
37111           (darg)->OnChildAddSwigPublic(*arg2);
37112       }
37113     } CALL_CATCH_EXCEPTION();
37114   }
37115
37116 }
37117
37118
37119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
37120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37121   Dali::Actor *arg2 = 0 ;
37122   SwigDirector_ViewImpl *darg = 0;
37123
37124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37125   arg2 = (Dali::Actor *)jarg2;
37126   if (!arg2) {
37127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37128     return ;
37129   }
37130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37131   if(!darg) {
37132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37133     return;
37134   }
37135   {
37136     try {
37137       if(darg) {
37138         (darg)->OnChildRemove(*arg2);
37139       }
37140     } CALL_CATCH_EXCEPTION();
37141   }
37142
37143 }
37144
37145
37146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37148   Dali::Actor *arg2 = 0 ;
37149   SwigDirector_ViewImpl *darg = 0;
37150
37151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37152   arg2 = (Dali::Actor *)jarg2;
37153   if (!arg2) {
37154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37155     return ;
37156   }
37157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37158   if(!darg) {
37159     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37160     return;
37161   }
37162   {
37163     try {
37164       if(darg) {
37165         (darg)->OnChildRemoveSwigPublic(*arg2);
37166       }
37167     } CALL_CATCH_EXCEPTION();
37168   }
37169
37170 }
37171
37172
37173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
37174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37175   Dali::Property::Index arg2 ;
37176   Dali::Property::Value arg3 ;
37177   Dali::Property::Value *argp3 ;
37178   SwigDirector_ViewImpl *darg = 0;
37179
37180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37181   arg2 = (Dali::Property::Index)jarg2;
37182   argp3 = (Dali::Property::Value *)jarg3;
37183   if (!argp3) {
37184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37185     return ;
37186   }
37187   arg3 = *argp3;
37188   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37189   if (!darg) {
37190     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37191     return;
37192   }
37193   {
37194     try {
37195       (darg)->OnPropertySet(arg2,arg3);
37196     } CALL_CATCH_EXCEPTION();
37197   }
37198
37199 }
37200
37201
37202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
37203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37204   Dali::Vector3 *arg2 = 0 ;
37205   SwigDirector_ViewImpl *darg = 0;
37206
37207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37208   arg2 = (Dali::Vector3 *)jarg2;
37209   if (!arg2) {
37210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37211     return ;
37212   }
37213   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37214   if (!darg) {
37215     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37216     return;
37217   }
37218   {
37219     try {
37220       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
37221     } CALL_CATCH_EXCEPTION();
37222   }
37223
37224 }
37225
37226
37227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37229   Dali::Vector3 *arg2 = 0 ;
37230   SwigDirector_ViewImpl *darg = 0;
37231
37232   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37233   arg2 = (Dali::Vector3 *)jarg2;
37234   if (!arg2) {
37235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37236     return ;
37237   }
37238   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37239   if (!darg) {
37240     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37241     return;
37242   }
37243   {
37244     try {
37245       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
37246     } CALL_CATCH_EXCEPTION();
37247   }
37248
37249 }
37250
37251
37252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
37253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37254   Dali::Animation *arg2 = 0 ;
37255   Dali::Vector3 *arg3 = 0 ;
37256   SwigDirector_ViewImpl *darg = 0;
37257
37258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37259   arg2 = (Dali::Animation *)jarg2;
37260   if (!arg2) {
37261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
37262     return ;
37263   }
37264   arg3 = (Dali::Vector3 *)jarg3;
37265   if (!arg3) {
37266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37267     return ;
37268   }
37269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37270   if (!darg) {
37271     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37272     return;
37273   }
37274   {
37275     try {
37276       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
37277     } CALL_CATCH_EXCEPTION();
37278   }
37279
37280 }
37281
37282
37283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37285   Dali::Animation *arg2 = 0 ;
37286   Dali::Vector3 *arg3 = 0 ;
37287   SwigDirector_ViewImpl *darg = 0;
37288
37289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37290   arg2 = (Dali::Animation *)jarg2;
37291   if (!arg2) {
37292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
37293     return ;
37294   }
37295   arg3 = (Dali::Vector3 *)jarg3;
37296   if (!arg3) {
37297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37298     return ;
37299   }
37300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37301   if (!darg) {
37302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37303     return;
37304   }
37305   {
37306     try {
37307       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
37308     } CALL_CATCH_EXCEPTION();
37309   }
37310 }
37311
37312 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
37313   bool jresult ;
37314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37315   Dali::KeyEvent *arg2 = 0 ;
37316   SwigDirector_ViewImpl *darg = 0;
37317   bool result;
37318
37319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37320   arg2 = (Dali::KeyEvent *)jarg2;
37321   if (!arg2) {
37322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
37323     return 0;
37324   }
37325   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37326   if (!darg) {
37327     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37328     return 0;
37329   }
37330   {
37331     try {
37332       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
37333     } CALL_CATCH_EXCEPTION(0);
37334   }
37335
37336   jresult = result;
37337   return jresult;
37338 }
37339
37340
37341 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37342   bool jresult ;
37343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37344   Dali::KeyEvent *arg2 = 0 ;
37345   SwigDirector_ViewImpl *darg = 0;
37346   bool result;
37347
37348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37349   arg2 = (Dali::KeyEvent *)jarg2;
37350   if (!arg2) {
37351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
37352     return 0;
37353   }
37354   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37355   if (!darg) {
37356     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37357     return 0;
37358   }
37359   {
37360     try {
37361       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
37362     } CALL_CATCH_EXCEPTION(0);
37363   }
37364
37365   jresult = result;
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
37371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37372   Dali::Vector2 *arg2 = 0 ;
37373   Dali::RelayoutContainer *arg3 = 0 ;
37374   SwigDirector_ViewImpl *darg = 0;
37375
37376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37377   arg2 = (Dali::Vector2 *)jarg2;
37378   if (!arg2) {
37379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37380     return ;
37381   }
37382   arg3 = (Dali::RelayoutContainer *)jarg3;
37383   if (!arg3) {
37384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
37385     return ;
37386   }
37387   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37388   if (!darg) {
37389     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37390     return;
37391   }
37392   {
37393     try {
37394       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
37395     } CALL_CATCH_EXCEPTION();
37396   }
37397
37398 }
37399
37400
37401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37403   Dali::Vector2 *arg2 = 0 ;
37404   Dali::RelayoutContainer *arg3 = 0 ;
37405   SwigDirector_ViewImpl *darg = 0;
37406
37407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37408   arg2 = (Dali::Vector2 *)jarg2;
37409   if (!arg2) {
37410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37411     return ;
37412   }
37413   arg3 = (Dali::RelayoutContainer *)jarg3;
37414   if (!arg3) {
37415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
37416     return ;
37417   }
37418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37419   if (!darg) {
37420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37421     return;
37422   }
37423   {
37424     try {
37425       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
37426     } CALL_CATCH_EXCEPTION();
37427   }
37428
37429 }
37430
37431
37432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
37433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37434   Dali::ResizePolicy::Type arg2 ;
37435   Dali::Dimension::Type arg3 ;
37436   SwigDirector_ViewImpl *darg = 0;
37437
37438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37439   arg2 = (Dali::ResizePolicy::Type)jarg2;
37440   arg3 = (Dali::Dimension::Type)jarg3;
37441   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37442   if (!darg) {
37443     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37444     return;
37445   }
37446   {
37447     try {
37448       (darg)->OnSetResizePolicy(arg2,arg3);
37449     } CALL_CATCH_EXCEPTION();
37450   }
37451
37452 }
37453
37454
37455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
37456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37457   Dali::ResizePolicy::Type arg2 ;
37458   Dali::Dimension::Type arg3 ;
37459   SwigDirector_ViewImpl *darg = 0;
37460
37461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37462   arg2 = (Dali::ResizePolicy::Type)jarg2;
37463   arg3 = (Dali::Dimension::Type)jarg3;
37464   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37465   if (!darg) {
37466     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37467     return;
37468   }
37469   {
37470     try {
37471       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
37472     } CALL_CATCH_EXCEPTION();
37473   }
37474
37475 }
37476
37477
37478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
37479   void * jresult ;
37480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37481   SwigDirector_ViewImpl *darg = 0;
37482   Dali::Vector3 result;
37483
37484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37485   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37486   if (!darg) {
37487     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37488     return 0;
37489   }
37490   {
37491     try {
37492       result = (darg)->GetNaturalSize();
37493     } CALL_CATCH_EXCEPTION(0);
37494   }
37495
37496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
37497   return jresult;
37498 }
37499
37500
37501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
37502   void * jresult ;
37503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37504   SwigDirector_ViewImpl *darg = 0;
37505   Dali::Vector3 result;
37506
37507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37508   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37509   if (!darg) {
37510     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37511     return 0;
37512   }
37513   {
37514     try {
37515       result = (darg)->GetNaturalSizeSwigPublic();
37516     } CALL_CATCH_EXCEPTION(0);
37517   }
37518
37519   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
37520   return jresult;
37521 }
37522
37523
37524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
37525   float jresult ;
37526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37527   Dali::Actor *arg2 = 0 ;
37528   Dali::Dimension::Type arg3 ;
37529   SwigDirector_ViewImpl *darg = 0;
37530   float result;
37531
37532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37533   arg2 = (Dali::Actor *)jarg2;
37534   if (!arg2) {
37535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
37536     return 0;
37537   }
37538   arg3 = (Dali::Dimension::Type)jarg3;
37539   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37540   if (!darg) {
37541     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37542     return 0;
37543   }
37544   {
37545     try {
37546       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
37547     } CALL_CATCH_EXCEPTION(0);
37548   }
37549
37550   jresult = result;
37551   return jresult;
37552 }
37553
37554
37555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37556   float jresult ;
37557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37558   Dali::Actor *arg2 = 0 ;
37559   Dali::Dimension::Type arg3 ;
37560   SwigDirector_ViewImpl *darg = 0;
37561   float result;
37562
37563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37564   arg2 = (Dali::Actor *)jarg2;
37565   if (!arg2) {
37566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
37567     return 0;
37568   }
37569   arg3 = (Dali::Dimension::Type)jarg3;
37570   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37571   if (!darg) {
37572     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37573     return 0;
37574   }
37575   {
37576     try {
37577       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
37578     } CALL_CATCH_EXCEPTION(0);
37579   }
37580
37581   jresult = result;
37582   return jresult;
37583 }
37584
37585
37586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
37587   float jresult ;
37588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37589   float arg2 ;
37590   SwigDirector_ViewImpl *darg = 0;
37591   float result;
37592
37593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37594   arg2 = (float)jarg2;
37595   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37596   if (!darg) {
37597     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37598     return 0;
37599   }
37600   {
37601     try {
37602       result = (float)(darg)->GetHeightForWidth(arg2);
37603     } CALL_CATCH_EXCEPTION(0);
37604   }
37605
37606   jresult = result;
37607   return jresult;
37608 }
37609
37610
37611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
37612   float jresult ;
37613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37614   float arg2 ;
37615   SwigDirector_ViewImpl *darg = 0;
37616   float result;
37617
37618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37619   arg2 = (float)jarg2;
37620   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37621   if (!darg) {
37622     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37623     return 0;
37624   }
37625   {
37626     try {
37627       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
37628     } CALL_CATCH_EXCEPTION(0);
37629   }
37630
37631   jresult = result;
37632   return jresult;
37633 }
37634
37635
37636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
37637   float jresult ;
37638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37639   float arg2 ;
37640   SwigDirector_ViewImpl *darg = 0;
37641   float result;
37642
37643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37644   arg2 = (float)jarg2;
37645   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37646   if (!darg) {
37647     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37648     return 0;
37649   }
37650   {
37651     try {
37652       result = (float)(darg)->GetWidthForHeight(arg2);
37653     } CALL_CATCH_EXCEPTION(0);
37654   }
37655
37656   jresult = result;
37657   return jresult;
37658 }
37659
37660
37661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
37662   float jresult ;
37663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37664   float arg2 ;
37665   SwigDirector_ViewImpl *darg = 0;
37666   float result;
37667
37668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37669   arg2 = (float)jarg2;
37670   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37671   if (!darg) {
37672     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37673     return 0;
37674   }
37675   {
37676     try {
37677       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
37678     } CALL_CATCH_EXCEPTION(0);
37679   }
37680
37681   jresult = result;
37682   return jresult;
37683 }
37684
37685
37686 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
37687   bool jresult ;
37688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37689   Dali::Dimension::Type arg2 ;
37690   SwigDirector_ViewImpl *darg = 0;
37691   bool result;
37692
37693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37694   arg2 = (Dali::Dimension::Type)jarg2;
37695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37696   if (!darg) {
37697     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37698     return 0;
37699   }
37700   {
37701     try {
37702       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
37703     } CALL_CATCH_EXCEPTION(0);
37704   }
37705
37706   jresult = result;
37707   return jresult;
37708 }
37709
37710
37711 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
37712   bool jresult ;
37713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37714   Dali::Dimension::Type arg2 ;
37715   SwigDirector_ViewImpl *darg = 0;
37716   bool result;
37717
37718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37719   arg2 = (Dali::Dimension::Type)jarg2;
37720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37721   if (!darg) {
37722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37723     return 0;
37724   }
37725   {
37726     try {
37727       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
37728     } CALL_CATCH_EXCEPTION(0);
37729   }
37730
37731   jresult = result;
37732   return jresult;
37733 }
37734
37735
37736 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
37737   bool jresult ;
37738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37739   SwigDirector_ViewImpl *darg = 0;
37740   bool result;
37741
37742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37744   if (!darg) {
37745     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37746     return 0;
37747   }
37748   {
37749     try {
37750       result = (bool)(darg)->RelayoutDependentOnChildren();
37751     } CALL_CATCH_EXCEPTION(0);
37752   }
37753
37754   jresult = result;
37755   return jresult;
37756 }
37757
37758
37759 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
37760   bool jresult ;
37761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37762   SwigDirector_ViewImpl *darg = 0;
37763   bool result;
37764
37765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37766   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37767   if (!darg) {
37768     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37769     return 0;
37770   }
37771   {
37772     try {
37773       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
37774     } CALL_CATCH_EXCEPTION(0);
37775   }
37776
37777   jresult = result;
37778   return jresult;
37779 }
37780
37781
37782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
37783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37784   Dali::Dimension::Type arg2 ;
37785   SwigDirector_ViewImpl *darg = 0;
37786
37787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37788   arg2 = (Dali::Dimension::Type)jarg2;
37789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37790   if (!darg) {
37791     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37792     return;
37793   }
37794   {
37795     try {
37796       (darg)->OnCalculateRelayoutSize(arg2);
37797     } CALL_CATCH_EXCEPTION();
37798   }
37799
37800 }
37801
37802
37803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
37804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37805   Dali::Dimension::Type arg2 ;
37806   SwigDirector_ViewImpl *darg = 0;
37807
37808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37809   arg2 = (Dali::Dimension::Type)jarg2;
37810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37811   if (!darg) {
37812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37813     return;
37814   }
37815   {
37816     try {
37817       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
37818     } CALL_CATCH_EXCEPTION();
37819   }
37820
37821 }
37822
37823
37824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
37825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37826   float arg2 ;
37827   Dali::Dimension::Type arg3 ;
37828   SwigDirector_ViewImpl *darg = 0;
37829
37830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37831   arg2 = (float)jarg2;
37832   arg3 = (Dali::Dimension::Type)jarg3;
37833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37834   if (!darg) {
37835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37836     return;
37837   }
37838   {
37839     try {
37840       (darg)->OnLayoutNegotiated(arg2,arg3);
37841     } CALL_CATCH_EXCEPTION();
37842   }
37843
37844 }
37845
37846
37847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
37848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37849   float arg2 ;
37850   Dali::Dimension::Type arg3 ;
37851   SwigDirector_ViewImpl *darg = 0;
37852
37853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37854   arg2 = (float)jarg2;
37855   arg3 = (Dali::Dimension::Type)jarg3;
37856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37857   if (!darg) {
37858     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37859     return;
37860   }
37861   {
37862     try {
37863       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
37864     } CALL_CATCH_EXCEPTION();
37865   }
37866
37867 }
37868
37869
37870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
37871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37872
37873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37874   {
37875     try {
37876       (arg1)->OnInitialize();
37877     } CALL_CATCH_EXCEPTION();
37878   }
37879
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
37884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37885
37886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37887   {
37888     try {
37889       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
37890     } CALL_CATCH_EXCEPTION();
37891   }
37892
37893 }
37894
37895
37896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
37897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37898   Dali::Toolkit::StyleManager arg2 ;
37899   Dali::StyleChange::Type arg3 ;
37900   Dali::Toolkit::StyleManager *argp2 ;
37901
37902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37903   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37904   if (!argp2) {
37905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37906     return ;
37907   }
37908   arg2 = *argp2;
37909   arg3 = (Dali::StyleChange::Type)jarg3;
37910   {
37911     try {
37912       (arg1)->OnStyleChange(arg2,arg3);
37913     } CALL_CATCH_EXCEPTION();
37914   }
37915
37916 }
37917
37918
37919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37921   Dali::Toolkit::StyleManager arg2 ;
37922   Dali::StyleChange::Type arg3 ;
37923   Dali::Toolkit::StyleManager *argp2 ;
37924
37925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37926   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37927   if (!argp2) {
37928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37929     return ;
37930   }
37931   arg2 = *argp2;
37932   arg3 = (Dali::StyleChange::Type)jarg3;
37933   {
37934     try {
37935       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37936     } CALL_CATCH_EXCEPTION();
37937   }
37938
37939 }
37940
37941
37942 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37943   bool jresult ;
37944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37945   bool result;
37946
37947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37948   {
37949     try {
37950       result = (bool)(arg1)->OnAccessibilityActivated();
37951     } CALL_CATCH_EXCEPTION(0);
37952   }
37953
37954   jresult = result;
37955   return jresult;
37956 }
37957
37958
37959 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
37960   bool jresult ;
37961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37962   bool result;
37963
37964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37965   {
37966     try {
37967       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
37968     } CALL_CATCH_EXCEPTION(0);
37969   }
37970
37971   jresult = result;
37972   return jresult;
37973 }
37974
37975
37976 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37977   bool jresult ;
37978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37979   Dali::PanGesture arg2 ;
37980   Dali::PanGesture *argp2 ;
37981   bool result;
37982
37983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37984   argp2 = (Dali::PanGesture *)jarg2;
37985   if (!argp2) {
37986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37987     return 0;
37988   }
37989   arg2 = *argp2;
37990   {
37991     try {
37992       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37993     } CALL_CATCH_EXCEPTION(0);
37994   }
37995
37996   jresult = result;
37997   return jresult;
37998 }
37999
38000
38001 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38002   bool jresult ;
38003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38004   Dali::PanGesture arg2 ;
38005   Dali::PanGesture *argp2 ;
38006   bool result;
38007
38008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38009   argp2 = (Dali::PanGesture *)jarg2;
38010   if (!argp2) {
38011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
38012     return 0;
38013   }
38014   arg2 = *argp2;
38015   {
38016     try {
38017       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
38018     } CALL_CATCH_EXCEPTION(0);
38019   }
38020
38021   jresult = result;
38022   return jresult;
38023 }
38024
38025 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) {
38026   bool jresult ;
38027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38028   bool arg2 ;
38029   bool result;
38030
38031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38032   arg2 = jarg2 ? true : false;
38033   {
38034     try {
38035       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
38036     } CALL_CATCH_EXCEPTION(0);
38037   }
38038
38039   jresult = result;
38040   return jresult;
38041 }
38042
38043
38044 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) {
38045   bool jresult ;
38046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38047   bool arg2 ;
38048   bool result;
38049
38050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38051   arg2 = jarg2 ? true : false;
38052   {
38053     try {
38054       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
38055     } CALL_CATCH_EXCEPTION(0);
38056   }
38057
38058   jresult = result;
38059   return jresult;
38060 }
38061
38062
38063 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
38064   bool jresult ;
38065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38066   bool result;
38067
38068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38069   {
38070     try {
38071       result = (bool)(arg1)->OnAccessibilityZoom();
38072     } CALL_CATCH_EXCEPTION(0);
38073   }
38074
38075   jresult = result;
38076   return jresult;
38077 }
38078
38079
38080 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
38081   bool jresult ;
38082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38083   bool result;
38084
38085   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38086   {
38087     try {
38088       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
38089     } CALL_CATCH_EXCEPTION(0);
38090   }
38091
38092   jresult = result;
38093   return jresult;
38094 }
38095
38096
38097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
38098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38099
38100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38101   {
38102     try {
38103       (arg1)->OnKeyInputFocusGained();
38104     } CALL_CATCH_EXCEPTION();
38105   }
38106
38107 }
38108
38109
38110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
38111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38112
38113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38114   {
38115     try {
38116       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
38117     } CALL_CATCH_EXCEPTION();
38118   }
38119
38120 }
38121
38122
38123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
38124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38125
38126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38127   {
38128     try {
38129       (arg1)->OnKeyInputFocusLost();
38130     } CALL_CATCH_EXCEPTION();
38131   }
38132
38133 }
38134
38135
38136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
38137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38138
38139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38140   {
38141     try {
38142       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
38143     } CALL_CATCH_EXCEPTION();
38144   }
38145
38146 }
38147
38148
38149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
38150   void * jresult ;
38151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38152   Dali::Actor arg2 ;
38153   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
38154   bool arg4 ;
38155   Dali::Actor *argp2 ;
38156   Dali::Actor result;
38157
38158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38159   argp2 = (Dali::Actor *)jarg2;
38160   if (!argp2) {
38161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38162     return 0;
38163   }
38164   arg2 = *argp2;
38165   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
38166   arg4 = jarg4 ? true : false;
38167   {
38168     try {
38169       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
38170     } CALL_CATCH_EXCEPTION(0);
38171   }
38172
38173   jresult = new Dali::Actor((const Dali::Actor &)result);
38174   return jresult;
38175 }
38176
38177
38178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) {
38179   void * jresult ;
38180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38181   Dali::Actor arg2 ;
38182   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
38183   bool arg4 ;
38184   Dali::Actor *argp2 ;
38185   Dali::Actor result;
38186
38187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38188   argp2 = (Dali::Actor *)jarg2;
38189   if (!argp2) {
38190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38191     return 0;
38192   }
38193   arg2 = *argp2;
38194   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
38195   arg4 = jarg4 ? true : false;
38196   {
38197     try {
38198       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
38199     } CALL_CATCH_EXCEPTION(0);
38200   }
38201
38202   jresult = new Dali::Actor((const Dali::Actor &)result);
38203   return jresult;
38204 }
38205
38206
38207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
38208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38209   Dali::Actor arg2 ;
38210   Dali::Actor *argp2 ;
38211
38212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38213   argp2 = (Dali::Actor *)jarg2;
38214   if (!argp2) {
38215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38216     return ;
38217   }
38218   arg2 = *argp2;
38219   {
38220     try {
38221       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
38222     } CALL_CATCH_EXCEPTION();
38223   }
38224
38225 }
38226
38227
38228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38230   Dali::Actor arg2 ;
38231   Dali::Actor *argp2 ;
38232
38233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38234   argp2 = (Dali::Actor *)jarg2;
38235   if (!argp2) {
38236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38237     return ;
38238   }
38239   arg2 = *argp2;
38240   {
38241     try {
38242       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
38243     } CALL_CATCH_EXCEPTION();
38244   }
38245
38246 }
38247
38248
38249 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
38250   bool jresult ;
38251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38252   bool result;
38253
38254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38255   {
38256     try {
38257       result = (bool)(arg1)->OnKeyboardEnter();
38258     } CALL_CATCH_EXCEPTION(0);
38259   }
38260
38261   jresult = result;
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
38267   bool jresult ;
38268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38269   bool result;
38270
38271   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38272   {
38273     try {
38274       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
38275     } CALL_CATCH_EXCEPTION(0);
38276   }
38277
38278   jresult = result;
38279   return jresult;
38280 }
38281
38282
38283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
38284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38285   Dali::PinchGesture *arg2 = 0 ;
38286
38287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38288   arg2 = (Dali::PinchGesture *)jarg2;
38289   if (!arg2) {
38290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
38291     return ;
38292   }
38293   {
38294     try {
38295       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
38296     } CALL_CATCH_EXCEPTION();
38297   }
38298
38299 }
38300
38301
38302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38304   Dali::PinchGesture *arg2 = 0 ;
38305
38306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38307   arg2 = (Dali::PinchGesture *)jarg2;
38308   if (!arg2) {
38309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
38310     return ;
38311   }
38312   {
38313     try {
38314       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
38315     } CALL_CATCH_EXCEPTION();
38316   }
38317
38318 }
38319
38320
38321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
38322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38323   Dali::PanGesture *arg2 = 0 ;
38324
38325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38326   arg2 = (Dali::PanGesture *)jarg2;
38327   if (!arg2) {
38328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
38329     return ;
38330   }
38331   {
38332     try {
38333       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
38334     } CALL_CATCH_EXCEPTION();
38335   }
38336
38337 }
38338
38339
38340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38342   Dali::PanGesture *arg2 = 0 ;
38343
38344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38345   arg2 = (Dali::PanGesture *)jarg2;
38346   if (!arg2) {
38347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
38348     return ;
38349   }
38350   {
38351     try {
38352       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
38353     } CALL_CATCH_EXCEPTION();
38354   }
38355
38356 }
38357
38358
38359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
38360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38361   Dali::TapGesture *arg2 = 0 ;
38362
38363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38364   arg2 = (Dali::TapGesture *)jarg2;
38365   if (!arg2) {
38366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
38367     return ;
38368   }
38369   {
38370     try {
38371       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
38372     } CALL_CATCH_EXCEPTION();
38373   }
38374
38375 }
38376
38377
38378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38380   Dali::TapGesture *arg2 = 0 ;
38381
38382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38383   arg2 = (Dali::TapGesture *)jarg2;
38384   if (!arg2) {
38385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
38386     return ;
38387   }
38388   {
38389     try {
38390       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
38391     } CALL_CATCH_EXCEPTION();
38392   }
38393
38394 }
38395
38396
38397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
38398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38399   Dali::LongPressGesture *arg2 = 0 ;
38400
38401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38402   arg2 = (Dali::LongPressGesture *)jarg2;
38403   if (!arg2) {
38404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
38405     return ;
38406   }
38407   {
38408     try {
38409       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
38410     } CALL_CATCH_EXCEPTION();
38411   }
38412
38413 }
38414
38415
38416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
38417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38418   Dali::LongPressGesture *arg2 = 0 ;
38419
38420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38421   arg2 = (Dali::LongPressGesture *)jarg2;
38422   if (!arg2) {
38423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
38424     return ;
38425   }
38426   {
38427     try {
38428       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
38429     } CALL_CATCH_EXCEPTION();
38430   }
38431
38432 }
38433
38434
38435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
38436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38437   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38438   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38439
38440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38441   arg2 = (Dali::SlotObserver *)jarg2;
38442   arg3 = (Dali::CallbackBase *)jarg3;
38443   {
38444     try {
38445       (arg1)->SignalConnected(arg2,arg3);
38446     } CALL_CATCH_EXCEPTION();
38447   }
38448
38449 }
38450
38451
38452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38453   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38454   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38455   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38456
38457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38458   arg2 = (Dali::SlotObserver *)jarg2;
38459   arg3 = (Dali::CallbackBase *)jarg3;
38460   {
38461     try {
38462       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
38463     } CALL_CATCH_EXCEPTION();
38464   }
38465
38466 }
38467
38468
38469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
38470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38471   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38472   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38473
38474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38475   arg2 = (Dali::SlotObserver *)jarg2;
38476   arg3 = (Dali::CallbackBase *)jarg3;
38477   {
38478     try {
38479       (arg1)->SignalDisconnected(arg2,arg3);
38480     } CALL_CATCH_EXCEPTION();
38481   }
38482
38483 }
38484
38485
38486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
38487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
38488   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
38489   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
38490
38491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38492   arg2 = (Dali::SlotObserver *)jarg2;
38493   arg3 = (Dali::CallbackBase *)jarg3;
38494   {
38495     try {
38496       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
38497     } CALL_CATCH_EXCEPTION();
38498   }
38499
38500 }
38501
38502 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) {
38503   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
38504   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
38505   if (director) {
38506     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);
38507   }
38508 }
38509
38510
38511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
38512   void * jresult ;
38513   Dali::Toolkit::Control *arg1 = 0 ;
38514   Dali::Toolkit::Internal::Control *result = 0 ;
38515
38516   arg1 = (Dali::Toolkit::Control *)jarg1;
38517   if (!arg1) {
38518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38519     return 0;
38520   }
38521   {
38522     try {
38523       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
38524     } CALL_CATCH_EXCEPTION(0);
38525   }
38526
38527   jresult = (void *)result;
38528   return jresult;
38529 }
38530
38531
38532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
38533   int jresult ;
38534   int result;
38535
38536   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
38537   jresult = (int)result;
38538   return jresult;
38539 }
38540
38541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
38542   int jresult ;
38543   int result;
38544
38545   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
38546   jresult = (int)result;
38547   return jresult;
38548 }
38549
38550
38551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
38552   int jresult ;
38553   int result;
38554
38555   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
38556   jresult = (int)result;
38557   return jresult;
38558 }
38559
38560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
38561   int jresult ;
38562   int result;
38563
38564   result = (int)Dali::Toolkit::Control::Property::MARGIN;
38565   jresult = (int)result;
38566   return jresult;
38567 }
38568
38569
38570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
38571   int jresult ;
38572   int result;
38573
38574   result = (int)Dali::Toolkit::Control::Property::PADDING;
38575   jresult = (int)result;
38576   return jresult;
38577 }
38578
38579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
38580   int jresult ;
38581   int result;
38582
38583   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
38584   jresult = (int)result;
38585   return jresult;
38586 }
38587
38588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() {
38589   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME;
38590 }
38591
38592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() {
38593   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION;
38594 }
38595
38596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() {
38597   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
38598 }
38599
38600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() {
38601   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE;
38602 }
38603
38604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() {
38605   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE;
38606 }
38607
38608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() {
38609   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES;
38610 }
38611
38612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() {
38613   return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN;
38614 }
38615
38616 SWIGEXPORT int SWIGSTDCALL  CSharp_Dali_View_Property_AUTOMATION_ID_get() {
38617   return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID;
38618 }
38619
38620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
38621   void * jresult ;
38622   Dali::Toolkit::Control::Property *result = 0 ;
38623
38624   {
38625     try {
38626       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
38627     } CALL_CATCH_EXCEPTION(0);
38628   }
38629
38630   jresult = (void *)result;
38631   return jresult;
38632 }
38633
38634
38635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
38636   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
38637
38638   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
38639   {
38640     try {
38641       delete arg1;
38642     } CALL_CATCH_EXCEPTION();
38643   }
38644
38645 }
38646
38647
38648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
38649   void * jresult ;
38650   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
38651
38652   {
38653     try {
38654       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
38655     } CALL_CATCH_EXCEPTION(0);
38656   }
38657
38658   jresult = (void *)result;
38659   return jresult;
38660 }
38661
38662
38663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
38664   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
38665
38666   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
38667   {
38668     try {
38669       delete arg1;
38670     } CALL_CATCH_EXCEPTION();
38671   }
38672
38673 }
38674
38675
38676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
38677   void * jresult ;
38678   Dali::Toolkit::Control result;
38679
38680   {
38681     try {
38682       result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
38683     } CALL_CATCH_EXCEPTION(0);
38684   }
38685
38686   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38687   return jresult;
38688 }
38689
38690
38691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
38692   void * jresult ;
38693   Dali::Toolkit::Control *result = 0 ;
38694
38695   {
38696     try {
38697       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
38698     } CALL_CATCH_EXCEPTION(0);
38699   }
38700
38701   jresult = (void *)result;
38702   return jresult;
38703 }
38704
38705
38706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
38707   void * jresult ;
38708   Dali::Toolkit::Control *arg1 = 0 ;
38709   Dali::Toolkit::Control *result = 0 ;
38710
38711   arg1 = (Dali::Toolkit::Control *)jarg1;
38712   if (!arg1) {
38713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38714     return 0;
38715   }
38716   {
38717     try {
38718       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
38719     } CALL_CATCH_EXCEPTION(0);
38720   }
38721
38722   jresult = (void *)result;
38723   return jresult;
38724 }
38725
38726
38727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
38728   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38729
38730   arg1 = (Dali::Toolkit::Control *)jarg1;
38731   {
38732     try {
38733       delete arg1;
38734     } CALL_CATCH_EXCEPTION();
38735   }
38736
38737 }
38738
38739
38740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
38741   void * jresult ;
38742   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38743   Dali::Toolkit::Control *arg2 = 0 ;
38744   Dali::Toolkit::Control *result = 0 ;
38745
38746   arg1 = (Dali::Toolkit::Control *)jarg1;
38747   arg2 = (Dali::Toolkit::Control *)jarg2;
38748   if (!arg2) {
38749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38750     return 0;
38751   }
38752   {
38753     try {
38754       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
38755     } CALL_CATCH_EXCEPTION(0);
38756   }
38757
38758   jresult = (void *)result;
38759   return jresult;
38760 }
38761
38762
38763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
38764   void * jresult ;
38765   Dali::BaseHandle arg1 ;
38766   Dali::BaseHandle *argp1 ;
38767   Dali::Toolkit::Control result;
38768
38769   argp1 = (Dali::BaseHandle *)jarg1;
38770   if (!argp1) {
38771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38772     return 0;
38773   }
38774   arg1 = *argp1;
38775   {
38776     try {
38777       result = Dali::Toolkit::Control::DownCast(arg1);
38778     } CALL_CATCH_EXCEPTION(0);
38779   }
38780
38781   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38782   return jresult;
38783 }
38784
38785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) {
38786   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1;
38787   try {
38788     delete arg1;
38789   } CALL_CATCH_EXCEPTION();
38790 }
38791
38792
38793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
38794   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38795
38796   arg1 = (Dali::Toolkit::Control *)jarg1;
38797   {
38798     try {
38799       (arg1)->SetKeyInputFocus();
38800     } CALL_CATCH_EXCEPTION();
38801   }
38802
38803 }
38804
38805
38806 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
38807   bool jresult ;
38808   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38809   bool result;
38810
38811   arg1 = (Dali::Toolkit::Control *)jarg1;
38812   {
38813     try {
38814       result = (bool)(arg1)->HasKeyInputFocus();
38815     } CALL_CATCH_EXCEPTION(0);
38816   }
38817
38818   jresult = result;
38819   return jresult;
38820 }
38821
38822
38823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
38824   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38825
38826   arg1 = (Dali::Toolkit::Control *)jarg1;
38827   {
38828     try {
38829       (arg1)->ClearKeyInputFocus();
38830     } CALL_CATCH_EXCEPTION();
38831   }
38832
38833 }
38834
38835
38836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
38837   void * jresult ;
38838   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38839   Dali::PinchGestureDetector result;
38840
38841   arg1 = (Dali::Toolkit::Control *)jarg1;
38842   {
38843     try {
38844       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
38845     } CALL_CATCH_EXCEPTION(0);
38846   }
38847
38848   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38849   return jresult;
38850 }
38851
38852
38853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
38854   void * jresult ;
38855   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38856   Dali::PanGestureDetector result;
38857
38858   arg1 = (Dali::Toolkit::Control *)jarg1;
38859   {
38860     try {
38861       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
38862     } CALL_CATCH_EXCEPTION(0);
38863   }
38864
38865   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38866   return jresult;
38867 }
38868
38869
38870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
38871   void * jresult ;
38872   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38873   Dali::TapGestureDetector result;
38874
38875   arg1 = (Dali::Toolkit::Control *)jarg1;
38876   {
38877     try {
38878       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
38879     } CALL_CATCH_EXCEPTION(0);
38880   }
38881
38882   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38883   return jresult;
38884 }
38885
38886
38887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
38888   void * jresult ;
38889   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38890   Dali::LongPressGestureDetector result;
38891
38892   arg1 = (Dali::Toolkit::Control *)jarg1;
38893   {
38894     try {
38895       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
38896     } CALL_CATCH_EXCEPTION(0);
38897   }
38898
38899   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38900   return jresult;
38901 }
38902
38903
38904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
38905   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38906   std::string *arg2 = 0 ;
38907
38908   arg1 = (Dali::Toolkit::Control *)jarg1;
38909   if (!jarg2) {
38910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38911     return ;
38912   }
38913   std::string arg2_str(jarg2);
38914   arg2 = &arg2_str;
38915   {
38916     try {
38917       (arg1)->SetStyleName((std::string const &)*arg2);
38918     } CALL_CATCH_EXCEPTION();
38919   }
38920
38921
38922   //argout typemap for const std::string&
38923
38924 }
38925
38926
38927 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
38928   char * jresult ;
38929   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38930   std::string *result = 0 ;
38931
38932   arg1 = (Dali::Toolkit::Control *)jarg1;
38933   {
38934     try {
38935       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
38936     } CALL_CATCH_EXCEPTION(0);
38937   }
38938
38939   jresult = SWIG_csharp_string_callback(result->c_str());
38940   return jresult;
38941 }
38942
38943
38944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
38945   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38946   Dali::Vector4 *arg2 = 0 ;
38947
38948   arg1 = (Dali::Toolkit::Control *)jarg1;
38949   arg2 = (Dali::Vector4 *)jarg2;
38950   if (!arg2) {
38951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38952     return ;
38953   }
38954   {
38955     try {
38956       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38957     } CALL_CATCH_EXCEPTION();
38958   }
38959
38960 }
38961
38962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
38963   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38964
38965   arg1 = (Dali::Toolkit::Control *)jarg1;
38966   {
38967     try {
38968       (arg1)->ClearBackground();
38969     } CALL_CATCH_EXCEPTION();
38970   }
38971
38972 }
38973
38974
38975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38976   void * jresult ;
38977   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38978   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38979
38980   arg1 = (Dali::Toolkit::Control *)jarg1;
38981   {
38982     try {
38983       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38984     } CALL_CATCH_EXCEPTION(0);
38985   }
38986
38987   jresult = (void *)result;
38988   return jresult;
38989 }
38990
38991
38992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38993   void * jresult ;
38994   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38995   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38996
38997   arg1 = (Dali::Toolkit::Control *)jarg1;
38998   {
38999     try {
39000       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
39001     } CALL_CATCH_EXCEPTION(0);
39002   }
39003
39004   jresult = (void *)result;
39005   return jresult;
39006 }
39007
39008
39009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
39010   void * jresult ;
39011   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39012   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
39013
39014   arg1 = (Dali::Toolkit::Control *)jarg1;
39015   {
39016     try {
39017       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
39018     } CALL_CATCH_EXCEPTION(0);
39019   }
39020
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
39027   void * jresult ;
39028   Dali::Toolkit::Internal::Control *arg1 = 0 ;
39029   Dali::Toolkit::Control *result = 0 ;
39030
39031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
39032   if (!arg1) {
39033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
39034     return 0;
39035   }
39036   {
39037     try {
39038       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
39039     } CALL_CATCH_EXCEPTION(0);
39040   }
39041
39042   jresult = (void *)result;
39043   return jresult;
39044 }
39045
39046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
39047 {
39048   int jresult;
39049   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39050   arg1 = (Dali::Toolkit::Control *)jarg1;
39051
39052   if (!arg1) {
39053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39054     return 0;
39055   }
39056
39057   Dali::Property::Index arg2 = 0 ;
39058   arg2 = (Dali::Property::Index)jarg2;
39059
39060   Toolkit::Visual::ResourceStatus result;
39061   {
39062     try {
39063       result = arg1->GetVisualResourceStatus(arg2);
39064     } CALL_CATCH_EXCEPTION(0);
39065   }
39066
39067   jresult = (int)result;
39068   return jresult;
39069 }
39070
39071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
39072 {
39073   void * jresult;
39074   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
39075   arg1 = (Dali::Toolkit::Control *)jarg1;
39076
39077   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
39078
39079   Dali::Toolkit::TransitionData *arg2 = 0 ;
39080   Dali::Animation result;
39081
39082   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
39083   if (!arg2) {
39084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
39085     return 0;
39086   }
39087   {
39088     try {
39089       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
39090     } CALL_CATCH_EXCEPTION(0);
39091   }
39092
39093   jresult = new Dali::Animation((const Dali::Animation &)result);
39094   return jresult;
39095 }
39096
39097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
39098 {
39099   Dali::Toolkit::Control arg1;
39100   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
39101
39102   if (!argp1) {
39103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39104   }
39105   arg1 = *argp1;
39106
39107   Dali::Property::Index arg2 = 0 ;
39108   arg2 = (Dali::Property::Index)jarg2;
39109
39110   Dali::Property::Index arg3 = 0 ;
39111   arg3 = (Dali::Property::Index)jarg3;
39112
39113   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
39114
39115   {
39116     try {
39117       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
39118     } CALL_CATCH_EXCEPTION();
39119   }
39120 }
39121
39122 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex)
39123 {
39124   if (!control)
39125   {
39126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0);
39127     return 0;
39128   }
39129
39130   void* result = 0;
39131   try
39132   {
39133     Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex);
39134     result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex);
39135   }
39136   CALL_CATCH_EXCEPTION(0);
39137
39138   return result;
39139 }
39140
39141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
39142   void * jresult ;
39143   Dali::Toolkit::Control *arg1 = 0 ;
39144   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
39145
39146   arg1 = (Dali::Toolkit::Control *)jarg1;
39147   if (!arg1) {
39148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
39149     return 0;
39150   }
39151   {
39152     try {
39153       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
39154     } CALL_CATCH_EXCEPTION(0);
39155   }
39156
39157   jresult = (void *)result;
39158   return jresult;
39159 }
39160
39161
39162 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
39163   bool jresult ;
39164   Dali::Toolkit::Control *arg1 = 0 ;
39165   bool result;
39166
39167   arg1 = (Dali::Toolkit::Control *)jarg1;
39168   if (!arg1) {
39169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
39170     return 0;
39171   }
39172   {
39173     try {
39174       result = (bool)arg1->IsResourceReady();
39175     } CALL_CATCH_EXCEPTION(0);
39176   }
39177
39178   jresult = result;
39179   return jresult;
39180 }
39181
39182
39183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
39184   void * jresult ;
39185   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
39186
39187   {
39188     try {
39189       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
39190     } CALL_CATCH_EXCEPTION(0);
39191   }
39192
39193   jresult = (void *)result;
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
39199   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39200
39201   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39202   {
39203     try {
39204       delete arg1;
39205     } CALL_CATCH_EXCEPTION();
39206   }
39207
39208 }
39209
39210
39211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
39212   void * jresult ;
39213   Dali::Toolkit::KeyInputFocusManager result;
39214
39215   {
39216     try {
39217       result = Dali::Toolkit::KeyInputFocusManager::Get();
39218     } CALL_CATCH_EXCEPTION(0);
39219   }
39220
39221   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
39222   return jresult;
39223 }
39224
39225
39226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
39227   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39228   Dali::Toolkit::Control arg2 ;
39229   Dali::Toolkit::Control *argp2 ;
39230
39231   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39232   argp2 = (Dali::Toolkit::Control *)jarg2;
39233   if (!argp2) {
39234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
39235     return ;
39236   }
39237   arg2 = *argp2;
39238   {
39239     try {
39240       (arg1)->SetFocus(arg2);
39241     } CALL_CATCH_EXCEPTION();
39242   }
39243
39244 }
39245
39246
39247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
39248   void * jresult ;
39249   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39250   Dali::Toolkit::Control result;
39251
39252   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39253   {
39254     try {
39255       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
39256     } CALL_CATCH_EXCEPTION(0);
39257   }
39258
39259   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
39260   return jresult;
39261 }
39262
39263
39264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
39265   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39266   Dali::Toolkit::Control arg2 ;
39267   Dali::Toolkit::Control *argp2 ;
39268
39269   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39270   argp2 = (Dali::Toolkit::Control *)jarg2;
39271   if (!argp2) {
39272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
39273     return ;
39274   }
39275   arg2 = *argp2;
39276   {
39277     try {
39278       (arg1)->RemoveFocus(arg2);
39279     } CALL_CATCH_EXCEPTION();
39280   }
39281
39282 }
39283
39284
39285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
39286   void * jresult ;
39287   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
39288   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
39289
39290   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
39291   {
39292     try {
39293       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
39294     } CALL_CATCH_EXCEPTION(0);
39295   }
39296
39297   jresult = (void *)result;
39298   return jresult;
39299 }
39300
39301
39302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
39303   void * jresult ;
39304   Dali::Toolkit::Alignment::Padding *result = 0 ;
39305
39306   {
39307     try {
39308       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
39309     } CALL_CATCH_EXCEPTION(0);
39310   }
39311
39312   jresult = (void *)result;
39313   return jresult;
39314 }
39315
39316
39317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
39318   void * jresult ;
39319   float arg1 ;
39320   float arg2 ;
39321   float arg3 ;
39322   float arg4 ;
39323   Dali::Toolkit::Alignment::Padding *result = 0 ;
39324
39325   arg1 = (float)jarg1;
39326   arg2 = (float)jarg2;
39327   arg3 = (float)jarg3;
39328   arg4 = (float)jarg4;
39329   {
39330     try {
39331       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
39332     } CALL_CATCH_EXCEPTION(0);
39333   }
39334
39335   jresult = (void *)result;
39336   return jresult;
39337 }
39338
39339
39340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
39341   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39342   float arg2 ;
39343
39344   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39345   arg2 = (float)jarg2;
39346   if (arg1) (arg1)->left = arg2;
39347 }
39348
39349
39350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
39351   float jresult ;
39352   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39353   float result;
39354
39355   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39356   result = (float) ((arg1)->left);
39357   jresult = result;
39358   return jresult;
39359 }
39360
39361
39362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
39363   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39364   float arg2 ;
39365
39366   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39367   arg2 = (float)jarg2;
39368   if (arg1) (arg1)->right = arg2;
39369 }
39370
39371
39372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
39373   float jresult ;
39374   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39375   float result;
39376
39377   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39378   result = (float) ((arg1)->right);
39379   jresult = result;
39380   return jresult;
39381 }
39382
39383
39384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
39385   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39386   float arg2 ;
39387
39388   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39389   arg2 = (float)jarg2;
39390   if (arg1) (arg1)->top = arg2;
39391 }
39392
39393
39394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
39395   float jresult ;
39396   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39397   float result;
39398
39399   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39400   result = (float) ((arg1)->top);
39401   jresult = result;
39402   return jresult;
39403 }
39404
39405
39406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
39407   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39408   float arg2 ;
39409
39410   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39411   arg2 = (float)jarg2;
39412   if (arg1) (arg1)->bottom = arg2;
39413 }
39414
39415
39416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
39417   float jresult ;
39418   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39419   float result;
39420
39421   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39422   result = (float) ((arg1)->bottom);
39423   jresult = result;
39424   return jresult;
39425 }
39426
39427
39428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
39429   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
39430
39431   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
39432   {
39433     try {
39434       delete arg1;
39435     } CALL_CATCH_EXCEPTION();
39436   }
39437
39438 }
39439
39440
39441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
39442   void * jresult ;
39443   Dali::Toolkit::Alignment *result = 0 ;
39444
39445   {
39446     try {
39447       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
39448     } CALL_CATCH_EXCEPTION(0);
39449   }
39450
39451   jresult = (void *)result;
39452   return jresult;
39453 }
39454
39455
39456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
39457   void * jresult ;
39458   Dali::Toolkit::Alignment::Type arg1 ;
39459   Dali::Toolkit::Alignment::Type arg2 ;
39460   Dali::Toolkit::Alignment result;
39461
39462   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
39463   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
39464   {
39465     try {
39466       result = Dali::Toolkit::Alignment::New(arg1,arg2);
39467     } CALL_CATCH_EXCEPTION(0);
39468   }
39469
39470   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
39471   return jresult;
39472 }
39473
39474
39475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
39476   void * jresult ;
39477   Dali::Toolkit::Alignment::Type arg1 ;
39478   Dali::Toolkit::Alignment result;
39479
39480   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
39481   {
39482     try {
39483       result = Dali::Toolkit::Alignment::New(arg1);
39484     } CALL_CATCH_EXCEPTION(0);
39485   }
39486
39487   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
39488   return jresult;
39489 }
39490
39491
39492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
39493   void * jresult ;
39494   Dali::Toolkit::Alignment result;
39495
39496   {
39497     try {
39498       result = Dali::Toolkit::Alignment::New();
39499     } CALL_CATCH_EXCEPTION(0);
39500   }
39501
39502   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
39503   return jresult;
39504 }
39505
39506
39507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
39508   void * jresult ;
39509   Dali::Toolkit::Alignment *arg1 = 0 ;
39510   Dali::Toolkit::Alignment *result = 0 ;
39511
39512   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39513   if (!arg1) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
39515     return 0;
39516   }
39517   {
39518     try {
39519       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
39520     } CALL_CATCH_EXCEPTION(0);
39521   }
39522
39523   jresult = (void *)result;
39524   return jresult;
39525 }
39526
39527
39528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
39529   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39530
39531   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39532   {
39533     try {
39534       delete arg1;
39535     } CALL_CATCH_EXCEPTION();
39536   }
39537
39538 }
39539
39540
39541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
39542   void * jresult ;
39543   Dali::BaseHandle arg1 ;
39544   Dali::BaseHandle *argp1 ;
39545   Dali::Toolkit::Alignment result;
39546
39547   argp1 = (Dali::BaseHandle *)jarg1;
39548   if (!argp1) {
39549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39550     return 0;
39551   }
39552   arg1 = *argp1;
39553   {
39554     try {
39555       result = Dali::Toolkit::Alignment::DownCast(arg1);
39556     } CALL_CATCH_EXCEPTION(0);
39557   }
39558
39559   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
39560   return jresult;
39561 }
39562
39563
39564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
39565   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39566   Dali::Toolkit::Alignment::Type arg2 ;
39567
39568   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39569   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
39570   {
39571     try {
39572       (arg1)->SetAlignmentType(arg2);
39573     } CALL_CATCH_EXCEPTION();
39574   }
39575
39576 }
39577
39578
39579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
39580   int jresult ;
39581   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39582   Dali::Toolkit::Alignment::Type result;
39583
39584   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39585   {
39586     try {
39587       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
39588     } CALL_CATCH_EXCEPTION(0);
39589   }
39590
39591   jresult = (int)result;
39592   return jresult;
39593 }
39594
39595
39596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
39597   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39598   Dali::Toolkit::Alignment::Scaling arg2 ;
39599
39600   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39601   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
39602   {
39603     try {
39604       (arg1)->SetScaling(arg2);
39605     } CALL_CATCH_EXCEPTION();
39606   }
39607
39608 }
39609
39610
39611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
39612   int jresult ;
39613   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39614   Dali::Toolkit::Alignment::Scaling result;
39615
39616   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39617   {
39618     try {
39619       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
39620     } CALL_CATCH_EXCEPTION(0);
39621   }
39622
39623   jresult = (int)result;
39624   return jresult;
39625 }
39626
39627
39628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
39629   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39630   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
39631
39632   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39633   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
39634   if (!arg2) {
39635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
39636     return ;
39637   }
39638   {
39639     try {
39640       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
39641     } CALL_CATCH_EXCEPTION();
39642   }
39643
39644 }
39645
39646
39647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
39648   void * jresult ;
39649   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39650   Dali::Toolkit::Alignment::Padding *result = 0 ;
39651
39652   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39653   {
39654     try {
39655       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
39656     } CALL_CATCH_EXCEPTION(0);
39657   }
39658
39659   jresult = (void *)result;
39660   return jresult;
39661 }
39662
39663
39664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
39665   void * jresult ;
39666   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
39667   Dali::Toolkit::Alignment *arg2 = 0 ;
39668   Dali::Toolkit::Alignment *result = 0 ;
39669
39670   arg1 = (Dali::Toolkit::Alignment *)jarg1;
39671   arg2 = (Dali::Toolkit::Alignment *)jarg2;
39672   if (!arg2) {
39673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
39674     return 0;
39675   }
39676   {
39677     try {
39678       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
39679     } CALL_CATCH_EXCEPTION(0);
39680   }
39681
39682   jresult = (void *)result;
39683   return jresult;
39684 }
39685
39686
39687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
39688   int jresult ;
39689   int result;
39690
39691   result = (int)Dali::Toolkit::Button::Property::DISABLED;
39692   jresult = (int)result;
39693   return jresult;
39694 }
39695
39696
39697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
39698   int jresult ;
39699   int result;
39700
39701   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
39702   jresult = (int)result;
39703   return jresult;
39704 }
39705
39706
39707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
39708   int jresult ;
39709   int result;
39710
39711   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
39712   jresult = (int)result;
39713   return jresult;
39714 }
39715
39716
39717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
39718   int jresult ;
39719   int result;
39720
39721   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
39722   jresult = (int)result;
39723   return jresult;
39724 }
39725
39726
39727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
39728   int jresult ;
39729   int result;
39730
39731   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
39732   jresult = (int)result;
39733   return jresult;
39734 }
39735
39736
39737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
39738   int jresult ;
39739   int result;
39740
39741   result = (int)Dali::Toolkit::Button::Property::SELECTED;
39742   jresult = (int)result;
39743   return jresult;
39744 }
39745
39746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
39747   int jresult ;
39748   int result;
39749
39750   result = (int)Dali::Toolkit::Button::Property::LABEL;
39751   jresult = (int)result;
39752   return jresult;
39753 }
39754
39755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
39756   void * jresult ;
39757   Dali::Toolkit::Button::Property *result = 0 ;
39758
39759   {
39760     try {
39761       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
39762     } CALL_CATCH_EXCEPTION(0);
39763   }
39764
39765   jresult = (void *)result;
39766   return jresult;
39767 }
39768
39769
39770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
39771   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
39772
39773   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
39774   {
39775     try {
39776       delete arg1;
39777     } CALL_CATCH_EXCEPTION();
39778   }
39779
39780 }
39781
39782
39783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
39784   void * jresult ;
39785   Dali::Toolkit::Button *result = 0 ;
39786
39787   {
39788     try {
39789       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
39790     } CALL_CATCH_EXCEPTION(0);
39791   }
39792
39793   jresult = (void *)result;
39794   return jresult;
39795 }
39796
39797
39798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
39799   void * jresult ;
39800   Dali::Toolkit::Button *arg1 = 0 ;
39801   Dali::Toolkit::Button *result = 0 ;
39802
39803   arg1 = (Dali::Toolkit::Button *)jarg1;
39804   if (!arg1) {
39805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39806     return 0;
39807   }
39808   {
39809     try {
39810       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
39811     } CALL_CATCH_EXCEPTION(0);
39812   }
39813
39814   jresult = (void *)result;
39815   return jresult;
39816 }
39817
39818
39819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
39820   void * jresult ;
39821   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39822   Dali::Toolkit::Button *arg2 = 0 ;
39823   Dali::Toolkit::Button *result = 0 ;
39824
39825   arg1 = (Dali::Toolkit::Button *)jarg1;
39826   arg2 = (Dali::Toolkit::Button *)jarg2;
39827   if (!arg2) {
39828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39829     return 0;
39830   }
39831   {
39832     try {
39833       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
39834     } CALL_CATCH_EXCEPTION(0);
39835   }
39836
39837   jresult = (void *)result;
39838   return jresult;
39839 }
39840
39841
39842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
39843   void * jresult ;
39844   Dali::BaseHandle arg1 ;
39845   Dali::BaseHandle *argp1 ;
39846   Dali::Toolkit::Button result;
39847
39848   argp1 = (Dali::BaseHandle *)jarg1;
39849   if (!argp1) {
39850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39851     return 0;
39852   }
39853   arg1 = *argp1;
39854   {
39855     try {
39856       result = Dali::Toolkit::Button::DownCast(arg1);
39857     } CALL_CATCH_EXCEPTION(0);
39858   }
39859
39860   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
39861   return jresult;
39862 }
39863
39864
39865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
39866   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39867
39868   arg1 = (Dali::Toolkit::Button *)jarg1;
39869   {
39870     try {
39871       delete arg1;
39872     } CALL_CATCH_EXCEPTION();
39873   }
39874
39875 }
39876
39877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
39878   void * jresult ;
39879   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39880   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39881
39882   arg1 = (Dali::Toolkit::Button *)jarg1;
39883   {
39884     try {
39885       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
39886     } CALL_CATCH_EXCEPTION(0);
39887   }
39888
39889   jresult = (void *)result;
39890   return jresult;
39891 }
39892
39893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
39894   void * jresult ;
39895   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39896   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39897
39898   arg1 = (Dali::Toolkit::Button *)jarg1;
39899   {
39900     try {
39901       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
39902     } CALL_CATCH_EXCEPTION(0);
39903   }
39904
39905   jresult = (void *)result;
39906   return jresult;
39907 }
39908
39909
39910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
39911   void * jresult ;
39912   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39913   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39914
39915   arg1 = (Dali::Toolkit::Button *)jarg1;
39916   {
39917     try {
39918       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
39919     } CALL_CATCH_EXCEPTION(0);
39920   }
39921
39922   jresult = (void *)result;
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
39928   void * jresult ;
39929   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39930   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39931
39932   arg1 = (Dali::Toolkit::Button *)jarg1;
39933   {
39934     try {
39935       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
39936     } CALL_CATCH_EXCEPTION(0);
39937   }
39938
39939   jresult = (void *)result;
39940   return jresult;
39941 }
39942
39943
39944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
39945   void * jresult ;
39946   Dali::Toolkit::CheckBoxButton *result = 0 ;
39947
39948   {
39949     try {
39950       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
39951     } CALL_CATCH_EXCEPTION(0);
39952   }
39953
39954   jresult = (void *)result;
39955   return jresult;
39956 }
39957
39958
39959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
39960   void * jresult ;
39961   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
39962   Dali::Toolkit::CheckBoxButton *result = 0 ;
39963
39964   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39965   if (!arg1) {
39966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39967     return 0;
39968   }
39969   {
39970     try {
39971       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
39972     } CALL_CATCH_EXCEPTION(0);
39973   }
39974
39975   jresult = (void *)result;
39976   return jresult;
39977 }
39978
39979
39980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
39981   void * jresult ;
39982   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39983   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
39984   Dali::Toolkit::CheckBoxButton *result = 0 ;
39985
39986   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39987   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
39988   if (!arg2) {
39989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39990     return 0;
39991   }
39992   {
39993     try {
39994       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39995     } CALL_CATCH_EXCEPTION(0);
39996   }
39997
39998   jresult = (void *)result;
39999   return jresult;
40000 }
40001
40002
40003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
40004   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
40005
40006   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
40007   {
40008     try {
40009       delete arg1;
40010     } CALL_CATCH_EXCEPTION();
40011   }
40012
40013 }
40014
40015
40016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
40017   void * jresult ;
40018   Dali::Toolkit::CheckBoxButton result;
40019
40020   {
40021     try {
40022       result = Dali::Toolkit::CheckBoxButton::New();
40023     } CALL_CATCH_EXCEPTION(0);
40024   }
40025
40026   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40027   return jresult;
40028 }
40029
40030
40031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
40032   void * jresult ;
40033   Dali::BaseHandle arg1 ;
40034   Dali::BaseHandle *argp1 ;
40035   Dali::Toolkit::CheckBoxButton result;
40036
40037   argp1 = (Dali::BaseHandle *)jarg1;
40038   if (!argp1) {
40039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40040     return 0;
40041   }
40042   arg1 = *argp1;
40043   {
40044     try {
40045       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
40046     } CALL_CATCH_EXCEPTION(0);
40047   }
40048
40049   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
40050   return jresult;
40051 }
40052
40053
40054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
40055   int jresult ;
40056   int result;
40057
40058   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
40059   jresult = (int)result;
40060   return jresult;
40061 }
40062
40063
40064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
40065   int jresult ;
40066   int result;
40067
40068   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
40069   jresult = (int)result;
40070   return jresult;
40071 }
40072
40073
40074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
40075   void * jresult ;
40076   Dali::Toolkit::PushButton::Property *result = 0 ;
40077
40078   {
40079     try {
40080       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
40081     } CALL_CATCH_EXCEPTION(0);
40082   }
40083
40084   jresult = (void *)result;
40085   return jresult;
40086 }
40087
40088
40089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
40090   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
40091
40092   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
40093   {
40094     try {
40095       delete arg1;
40096     } CALL_CATCH_EXCEPTION();
40097   }
40098
40099 }
40100
40101
40102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
40103   void * jresult ;
40104   Dali::Toolkit::PushButton *result = 0 ;
40105
40106   {
40107     try {
40108       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
40109     } CALL_CATCH_EXCEPTION(0);
40110   }
40111
40112   jresult = (void *)result;
40113   return jresult;
40114 }
40115
40116
40117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
40118   void * jresult ;
40119   Dali::Toolkit::PushButton *arg1 = 0 ;
40120   Dali::Toolkit::PushButton *result = 0 ;
40121
40122   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40123   if (!arg1) {
40124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
40125     return 0;
40126   }
40127   {
40128     try {
40129       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
40130     } CALL_CATCH_EXCEPTION(0);
40131   }
40132
40133   jresult = (void *)result;
40134   return jresult;
40135 }
40136
40137
40138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
40139   void * jresult ;
40140   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
40141   Dali::Toolkit::PushButton *arg2 = 0 ;
40142   Dali::Toolkit::PushButton *result = 0 ;
40143
40144   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40145   arg2 = (Dali::Toolkit::PushButton *)jarg2;
40146   if (!arg2) {
40147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
40148     return 0;
40149   }
40150   {
40151     try {
40152       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
40153     } CALL_CATCH_EXCEPTION(0);
40154   }
40155
40156   jresult = (void *)result;
40157   return jresult;
40158 }
40159
40160
40161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
40162   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
40163
40164   arg1 = (Dali::Toolkit::PushButton *)jarg1;
40165   {
40166     try {
40167       delete arg1;
40168     } CALL_CATCH_EXCEPTION();
40169   }
40170
40171 }
40172
40173
40174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
40175   void * jresult ;
40176   Dali::Toolkit::PushButton result;
40177
40178   {
40179     try {
40180       result = Dali::Toolkit::PushButton::New();
40181     } CALL_CATCH_EXCEPTION(0);
40182   }
40183
40184   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
40185   return jresult;
40186 }
40187
40188
40189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
40190   void * jresult ;
40191   Dali::BaseHandle arg1 ;
40192   Dali::BaseHandle *argp1 ;
40193   Dali::Toolkit::PushButton result;
40194
40195   argp1 = (Dali::BaseHandle *)jarg1;
40196   if (!argp1) {
40197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40198     return 0;
40199   }
40200   arg1 = *argp1;
40201   {
40202     try {
40203       result = Dali::Toolkit::PushButton::DownCast(arg1);
40204     } CALL_CATCH_EXCEPTION(0);
40205   }
40206
40207   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
40208   return jresult;
40209 }
40210
40211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
40212   void * jresult ;
40213   Dali::Toolkit::RadioButton *result = 0 ;
40214
40215   {
40216     try {
40217       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
40218     } CALL_CATCH_EXCEPTION(0);
40219   }
40220
40221   jresult = (void *)result;
40222   return jresult;
40223 }
40224
40225
40226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
40227   void * jresult ;
40228   Dali::Toolkit::RadioButton *arg1 = 0 ;
40229   Dali::Toolkit::RadioButton *result = 0 ;
40230
40231   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40232   if (!arg1) {
40233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
40234     return 0;
40235   }
40236   {
40237     try {
40238       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
40239     } CALL_CATCH_EXCEPTION(0);
40240   }
40241
40242   jresult = (void *)result;
40243   return jresult;
40244 }
40245
40246
40247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
40248   void * jresult ;
40249   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
40250   Dali::Toolkit::RadioButton *arg2 = 0 ;
40251   Dali::Toolkit::RadioButton *result = 0 ;
40252
40253   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40254   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
40255   if (!arg2) {
40256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
40257     return 0;
40258   }
40259   {
40260     try {
40261       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
40262     } CALL_CATCH_EXCEPTION(0);
40263   }
40264
40265   jresult = (void *)result;
40266   return jresult;
40267 }
40268
40269
40270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
40271   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
40272
40273   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
40274   {
40275     try {
40276       delete arg1;
40277     } CALL_CATCH_EXCEPTION();
40278   }
40279
40280 }
40281
40282
40283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
40284   void * jresult ;
40285   Dali::Toolkit::RadioButton result;
40286
40287   {
40288     try {
40289       result = Dali::Toolkit::RadioButton::New();
40290     } CALL_CATCH_EXCEPTION(0);
40291   }
40292
40293   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40294   return jresult;
40295 }
40296
40297
40298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
40299   void * jresult ;
40300   std::string *arg1 = 0 ;
40301   Dali::Toolkit::RadioButton result;
40302
40303   if (!jarg1) {
40304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40305     return 0;
40306   }
40307   std::string arg1_str(jarg1);
40308   arg1 = &arg1_str;
40309   {
40310     try {
40311       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
40312     } CALL_CATCH_EXCEPTION(0);
40313   }
40314
40315   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40316
40317   //argout typemap for const std::string&
40318
40319   return jresult;
40320 }
40321
40322
40323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
40324   void * jresult ;
40325   Dali::BaseHandle arg1 ;
40326   Dali::BaseHandle *argp1 ;
40327   Dali::Toolkit::RadioButton result;
40328
40329   argp1 = (Dali::BaseHandle *)jarg1;
40330   if (!argp1) {
40331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40332     return 0;
40333   }
40334   arg1 = *argp1;
40335   {
40336     try {
40337       result = Dali::Toolkit::RadioButton::DownCast(arg1);
40338     } CALL_CATCH_EXCEPTION(0);
40339   }
40340
40341   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
40342   return jresult;
40343 }
40344
40345
40346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
40347   int jresult ;
40348   int result;
40349
40350   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
40351   jresult = (int)result;
40352   return jresult;
40353 }
40354
40355
40356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
40357   int jresult ;
40358   int result;
40359
40360   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
40361   jresult = (int)result;
40362   return jresult;
40363 }
40364
40365
40366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
40367   int jresult ;
40368   int result;
40369
40370   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
40371   jresult = (int)result;
40372   return jresult;
40373 }
40374
40375
40376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
40377   int jresult ;
40378   int result;
40379
40380   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
40381   jresult = (int)result;
40382   return jresult;
40383 }
40384
40385
40386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
40387   int jresult ;
40388   int result;
40389
40390   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
40391   jresult = (int)result;
40392   return jresult;
40393 }
40394
40395
40396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
40397   int jresult ;
40398   int result;
40399
40400   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
40401   jresult = (int)result;
40402   return jresult;
40403 }
40404
40405
40406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
40407   void * jresult ;
40408   Dali::Toolkit::FlexContainer::Property *result = 0 ;
40409
40410   {
40411     try {
40412       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
40413     } CALL_CATCH_EXCEPTION(0);
40414   }
40415
40416   jresult = (void *)result;
40417   return jresult;
40418 }
40419
40420
40421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
40422   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
40423
40424   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
40425   {
40426     try {
40427       delete arg1;
40428     } CALL_CATCH_EXCEPTION();
40429   }
40430
40431 }
40432
40433
40434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
40435   int jresult ;
40436   int result;
40437
40438   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
40439   jresult = (int)result;
40440   return jresult;
40441 }
40442
40443
40444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
40445   int jresult ;
40446   int result;
40447
40448   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
40449   jresult = (int)result;
40450   return jresult;
40451 }
40452
40453
40454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
40455   int jresult ;
40456   int result;
40457
40458   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
40459   jresult = (int)result;
40460   return jresult;
40461 }
40462
40463
40464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
40465   void * jresult ;
40466   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
40467
40468   {
40469     try {
40470       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
40471     } CALL_CATCH_EXCEPTION(0);
40472   }
40473
40474   jresult = (void *)result;
40475   return jresult;
40476 }
40477
40478
40479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
40480   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
40481
40482   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
40483   {
40484     try {
40485       delete arg1;
40486     } CALL_CATCH_EXCEPTION();
40487   }
40488
40489 }
40490
40491
40492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
40493   void * jresult ;
40494   Dali::Toolkit::FlexContainer *result = 0 ;
40495
40496   {
40497     try {
40498       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
40499     } CALL_CATCH_EXCEPTION(0);
40500   }
40501
40502   jresult = (void *)result;
40503   return jresult;
40504 }
40505
40506
40507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
40508   void * jresult ;
40509   Dali::Toolkit::FlexContainer *arg1 = 0 ;
40510   Dali::Toolkit::FlexContainer *result = 0 ;
40511
40512   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
40513   if (!arg1) {
40514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
40515     return 0;
40516   }
40517   {
40518     try {
40519       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
40520     } CALL_CATCH_EXCEPTION(0);
40521   }
40522
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
40529   void * jresult ;
40530   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
40531   Dali::Toolkit::FlexContainer *arg2 = 0 ;
40532   Dali::Toolkit::FlexContainer *result = 0 ;
40533
40534   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
40535   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
40536   if (!arg2) {
40537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
40538     return 0;
40539   }
40540   {
40541     try {
40542       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
40543     } CALL_CATCH_EXCEPTION(0);
40544   }
40545
40546   jresult = (void *)result;
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
40552   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
40553
40554   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
40555   {
40556     try {
40557       delete arg1;
40558     } CALL_CATCH_EXCEPTION();
40559   }
40560
40561 }
40562
40563
40564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
40565   void * jresult ;
40566   Dali::Toolkit::FlexContainer result;
40567
40568   {
40569     try {
40570       result = Dali::Toolkit::FlexContainer::New();
40571     } CALL_CATCH_EXCEPTION(0);
40572   }
40573
40574   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
40575   return jresult;
40576 }
40577
40578
40579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
40580   void * jresult ;
40581   Dali::BaseHandle arg1 ;
40582   Dali::BaseHandle *argp1 ;
40583   Dali::Toolkit::FlexContainer result;
40584
40585   argp1 = (Dali::BaseHandle *)jarg1;
40586   if (!argp1) {
40587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40588     return 0;
40589   }
40590   arg1 = *argp1;
40591   {
40592     try {
40593       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
40594     } CALL_CATCH_EXCEPTION(0);
40595   }
40596
40597   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
40598   return jresult;
40599 }
40600
40601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
40602   int jresult ;
40603   int result;
40604
40605   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
40606   jresult = (int)result;
40607   return jresult;
40608 }
40609
40610
40611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
40612   int jresult ;
40613   int result;
40614
40615   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
40616   jresult = (int)result;
40617   return jresult;
40618 }
40619
40620
40621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
40622   int jresult ;
40623   int result;
40624
40625   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
40626   jresult = (int)result;
40627   return jresult;
40628 }
40629
40630
40631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
40632   void * jresult ;
40633   Dali::Toolkit::ImageView::Property *result = 0 ;
40634
40635   {
40636     try {
40637       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
40638     } CALL_CATCH_EXCEPTION(0);
40639   }
40640
40641   jresult = (void *)result;
40642   return jresult;
40643 }
40644
40645
40646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
40647   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
40648
40649   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
40650   {
40651     try {
40652       delete arg1;
40653     } CALL_CATCH_EXCEPTION();
40654   }
40655
40656 }
40657
40658
40659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
40660   void * jresult ;
40661   Dali::Toolkit::ImageView *result = 0 ;
40662
40663   {
40664     try {
40665       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
40666     } CALL_CATCH_EXCEPTION(0);
40667   }
40668
40669   jresult = (void *)result;
40670   return jresult;
40671 }
40672
40673
40674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
40675   void * jresult ;
40676   Dali::Toolkit::ImageView result;
40677
40678   {
40679     try {
40680       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
40681     } CALL_CATCH_EXCEPTION(0);
40682   }
40683
40684   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40685   return jresult;
40686 }
40687
40688
40689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
40690   void * jresult ;
40691   std::string *arg1 = 0 ;
40692   Dali::Toolkit::ImageView result;
40693
40694   if (!jarg1) {
40695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40696     return 0;
40697   }
40698   std::string arg1_str(jarg1);
40699   arg1 = &arg1_str;
40700   {
40701     try {
40702       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
40703     } CALL_CATCH_EXCEPTION(0);
40704   }
40705
40706   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40707
40708   //argout typemap for const std::string&
40709
40710   return jresult;
40711 }
40712
40713
40714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
40715   void * jresult ;
40716   std::string *arg1 = 0 ;
40717   Dali::ImageDimensions arg2 ;
40718   Dali::ImageDimensions *argp2 ;
40719   Dali::Toolkit::ImageView result;
40720
40721   if (!jarg1) {
40722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40723     return 0;
40724   }
40725   std::string arg1_str(jarg1);
40726   arg1 = &arg1_str;
40727   argp2 = (Dali::ImageDimensions *)jarg2;
40728   if (!argp2) {
40729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40730     return 0;
40731   }
40732   arg2 = *argp2;
40733   {
40734     try {
40735       result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2);
40736     } CALL_CATCH_EXCEPTION(0);
40737   }
40738
40739   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40740
40741   //argout typemap for const std::string&
40742
40743   return jresult;
40744 }
40745
40746
40747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
40748   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40749
40750   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40751   {
40752     try {
40753       delete arg1;
40754     } CALL_CATCH_EXCEPTION();
40755   }
40756
40757 }
40758
40759
40760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
40761   void * jresult ;
40762   Dali::Toolkit::ImageView *arg1 = 0 ;
40763   Dali::Toolkit::ImageView *result = 0 ;
40764
40765   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40766   if (!arg1) {
40767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
40768     return 0;
40769   }
40770   {
40771     try {
40772       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
40773     } CALL_CATCH_EXCEPTION(0);
40774   }
40775
40776   jresult = (void *)result;
40777   return jresult;
40778 }
40779
40780
40781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
40782   void * jresult ;
40783   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40784   Dali::Toolkit::ImageView *arg2 = 0 ;
40785   Dali::Toolkit::ImageView *result = 0 ;
40786
40787   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40788   arg2 = (Dali::Toolkit::ImageView *)jarg2;
40789   if (!arg2) {
40790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
40791     return 0;
40792   }
40793   {
40794     try {
40795       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
40796     } CALL_CATCH_EXCEPTION(0);
40797   }
40798
40799   jresult = (void *)result;
40800   return jresult;
40801 }
40802
40803
40804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
40805   void * jresult ;
40806   Dali::BaseHandle arg1 ;
40807   Dali::BaseHandle *argp1 ;
40808   Dali::Toolkit::ImageView result;
40809
40810   argp1 = (Dali::BaseHandle *)jarg1;
40811   if (!argp1) {
40812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40813     return 0;
40814   }
40815   arg1 = *argp1;
40816   {
40817     try {
40818       result = Dali::Toolkit::ImageView::DownCast(arg1);
40819     } CALL_CATCH_EXCEPTION(0);
40820   }
40821
40822   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40823   return jresult;
40824 }
40825
40826
40827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
40828   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40829   std::string *arg2 = 0 ;
40830
40831   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40832   if (!jarg2) {
40833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40834     return ;
40835   }
40836   std::string arg2_str(jarg2);
40837   arg2 = &arg2_str;
40838   {
40839     try {
40840       (arg1)->SetImage((std::string const &)*arg2);
40841     } CALL_CATCH_EXCEPTION();
40842   }
40843
40844
40845   //argout typemap for const std::string&
40846
40847 }
40848
40849
40850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
40851   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40852   std::string *arg2 = 0 ;
40853   Dali::ImageDimensions arg3 ;
40854   Dali::ImageDimensions *argp3 ;
40855
40856   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40857   if (!jarg2) {
40858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40859     return ;
40860   }
40861   std::string arg2_str(jarg2);
40862   arg2 = &arg2_str;
40863   argp3 = (Dali::ImageDimensions *)jarg3;
40864   if (!argp3) {
40865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40866     return ;
40867   }
40868   arg3 = *argp3;
40869   {
40870     try {
40871       (arg1)->SetImage((std::string const &)*arg2,arg3);
40872     } CALL_CATCH_EXCEPTION();
40873   }
40874
40875
40876   //argout typemap for const std::string&
40877
40878 }
40879
40880
40881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40882   int jresult ;
40883   int result;
40884
40885   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40886   jresult = (int)result;
40887   return jresult;
40888 }
40889
40890
40891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40892   int jresult ;
40893   int result;
40894
40895   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40896   jresult = (int)result;
40897   return jresult;
40898 }
40899
40900
40901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40902   int jresult ;
40903   int result;
40904
40905   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40906   jresult = (int)result;
40907   return jresult;
40908 }
40909
40910
40911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40912   int jresult ;
40913   int result;
40914
40915   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40916   jresult = (int)result;
40917   return jresult;
40918 }
40919
40920
40921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40922   int jresult ;
40923   int result;
40924
40925   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40926   jresult = (int)result;
40927   return jresult;
40928 }
40929
40930
40931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40932   int jresult ;
40933   int result;
40934
40935   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40936   jresult = (int)result;
40937   return jresult;
40938 }
40939
40940
40941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40942   int jresult ;
40943   int result;
40944
40945   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40946   jresult = (int)result;
40947   return jresult;
40948 }
40949
40950
40951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40952   int jresult ;
40953   int result;
40954
40955   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40956   jresult = (int)result;
40957   return jresult;
40958 }
40959
40960
40961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40962   int jresult ;
40963   int result;
40964
40965   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40966   jresult = (int)result;
40967   return jresult;
40968 }
40969
40970
40971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40972   void * jresult ;
40973   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40974
40975   {
40976     try {
40977       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40978     } CALL_CATCH_EXCEPTION(0);
40979   }
40980
40981   jresult = (void *)result;
40982   return jresult;
40983 }
40984
40985
40986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40987   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40988
40989   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40990   {
40991     try {
40992       delete arg1;
40993     } CALL_CATCH_EXCEPTION();
40994   }
40995
40996 }
40997
40998
40999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
41000   void * jresult ;
41001   Dali::Toolkit::ScrollBar *result = 0 ;
41002
41003   {
41004     try {
41005       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
41006     } CALL_CATCH_EXCEPTION(0);
41007   }
41008
41009   jresult = (void *)result;
41010   return jresult;
41011 }
41012
41013
41014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
41015   void * jresult ;
41016   Dali::Toolkit::ScrollBar *arg1 = 0 ;
41017   Dali::Toolkit::ScrollBar *result = 0 ;
41018
41019   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41020   if (!arg1) {
41021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41022     return 0;
41023   }
41024   {
41025     try {
41026       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
41027     } CALL_CATCH_EXCEPTION(0);
41028   }
41029
41030   jresult = (void *)result;
41031   return jresult;
41032 }
41033
41034
41035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
41036   void * jresult ;
41037   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41038   Dali::Toolkit::ScrollBar *arg2 = 0 ;
41039   Dali::Toolkit::ScrollBar *result = 0 ;
41040
41041   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41042   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
41043   if (!arg2) {
41044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
41045     return 0;
41046   }
41047   {
41048     try {
41049       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
41050     } CALL_CATCH_EXCEPTION(0);
41051   }
41052
41053   jresult = (void *)result;
41054   return jresult;
41055 }
41056
41057
41058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
41059   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41060
41061   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41062   {
41063     try {
41064       delete arg1;
41065     } CALL_CATCH_EXCEPTION();
41066   }
41067
41068 }
41069
41070
41071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
41072   void * jresult ;
41073   Dali::Toolkit::ScrollBar::Direction arg1 ;
41074   Dali::Toolkit::ScrollBar result;
41075
41076   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
41077   {
41078     try {
41079       result = Dali::Toolkit::ScrollBar::New(arg1);
41080     } CALL_CATCH_EXCEPTION(0);
41081   }
41082
41083   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41084   return jresult;
41085 }
41086
41087
41088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
41089   void * jresult ;
41090   Dali::Toolkit::ScrollBar result;
41091
41092   {
41093     try {
41094       result = Dali::Toolkit::ScrollBar::New();
41095     } CALL_CATCH_EXCEPTION(0);
41096   }
41097
41098   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41099   return jresult;
41100 }
41101
41102
41103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
41104   void * jresult ;
41105   Dali::BaseHandle arg1 ;
41106   Dali::BaseHandle *argp1 ;
41107   Dali::Toolkit::ScrollBar result;
41108
41109   argp1 = (Dali::BaseHandle *)jarg1;
41110   if (!argp1) {
41111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41112     return 0;
41113   }
41114   arg1 = *argp1;
41115   {
41116     try {
41117       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
41118     } CALL_CATCH_EXCEPTION(0);
41119   }
41120
41121   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
41122   return jresult;
41123 }
41124
41125
41126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
41127   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41128   Dali::Handle arg2 ;
41129   Dali::Property::Index arg3 ;
41130   Dali::Property::Index arg4 ;
41131   Dali::Property::Index arg5 ;
41132   Dali::Property::Index arg6 ;
41133   Dali::Handle *argp2 ;
41134
41135   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41136   argp2 = (Dali::Handle *)jarg2;
41137   if (!argp2) {
41138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
41139     return ;
41140   }
41141   arg2 = *argp2;
41142   arg3 = (Dali::Property::Index)jarg3;
41143   arg4 = (Dali::Property::Index)jarg4;
41144   arg5 = (Dali::Property::Index)jarg5;
41145   arg6 = (Dali::Property::Index)jarg6;
41146   {
41147     try {
41148       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
41149     } CALL_CATCH_EXCEPTION();
41150   }
41151
41152 }
41153
41154
41155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
41156   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41157   Dali::Actor arg2 ;
41158   Dali::Actor *argp2 ;
41159
41160   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41161   argp2 = (Dali::Actor *)jarg2;
41162   if (!argp2) {
41163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
41164     return ;
41165   }
41166   arg2 = *argp2;
41167   {
41168     try {
41169       (arg1)->SetScrollIndicator(arg2);
41170     } CALL_CATCH_EXCEPTION();
41171   }
41172
41173 }
41174
41175
41176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
41177   void * jresult ;
41178   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41179   Dali::Actor result;
41180
41181   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41182   {
41183     try {
41184       result = (arg1)->GetScrollIndicator();
41185     } CALL_CATCH_EXCEPTION(0);
41186   }
41187
41188   jresult = new Dali::Actor((const Dali::Actor &)result);
41189   return jresult;
41190 }
41191
41192
41193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
41194   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41195   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
41196
41197   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41198   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
41199   if (!arg2) {
41200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
41201     return ;
41202   }
41203   {
41204     try {
41205       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
41206     } CALL_CATCH_EXCEPTION();
41207   }
41208
41209 }
41210
41211
41212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
41213   void * jresult ;
41214   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41215
41216   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41217   {
41218     try {
41219       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()));
41220     } CALL_CATCH_EXCEPTION(0);
41221   }
41222   return jresult;
41223 }
41224
41225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
41226   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41227   Dali::Toolkit::ScrollBar::Direction arg2 ;
41228
41229   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41230   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
41231   {
41232     try {
41233       (arg1)->SetScrollDirection(arg2);
41234     } CALL_CATCH_EXCEPTION();
41235   }
41236
41237 }
41238
41239
41240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
41241   int jresult ;
41242   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41243   Dali::Toolkit::ScrollBar::Direction result;
41244
41245   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41246   {
41247     try {
41248       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
41249     } CALL_CATCH_EXCEPTION(0);
41250   }
41251
41252   jresult = (int)result;
41253   return jresult;
41254 }
41255
41256
41257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
41258   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41259   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
41260
41261   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41262   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
41263   {
41264     try {
41265       (arg1)->SetIndicatorHeightPolicy(arg2);
41266     } CALL_CATCH_EXCEPTION();
41267   }
41268
41269 }
41270
41271
41272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
41273   int jresult ;
41274   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41275   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
41276
41277   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41278   {
41279     try {
41280       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
41281     } CALL_CATCH_EXCEPTION(0);
41282   }
41283
41284   jresult = (int)result;
41285   return jresult;
41286 }
41287
41288
41289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
41290   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41291   float arg2 ;
41292
41293   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41294   arg2 = (float)jarg2;
41295   {
41296     try {
41297       (arg1)->SetIndicatorFixedHeight(arg2);
41298     } CALL_CATCH_EXCEPTION();
41299   }
41300
41301 }
41302
41303
41304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
41305   float jresult ;
41306   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41307   float result;
41308
41309   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41310   {
41311     try {
41312       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
41313     } CALL_CATCH_EXCEPTION(0);
41314   }
41315
41316   jresult = result;
41317   return jresult;
41318 }
41319
41320
41321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
41322   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41323   float arg2 ;
41324
41325   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41326   arg2 = (float)jarg2;
41327   {
41328     try {
41329       (arg1)->SetIndicatorShowDuration(arg2);
41330     } CALL_CATCH_EXCEPTION();
41331   }
41332
41333 }
41334
41335
41336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
41337   float jresult ;
41338   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41339   float result;
41340
41341   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41342   {
41343     try {
41344       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
41345     } CALL_CATCH_EXCEPTION(0);
41346   }
41347
41348   jresult = result;
41349   return jresult;
41350 }
41351
41352
41353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
41354   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41355   float arg2 ;
41356
41357   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41358   arg2 = (float)jarg2;
41359   {
41360     try {
41361       (arg1)->SetIndicatorHideDuration(arg2);
41362     } CALL_CATCH_EXCEPTION();
41363   }
41364
41365 }
41366
41367
41368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
41369   float jresult ;
41370   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41371   float result;
41372
41373   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41374   {
41375     try {
41376       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
41377     } CALL_CATCH_EXCEPTION(0);
41378   }
41379
41380   jresult = result;
41381   return jresult;
41382 }
41383
41384
41385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
41386   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41387
41388   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41389   {
41390     try {
41391       (arg1)->ShowIndicator();
41392     } CALL_CATCH_EXCEPTION();
41393   }
41394
41395 }
41396
41397
41398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
41399   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41400
41401   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41402   {
41403     try {
41404       (arg1)->HideIndicator();
41405     } CALL_CATCH_EXCEPTION();
41406   }
41407
41408 }
41409
41410
41411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
41412   void * jresult ;
41413   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41414   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
41415
41416   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41417   {
41418     try {
41419       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
41420     } CALL_CATCH_EXCEPTION(0);
41421   }
41422
41423   jresult = (void *)result;
41424   return jresult;
41425 }
41426
41427
41428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
41429   void * jresult ;
41430   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
41431   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
41432
41433   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
41434   {
41435     try {
41436       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
41437     } CALL_CATCH_EXCEPTION(0);
41438   }
41439
41440   jresult = (void *)result;
41441   return jresult;
41442 }
41443
41444
41445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
41446   int jresult ;
41447   int result;
41448
41449   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
41450   jresult = (int)result;
41451   return jresult;
41452 }
41453
41454
41455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
41456   int jresult ;
41457   int result;
41458
41459   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
41460   jresult = (int)result;
41461   return jresult;
41462 }
41463
41464
41465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
41466   int jresult ;
41467   int result;
41468
41469   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
41470   jresult = (int)result;
41471   return jresult;
41472 }
41473
41474
41475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
41476   int jresult ;
41477   int result;
41478
41479   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
41480   jresult = (int)result;
41481   return jresult;
41482 }
41483
41484
41485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
41486   int jresult ;
41487   int result;
41488
41489   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
41490   jresult = (int)result;
41491   return jresult;
41492 }
41493
41494
41495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
41496   int jresult ;
41497   int result;
41498
41499   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
41500   jresult = (int)result;
41501   return jresult;
41502 }
41503
41504
41505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
41506   int jresult ;
41507   int result;
41508
41509   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
41510   jresult = (int)result;
41511   return jresult;
41512 }
41513
41514
41515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
41516   int jresult ;
41517   int result;
41518
41519   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
41520   jresult = (int)result;
41521   return jresult;
41522 }
41523
41524
41525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
41526   int jresult ;
41527   int result;
41528
41529   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
41530   jresult = (int)result;
41531   return jresult;
41532 }
41533
41534
41535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
41536   int jresult ;
41537   int result;
41538
41539   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
41540   jresult = (int)result;
41541   return jresult;
41542 }
41543
41544
41545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
41546   int jresult ;
41547   int result;
41548
41549   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
41550   jresult = (int)result;
41551   return jresult;
41552 }
41553
41554
41555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
41556   int jresult ;
41557   int result;
41558
41559   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
41560   jresult = (int)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
41566   int jresult ;
41567   int result;
41568
41569   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
41570   jresult = (int)result;
41571   return jresult;
41572 }
41573
41574
41575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
41576   int jresult ;
41577   int result;
41578
41579   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
41580   jresult = (int)result;
41581   return jresult;
41582 }
41583
41584
41585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
41586   void * jresult ;
41587   Dali::Toolkit::Scrollable::Property *result = 0 ;
41588
41589   {
41590     try {
41591       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
41592     } CALL_CATCH_EXCEPTION(0);
41593   }
41594
41595   jresult = (void *)result;
41596   return jresult;
41597 }
41598
41599
41600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
41601   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
41602
41603   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
41604   {
41605     try {
41606       delete arg1;
41607     } CALL_CATCH_EXCEPTION();
41608   }
41609
41610 }
41611
41612
41613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
41614   void * jresult ;
41615   Dali::Toolkit::Scrollable *result = 0 ;
41616
41617   {
41618     try {
41619       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
41620     } CALL_CATCH_EXCEPTION(0);
41621   }
41622
41623   jresult = (void *)result;
41624   return jresult;
41625 }
41626
41627
41628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
41629   void * jresult ;
41630   Dali::Toolkit::Scrollable *arg1 = 0 ;
41631   Dali::Toolkit::Scrollable *result = 0 ;
41632
41633   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41634   if (!arg1) {
41635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41636     return 0;
41637   }
41638   {
41639     try {
41640       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
41641     } CALL_CATCH_EXCEPTION(0);
41642   }
41643
41644   jresult = (void *)result;
41645   return jresult;
41646 }
41647
41648
41649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
41650   void * jresult ;
41651   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41652   Dali::Toolkit::Scrollable *arg2 = 0 ;
41653   Dali::Toolkit::Scrollable *result = 0 ;
41654
41655   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41656   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
41657   if (!arg2) {
41658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41659     return 0;
41660   }
41661   {
41662     try {
41663       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
41664     } CALL_CATCH_EXCEPTION(0);
41665   }
41666
41667   jresult = (void *)result;
41668   return jresult;
41669 }
41670
41671
41672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
41673   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41674
41675   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41676   {
41677     try {
41678       delete arg1;
41679     } CALL_CATCH_EXCEPTION();
41680   }
41681
41682 }
41683
41684
41685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
41686   void * jresult ;
41687   Dali::BaseHandle arg1 ;
41688   Dali::BaseHandle *argp1 ;
41689   Dali::Toolkit::Scrollable result;
41690
41691   argp1 = (Dali::BaseHandle *)jarg1;
41692   if (!argp1) {
41693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41694     return 0;
41695   }
41696   arg1 = *argp1;
41697   {
41698     try {
41699       result = Dali::Toolkit::Scrollable::DownCast(arg1);
41700     } CALL_CATCH_EXCEPTION(0);
41701   }
41702
41703   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
41704   return jresult;
41705 }
41706
41707
41708 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
41709   bool jresult ;
41710   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41711   bool result;
41712
41713   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41714   {
41715     try {
41716       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
41717     } CALL_CATCH_EXCEPTION(0);
41718   }
41719
41720   jresult = result;
41721   return jresult;
41722 }
41723
41724
41725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) {
41726   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41727   bool arg2 ;
41728
41729   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41730   arg2 = jarg2 ? true : false;
41731   {
41732     try {
41733       (arg1)->SetOvershootEnabled(arg2);
41734     } CALL_CATCH_EXCEPTION();
41735   }
41736
41737 }
41738
41739
41740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41741   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41742   Dali::Vector4 *arg2 = 0 ;
41743
41744   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41745   arg2 = (Dali::Vector4 *)jarg2;
41746   if (!arg2) {
41747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41748     return ;
41749   }
41750   {
41751     try {
41752       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41753     } CALL_CATCH_EXCEPTION();
41754   }
41755
41756 }
41757
41758
41759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41760   void * jresult ;
41761   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41762   Dali::Vector4 result;
41763
41764   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41765   {
41766     try {
41767       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41768     } CALL_CATCH_EXCEPTION(0);
41769   }
41770
41771   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41777   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41778   float arg2 ;
41779
41780   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41781   arg2 = (float)jarg2;
41782   {
41783     try {
41784       (arg1)->SetOvershootAnimationSpeed(arg2);
41785     } CALL_CATCH_EXCEPTION();
41786   }
41787
41788 }
41789
41790
41791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41792   float jresult ;
41793   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41794   float result;
41795
41796   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41797   {
41798     try {
41799       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41800     } CALL_CATCH_EXCEPTION(0);
41801   }
41802
41803   jresult = result;
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41809   void * jresult ;
41810   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41811   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41812
41813   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41814   {
41815     try {
41816       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41817     } CALL_CATCH_EXCEPTION(0);
41818   }
41819
41820   jresult = (void *)result;
41821   return jresult;
41822 }
41823
41824
41825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41826   void * jresult ;
41827   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41828   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41829
41830   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41831   {
41832     try {
41833       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41834     } CALL_CATCH_EXCEPTION(0);
41835   }
41836
41837   jresult = (void *)result;
41838   return jresult;
41839 }
41840
41841
41842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41843   void * jresult ;
41844   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41845   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41846
41847   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41848   {
41849     try {
41850       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41851     } CALL_CATCH_EXCEPTION(0);
41852   }
41853
41854   jresult = (void *)result;
41855   return jresult;
41856 }
41857
41858
41859 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41860   bool jresult ;
41861   Dali::Toolkit::ControlOrientation::Type arg1 ;
41862   bool result;
41863
41864   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41865   {
41866     try {
41867       result = (bool)Dali::Toolkit::IsVertical(arg1);
41868     } CALL_CATCH_EXCEPTION(0);
41869   }
41870
41871   jresult = result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41877   bool jresult ;
41878   Dali::Toolkit::ControlOrientation::Type arg1 ;
41879   bool result;
41880
41881   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41882   {
41883     try {
41884       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41885     } CALL_CATCH_EXCEPTION(0);
41886   }
41887
41888   jresult = result;
41889   return jresult;
41890 }
41891
41892
41893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41894   void * jresult ;
41895   unsigned int arg1 ;
41896   unsigned int arg2 ;
41897   Dali::Toolkit::ItemRange *result = 0 ;
41898
41899   arg1 = (unsigned int)jarg1;
41900   arg2 = (unsigned int)jarg2;
41901   {
41902     try {
41903       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41904     } CALL_CATCH_EXCEPTION(0);
41905   }
41906
41907   jresult = (void *)result;
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41913   void * jresult ;
41914   Dali::Toolkit::ItemRange *arg1 = 0 ;
41915   Dali::Toolkit::ItemRange *result = 0 ;
41916
41917   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41918   if (!arg1) {
41919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41920     return 0;
41921   }
41922   {
41923     try {
41924       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41925     } CALL_CATCH_EXCEPTION(0);
41926   }
41927
41928   jresult = (void *)result;
41929   return jresult;
41930 }
41931
41932
41933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41934   void * jresult ;
41935   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41936   Dali::Toolkit::ItemRange *arg2 = 0 ;
41937   Dali::Toolkit::ItemRange *result = 0 ;
41938
41939   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41940   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41941   if (!arg2) {
41942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41943     return 0;
41944   }
41945   {
41946     try {
41947       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41948     } CALL_CATCH_EXCEPTION(0);
41949   }
41950
41951   jresult = (void *)result;
41952   return jresult;
41953 }
41954
41955
41956 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41957   bool jresult ;
41958   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41959   unsigned int arg2 ;
41960   bool result;
41961
41962   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41963   arg2 = (unsigned int)jarg2;
41964   {
41965     try {
41966       result = (bool)(arg1)->Within(arg2);
41967     } CALL_CATCH_EXCEPTION(0);
41968   }
41969
41970   jresult = result;
41971   return jresult;
41972 }
41973
41974
41975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41976   void * jresult ;
41977   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41978   Dali::Toolkit::ItemRange *arg2 = 0 ;
41979   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41980
41981   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41982   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41983   if (!arg2) {
41984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41985     return 0;
41986   }
41987   {
41988     try {
41989       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41990     } CALL_CATCH_EXCEPTION(0);
41991   }
41992
41993   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41994   return jresult;
41995 }
41996
41997
41998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41999   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42000   unsigned int arg2 ;
42001
42002   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42003   arg2 = (unsigned int)jarg2;
42004   if (arg1) (arg1)->begin = arg2;
42005 }
42006
42007
42008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
42009   unsigned int jresult ;
42010   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42011   unsigned int result;
42012
42013   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42014   result = (unsigned int) ((arg1)->begin);
42015   jresult = result;
42016   return jresult;
42017 }
42018
42019
42020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
42021   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42022   unsigned int arg2 ;
42023
42024   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42025   arg2 = (unsigned int)jarg2;
42026   if (arg1) (arg1)->end = arg2;
42027 }
42028
42029
42030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
42031   unsigned int jresult ;
42032   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42033   unsigned int result;
42034
42035   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42036   result = (unsigned int) ((arg1)->end);
42037   jresult = result;
42038   return jresult;
42039 }
42040
42041
42042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
42043   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
42044
42045   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
42046   {
42047     try {
42048       delete arg1;
42049     } CALL_CATCH_EXCEPTION();
42050   }
42051
42052 }
42053
42054
42055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
42056   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42057
42058   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42059   {
42060     try {
42061       delete arg1;
42062     } CALL_CATCH_EXCEPTION();
42063   }
42064
42065 }
42066
42067
42068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
42069   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42070   Dali::Toolkit::ControlOrientation::Type arg2 ;
42071
42072   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42073   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
42074   {
42075     try {
42076       (arg1)->SetOrientation(arg2);
42077     } CALL_CATCH_EXCEPTION();
42078   }
42079
42080 }
42081
42082
42083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
42084   int jresult ;
42085   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42086   Dali::Toolkit::ControlOrientation::Type result;
42087
42088   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42089   {
42090     try {
42091       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
42092     } CALL_CATCH_EXCEPTION(0);
42093   }
42094
42095   jresult = (int)result;
42096   return jresult;
42097 }
42098
42099
42100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
42101   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42102   Dali::Property::Map *arg2 = 0 ;
42103
42104   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42105   arg2 = (Dali::Property::Map *)jarg2;
42106   if (!arg2) {
42107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
42108     return ;
42109   }
42110   {
42111     try {
42112       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
42113     } CALL_CATCH_EXCEPTION();
42114   }
42115
42116 }
42117
42118
42119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
42120   void * jresult ;
42121   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42122   Dali::Property::Map result;
42123
42124   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42125   {
42126     try {
42127       result = (arg1)->GetLayoutProperties();
42128     } CALL_CATCH_EXCEPTION(0);
42129   }
42130
42131   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
42137   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42138   unsigned int arg2 ;
42139   Dali::Vector3 *arg3 = 0 ;
42140   Dali::Vector3 *arg4 = 0 ;
42141
42142   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42143   arg2 = (unsigned int)jarg2;
42144   arg3 = (Dali::Vector3 *)jarg3;
42145   if (!arg3) {
42146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42147     return ;
42148   }
42149   arg4 = (Dali::Vector3 *)jarg4;
42150   if (!arg4) {
42151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42152     return ;
42153   }
42154   {
42155     try {
42156       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
42157     } CALL_CATCH_EXCEPTION();
42158   }
42159
42160 }
42161
42162
42163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
42164   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42165   Dali::Vector3 *arg2 = 0 ;
42166
42167   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42168   arg2 = (Dali::Vector3 *)jarg2;
42169   if (!arg2) {
42170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42171     return ;
42172   }
42173   {
42174     try {
42175       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
42176     } CALL_CATCH_EXCEPTION();
42177   }
42178
42179 }
42180
42181
42182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
42183   float jresult ;
42184   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42185   unsigned int arg2 ;
42186   Dali::Vector3 arg3 ;
42187   Dali::Vector3 *argp3 ;
42188   float result;
42189
42190   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42191   arg2 = (unsigned int)jarg2;
42192   argp3 = (Dali::Vector3 *)jarg3;
42193   if (!argp3) {
42194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42195     return 0;
42196   }
42197   arg3 = *argp3;
42198   {
42199     try {
42200       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
42201     } CALL_CATCH_EXCEPTION(0);
42202   }
42203
42204   jresult = result;
42205   return jresult;
42206 }
42207
42208
42209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
42210   float jresult ;
42211   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42212   float arg2 ;
42213   float result;
42214
42215   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42216   arg2 = (float)jarg2;
42217   {
42218     try {
42219       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
42220     } CALL_CATCH_EXCEPTION(0);
42221   }
42222
42223   jresult = result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
42229   float jresult ;
42230   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42231   unsigned int arg2 ;
42232   float result;
42233
42234   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42235   arg2 = (unsigned int)jarg2;
42236   {
42237     try {
42238       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
42239     } CALL_CATCH_EXCEPTION(0);
42240   }
42241
42242   jresult = result;
42243   return jresult;
42244 }
42245
42246
42247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
42248   void * jresult ;
42249   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42250   float arg2 ;
42251   Dali::Vector3 arg3 ;
42252   Dali::Vector3 *argp3 ;
42253   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
42254
42255   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42256   arg2 = (float)jarg2;
42257   argp3 = (Dali::Vector3 *)jarg3;
42258   if (!argp3) {
42259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42260     return 0;
42261   }
42262   arg3 = *argp3;
42263   {
42264     try {
42265       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
42266     } CALL_CATCH_EXCEPTION(0);
42267   }
42268
42269   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
42270   return jresult;
42271 }
42272
42273
42274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
42275   float jresult ;
42276   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42277   int arg2 ;
42278   float arg3 ;
42279   Dali::Vector3 *arg4 = 0 ;
42280   float result;
42281
42282   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42283   arg2 = (int)jarg2;
42284   arg3 = (float)jarg3;
42285   arg4 = (Dali::Vector3 *)jarg4;
42286   if (!arg4) {
42287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42288     return 0;
42289   }
42290   {
42291     try {
42292       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
42293     } CALL_CATCH_EXCEPTION(0);
42294   }
42295
42296   jresult = result;
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
42302   unsigned int jresult ;
42303   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42304   Dali::Vector3 arg2 ;
42305   Dali::Vector3 *argp2 ;
42306   unsigned int result;
42307
42308   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42309   argp2 = (Dali::Vector3 *)jarg2;
42310   if (!argp2) {
42311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42312     return 0;
42313   }
42314   arg2 = *argp2;
42315   {
42316     try {
42317       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
42318     } CALL_CATCH_EXCEPTION(0);
42319   }
42320
42321   jresult = result;
42322   return jresult;
42323 }
42324
42325
42326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
42327   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42328   unsigned int arg2 ;
42329   Dali::Vector3 *arg3 = 0 ;
42330   Dali::Vector3 *arg4 = 0 ;
42331
42332   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42333   arg2 = (unsigned int)jarg2;
42334   arg3 = (Dali::Vector3 *)jarg3;
42335   if (!arg3) {
42336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42337     return ;
42338   }
42339   arg4 = (Dali::Vector3 *)jarg4;
42340   if (!arg4) {
42341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
42342     return ;
42343   }
42344   {
42345     try {
42346       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
42347     } CALL_CATCH_EXCEPTION();
42348   }
42349
42350 }
42351
42352
42353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
42354   void * jresult ;
42355   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42356   Dali::Degree result;
42357
42358   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42359   {
42360     try {
42361       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
42362     } CALL_CATCH_EXCEPTION(0);
42363   }
42364
42365   jresult = new Dali::Degree((const Dali::Degree &)result);
42366   return jresult;
42367 }
42368
42369
42370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
42371   float jresult ;
42372   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42373   float result;
42374
42375   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42376   {
42377     try {
42378       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
42379     } CALL_CATCH_EXCEPTION(0);
42380   }
42381
42382   jresult = result;
42383   return jresult;
42384 }
42385
42386
42387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
42388   float jresult ;
42389   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42390   float result;
42391
42392   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42393   {
42394     try {
42395       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
42396     } CALL_CATCH_EXCEPTION(0);
42397   }
42398
42399   jresult = result;
42400   return jresult;
42401 }
42402
42403
42404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
42405   float jresult ;
42406   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42407   float result;
42408
42409   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42410   {
42411     try {
42412       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
42413     } CALL_CATCH_EXCEPTION(0);
42414   }
42415
42416   jresult = result;
42417   return jresult;
42418 }
42419
42420
42421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) {
42422   int jresult ;
42423   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42424   int arg2 ;
42425   int arg3 ;
42426   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
42427   bool arg5 ;
42428   int result;
42429
42430   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42431   arg2 = (int)jarg2;
42432   arg3 = (int)jarg3;
42433   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
42434   arg5 = jarg5 ? true : false;
42435   {
42436     try {
42437       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
42438     } CALL_CATCH_EXCEPTION(0);
42439   }
42440
42441   jresult = result;
42442   return jresult;
42443 }
42444
42445
42446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
42447   float jresult ;
42448   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42449   float result;
42450
42451   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42452   {
42453     try {
42454       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
42455     } CALL_CATCH_EXCEPTION(0);
42456   }
42457
42458   jresult = result;
42459   return jresult;
42460 }
42461
42462
42463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
42464   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42465   Dali::Actor *arg2 = 0 ;
42466   int arg3 ;
42467   Dali::Vector3 *arg4 = 0 ;
42468   Dali::Actor *arg5 = 0 ;
42469
42470   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42471   arg2 = (Dali::Actor *)jarg2;
42472   if (!arg2) {
42473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
42474     return ;
42475   }
42476   arg3 = (int)jarg3;
42477   arg4 = (Dali::Vector3 *)jarg4;
42478   if (!arg4) {
42479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42480     return ;
42481   }
42482   arg5 = (Dali::Actor *)jarg5;
42483   if (!arg5) {
42484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
42485     return ;
42486   }
42487   {
42488     try {
42489       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
42490     } CALL_CATCH_EXCEPTION();
42491   }
42492
42493 }
42494
42495
42496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
42497   void * jresult ;
42498   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42499   int arg2 ;
42500   float arg3 ;
42501   Dali::Vector3 *arg4 = 0 ;
42502   Dali::Vector3 result;
42503
42504   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42505   arg2 = (int)jarg2;
42506   arg3 = (float)jarg3;
42507   arg4 = (Dali::Vector3 *)jarg4;
42508   if (!arg4) {
42509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42510     return 0;
42511   }
42512   {
42513     try {
42514       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
42515     } CALL_CATCH_EXCEPTION(0);
42516   }
42517
42518   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42519   return jresult;
42520 }
42521
42522
42523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
42524   void * jresult ;
42525   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
42526   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42527
42528   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
42529   {
42530     try {
42531       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
42532     } CALL_CATCH_EXCEPTION(0);
42533   }
42534
42535   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42536   return jresult;
42537 }
42538
42539
42540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
42541   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42542
42543   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42544   {
42545     try {
42546       delete arg1;
42547     } CALL_CATCH_EXCEPTION();
42548   }
42549
42550 }
42551
42552
42553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
42554   unsigned int jresult ;
42555   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42556   unsigned int result;
42557
42558   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42559   {
42560     try {
42561       result = (unsigned int)(arg1)->GetNumberOfItems();
42562     } CALL_CATCH_EXCEPTION(0);
42563   }
42564
42565   jresult = result;
42566   return jresult;
42567 }
42568
42569
42570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
42571   void * jresult ;
42572   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42573   unsigned int arg2 ;
42574   Dali::Actor result;
42575
42576   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42577   arg2 = (unsigned int)jarg2;
42578   {
42579     try {
42580       result = (arg1)->NewItem(arg2);
42581     } CALL_CATCH_EXCEPTION(0);
42582   }
42583
42584   jresult = new Dali::Actor((const Dali::Actor &)result);
42585   return jresult;
42586 }
42587
42588
42589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
42590   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42591   unsigned int arg2 ;
42592   Dali::Actor arg3 ;
42593   Dali::Actor *argp3 ;
42594
42595   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42596   arg2 = (unsigned int)jarg2;
42597   argp3 = (Dali::Actor *)jarg3;
42598   if (!argp3) {
42599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42600     return ;
42601   }
42602   arg3 = *argp3;
42603   {
42604     try {
42605       (arg1)->ItemReleased(arg2,arg3);
42606     } CALL_CATCH_EXCEPTION();
42607   }
42608
42609 }
42610
42611
42612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
42613   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42614   unsigned int arg2 ;
42615   Dali::Actor arg3 ;
42616   Dali::Actor *argp3 ;
42617
42618   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42619   arg2 = (unsigned int)jarg2;
42620   argp3 = (Dali::Actor *)jarg3;
42621   if (!argp3) {
42622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42623     return ;
42624   }
42625   arg3 = *argp3;
42626   {
42627     try {
42628       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
42629     } CALL_CATCH_EXCEPTION();
42630   }
42631
42632 }
42633
42634
42635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
42636   void * jresult ;
42637   Dali::Toolkit::ItemFactory *result = 0 ;
42638
42639   {
42640     try {
42641       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
42642     } CALL_CATCH_EXCEPTION(0);
42643   }
42644
42645   jresult = (void *)result;
42646   return jresult;
42647 }
42648
42649
42650 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) {
42651   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
42652   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
42653   if (director) {
42654     director->swig_connect_director(callback0, callback1, callback2);
42655   }
42656 }
42657
42658
42659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
42660   int jresult ;
42661   int result;
42662
42663   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
42664   jresult = (int)result;
42665   return jresult;
42666 }
42667
42668
42669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
42670   int jresult ;
42671   int result;
42672
42673   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
42674   jresult = (int)result;
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
42680   int jresult ;
42681   int result;
42682
42683   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
42684   jresult = (int)result;
42685   return jresult;
42686 }
42687
42688
42689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
42690   int jresult ;
42691   int result;
42692
42693   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
42694   jresult = (int)result;
42695   return jresult;
42696 }
42697
42698
42699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
42700   int jresult ;
42701   int result;
42702
42703   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
42704   jresult = (int)result;
42705   return jresult;
42706 }
42707
42708
42709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
42710   int jresult ;
42711   int result;
42712
42713   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
42714   jresult = (int)result;
42715   return jresult;
42716 }
42717
42718
42719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
42720   int jresult ;
42721   int result;
42722
42723   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
42724   jresult = (int)result;
42725   return jresult;
42726 }
42727
42728
42729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42730   int jresult ;
42731   int result;
42732
42733   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42734   jresult = (int)result;
42735   return jresult;
42736 }
42737
42738
42739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42740   int jresult ;
42741   int result;
42742
42743   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42744   jresult = (int)result;
42745   return jresult;
42746 }
42747
42748
42749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42750   int jresult ;
42751   int result;
42752
42753   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42754   jresult = (int)result;
42755   return jresult;
42756 }
42757
42758
42759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42760   int jresult ;
42761   int result;
42762
42763   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42764   jresult = (int)result;
42765   return jresult;
42766 }
42767
42768
42769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42770   void * jresult ;
42771   Dali::Toolkit::ItemView::Property *result = 0 ;
42772
42773   {
42774     try {
42775       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42776     } CALL_CATCH_EXCEPTION(0);
42777   }
42778
42779   jresult = (void *)result;
42780   return jresult;
42781 }
42782
42783
42784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42785   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42786
42787   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42788   {
42789     try {
42790       delete arg1;
42791     } CALL_CATCH_EXCEPTION();
42792   }
42793
42794 }
42795
42796
42797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42798   void * jresult ;
42799   Dali::Toolkit::ItemView *result = 0 ;
42800
42801   {
42802     try {
42803       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42804     } CALL_CATCH_EXCEPTION(0);
42805   }
42806
42807   jresult = (void *)result;
42808   return jresult;
42809 }
42810
42811
42812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42813   void * jresult ;
42814   Dali::Toolkit::ItemView *arg1 = 0 ;
42815   Dali::Toolkit::ItemView *result = 0 ;
42816
42817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42818   if (!arg1) {
42819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42820     return 0;
42821   }
42822   {
42823     try {
42824       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42825     } CALL_CATCH_EXCEPTION(0);
42826   }
42827
42828   jresult = (void *)result;
42829   return jresult;
42830 }
42831
42832
42833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42834   void * jresult ;
42835   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42836   Dali::Toolkit::ItemView *arg2 = 0 ;
42837   Dali::Toolkit::ItemView *result = 0 ;
42838
42839   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42840   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42841   if (!arg2) {
42842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42843     return 0;
42844   }
42845   {
42846     try {
42847       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42848     } CALL_CATCH_EXCEPTION(0);
42849   }
42850
42851   jresult = (void *)result;
42852   return jresult;
42853 }
42854
42855
42856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42857   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42858
42859   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42860   {
42861     try {
42862       delete arg1;
42863     } CALL_CATCH_EXCEPTION();
42864   }
42865
42866 }
42867
42868
42869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42870   void * jresult ;
42871   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42872   Dali::Toolkit::ItemView result;
42873
42874   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42875   if (!arg1) {
42876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42877     return 0;
42878   }
42879   {
42880     try {
42881       result = Dali::Toolkit::ItemView::New(*arg1);
42882     } CALL_CATCH_EXCEPTION(0);
42883   }
42884
42885   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42886   return jresult;
42887 }
42888
42889
42890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42891   void * jresult ;
42892   Dali::BaseHandle arg1 ;
42893   Dali::BaseHandle *argp1 ;
42894   Dali::Toolkit::ItemView result;
42895
42896   argp1 = (Dali::BaseHandle *)jarg1;
42897   if (!argp1) {
42898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42899     return 0;
42900   }
42901   arg1 = *argp1;
42902   {
42903     try {
42904       result = Dali::Toolkit::ItemView::DownCast(arg1);
42905     } CALL_CATCH_EXCEPTION(0);
42906   }
42907
42908   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42909   return jresult;
42910 }
42911
42912
42913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42914   unsigned int jresult ;
42915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42916   unsigned int result;
42917
42918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42919   {
42920     try {
42921       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42922     } CALL_CATCH_EXCEPTION(0);
42923   }
42924
42925   jresult = result;
42926   return jresult;
42927 }
42928
42929
42930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42932   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42933
42934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42935   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42936   if (!arg2) {
42937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42938     return ;
42939   }
42940   {
42941     try {
42942       (arg1)->AddLayout(*arg2);
42943     } CALL_CATCH_EXCEPTION();
42944   }
42945
42946 }
42947
42948
42949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42950   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42951   unsigned int arg2 ;
42952
42953   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42954   arg2 = (unsigned int)jarg2;
42955   {
42956     try {
42957       (arg1)->RemoveLayout(arg2);
42958     } CALL_CATCH_EXCEPTION();
42959   }
42960
42961 }
42962
42963
42964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42965   void * jresult ;
42966   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42967   unsigned int arg2 ;
42968   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42969
42970   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42971   arg2 = (unsigned int)jarg2;
42972   {
42973     try {
42974       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42975     } CALL_CATCH_EXCEPTION(0);
42976   }
42977
42978   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42979   return jresult;
42980 }
42981
42982
42983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42984   void * jresult ;
42985   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42986   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42987
42988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42989   {
42990     try {
42991       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42992     } CALL_CATCH_EXCEPTION(0);
42993   }
42994
42995   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42996   return jresult;
42997 }
42998
42999
43000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
43001   float jresult ;
43002   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43003   Dali::Toolkit::ItemId arg2 ;
43004   float result;
43005
43006   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43007   arg2 = (Dali::Toolkit::ItemId)jarg2;
43008   {
43009     try {
43010       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
43011     } CALL_CATCH_EXCEPTION(0);
43012   }
43013
43014   jresult = result;
43015   return jresult;
43016 }
43017
43018
43019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
43020   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43021   unsigned int arg2 ;
43022   Dali::Vector3 arg3 ;
43023   float arg4 ;
43024   Dali::Vector3 *argp3 ;
43025
43026   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43027   arg2 = (unsigned int)jarg2;
43028   argp3 = (Dali::Vector3 *)jarg3;
43029   if (!argp3) {
43030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
43031     return ;
43032   }
43033   arg3 = *argp3;
43034   arg4 = (float)jarg4;
43035   {
43036     try {
43037       (arg1)->ActivateLayout(arg2,arg3,arg4);
43038     } CALL_CATCH_EXCEPTION();
43039   }
43040
43041 }
43042
43043
43044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
43045   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43046
43047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43048   {
43049     try {
43050       (arg1)->DeactivateCurrentLayout();
43051     } CALL_CATCH_EXCEPTION();
43052   }
43053
43054 }
43055
43056
43057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
43058   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43059   float arg2 ;
43060
43061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43062   arg2 = (float)jarg2;
43063   {
43064     try {
43065       (arg1)->SetMinimumSwipeSpeed(arg2);
43066     } CALL_CATCH_EXCEPTION();
43067   }
43068
43069 }
43070
43071
43072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
43073   float jresult ;
43074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43075   float result;
43076
43077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43078   {
43079     try {
43080       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
43081     } CALL_CATCH_EXCEPTION(0);
43082   }
43083
43084   jresult = result;
43085   return jresult;
43086 }
43087
43088
43089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
43090   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43091   float arg2 ;
43092
43093   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43094   arg2 = (float)jarg2;
43095   {
43096     try {
43097       (arg1)->SetMinimumSwipeDistance(arg2);
43098     } CALL_CATCH_EXCEPTION();
43099   }
43100
43101 }
43102
43103
43104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
43105   float jresult ;
43106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43107   float result;
43108
43109   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43110   {
43111     try {
43112       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
43113     } CALL_CATCH_EXCEPTION(0);
43114   }
43115
43116   jresult = result;
43117   return jresult;
43118 }
43119
43120
43121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
43122   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43123   float arg2 ;
43124
43125   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43126   arg2 = (float)jarg2;
43127   {
43128     try {
43129       (arg1)->SetWheelScrollDistanceStep(arg2);
43130     } CALL_CATCH_EXCEPTION();
43131   }
43132
43133 }
43134
43135
43136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
43137   float jresult ;
43138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43139   float result;
43140
43141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43142   {
43143     try {
43144       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
43145     } CALL_CATCH_EXCEPTION(0);
43146   }
43147
43148   jresult = result;
43149   return jresult;
43150 }
43151
43152
43153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) {
43154   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43155   bool arg2 ;
43156
43157   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43158   arg2 = jarg2 ? true : false;
43159   {
43160     try {
43161       (arg1)->SetAnchoring(arg2);
43162     } CALL_CATCH_EXCEPTION();
43163   }
43164
43165 }
43166
43167 //// ========================= end of part 3 =============================
43168
43169 //// ========================== start part 4 ===============================
43170
43171
43172 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
43173   bool jresult ;
43174   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43175   bool result;
43176
43177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43178   {
43179     try {
43180       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
43181     } CALL_CATCH_EXCEPTION(0);
43182   }
43183
43184   jresult = result;
43185   return jresult;
43186 }
43187
43188
43189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
43190   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43191   float arg2 ;
43192
43193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43194   arg2 = (float)jarg2;
43195   {
43196     try {
43197       (arg1)->SetAnchoringDuration(arg2);
43198     } CALL_CATCH_EXCEPTION();
43199   }
43200
43201 }
43202
43203
43204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
43205   float jresult ;
43206   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43207   float result;
43208
43209   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43210   {
43211     try {
43212       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
43213     } CALL_CATCH_EXCEPTION(0);
43214   }
43215
43216   jresult = result;
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
43222   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43223   Dali::Toolkit::ItemId arg2 ;
43224   float arg3 ;
43225
43226   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43227   arg2 = (Dali::Toolkit::ItemId)jarg2;
43228   arg3 = (float)jarg3;
43229   {
43230     try {
43231       (arg1)->ScrollToItem(arg2,arg3);
43232     } CALL_CATCH_EXCEPTION();
43233   }
43234
43235 }
43236
43237
43238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
43239   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43240   float arg2 ;
43241
43242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43243   arg2 = (float)jarg2;
43244   {
43245     try {
43246       (arg1)->SetRefreshInterval(arg2);
43247     } CALL_CATCH_EXCEPTION();
43248   }
43249
43250 }
43251
43252
43253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
43254   float jresult ;
43255   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43256   float result;
43257
43258   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43259   {
43260     try {
43261       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
43262     } CALL_CATCH_EXCEPTION(0);
43263   }
43264
43265   jresult = result;
43266   return jresult;
43267 }
43268
43269
43270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
43271   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43272
43273   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43274   {
43275     try {
43276       (arg1)->Refresh();
43277     } CALL_CATCH_EXCEPTION();
43278   }
43279
43280 }
43281
43282
43283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
43284   void * jresult ;
43285   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43286   Dali::Toolkit::ItemId arg2 ;
43287   Dali::Actor result;
43288
43289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43290   arg2 = (Dali::Toolkit::ItemId)jarg2;
43291   {
43292     try {
43293       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
43294     } CALL_CATCH_EXCEPTION(0);
43295   }
43296
43297   jresult = new Dali::Actor((const Dali::Actor &)result);
43298   return jresult;
43299 }
43300
43301
43302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
43303   unsigned int jresult ;
43304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43305   Dali::Actor arg2 ;
43306   Dali::Actor *argp2 ;
43307   Dali::Toolkit::ItemId result;
43308
43309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43310   argp2 = (Dali::Actor *)jarg2;
43311   if (!argp2) {
43312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43313     return 0;
43314   }
43315   arg2 = *argp2;
43316   {
43317     try {
43318       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
43319     } CALL_CATCH_EXCEPTION(0);
43320   }
43321
43322   jresult = result;
43323   return jresult;
43324 }
43325
43326
43327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
43328   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43329   Dali::Toolkit::Item arg2 ;
43330   float arg3 ;
43331   Dali::Toolkit::Item *argp2 ;
43332
43333   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43334   argp2 = (Dali::Toolkit::Item *)jarg2;
43335   if (!argp2) {
43336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
43337     return ;
43338   }
43339   arg2 = *argp2;
43340   arg3 = (float)jarg3;
43341   {
43342     try {
43343       (arg1)->InsertItem(arg2,arg3);
43344     } CALL_CATCH_EXCEPTION();
43345   }
43346
43347 }
43348
43349
43350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
43351   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43352   Dali::Toolkit::ItemContainer *arg2 = 0 ;
43353   float arg3 ;
43354
43355   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43356   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
43357   if (!arg2) {
43358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
43359     return ;
43360   }
43361   arg3 = (float)jarg3;
43362   {
43363     try {
43364       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
43365     } CALL_CATCH_EXCEPTION();
43366   }
43367
43368 }
43369
43370
43371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
43372   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43373   Dali::Toolkit::ItemId arg2 ;
43374   float arg3 ;
43375
43376   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43377   arg2 = (Dali::Toolkit::ItemId)jarg2;
43378   arg3 = (float)jarg3;
43379   {
43380     try {
43381       (arg1)->RemoveItem(arg2,arg3);
43382     } CALL_CATCH_EXCEPTION();
43383   }
43384
43385 }
43386
43387
43388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
43389   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43390   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
43391   float arg3 ;
43392
43393   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43394   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
43395   if (!arg2) {
43396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
43397     return ;
43398   }
43399   arg3 = (float)jarg3;
43400   {
43401     try {
43402       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
43403     } CALL_CATCH_EXCEPTION();
43404   }
43405
43406 }
43407
43408
43409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
43410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43411   Dali::Toolkit::Item arg2 ;
43412   float arg3 ;
43413   Dali::Toolkit::Item *argp2 ;
43414
43415   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43416   argp2 = (Dali::Toolkit::Item *)jarg2;
43417   if (!argp2) {
43418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
43419     return ;
43420   }
43421   arg2 = *argp2;
43422   arg3 = (float)jarg3;
43423   {
43424     try {
43425       (arg1)->ReplaceItem(arg2,arg3);
43426     } CALL_CATCH_EXCEPTION();
43427   }
43428
43429 }
43430
43431
43432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
43433   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43434   Dali::Toolkit::ItemContainer *arg2 = 0 ;
43435   float arg3 ;
43436
43437   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43438   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
43439   if (!arg2) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
43441     return ;
43442   }
43443   arg3 = (float)jarg3;
43444   {
43445     try {
43446       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
43447     } CALL_CATCH_EXCEPTION();
43448   }
43449
43450 }
43451
43452
43453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
43454   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43455   Dali::Vector3 *arg2 = 0 ;
43456
43457   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43458   arg2 = (Dali::Vector3 *)jarg2;
43459   if (!arg2) {
43460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43461     return ;
43462   }
43463   {
43464     try {
43465       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
43466     } CALL_CATCH_EXCEPTION();
43467   }
43468
43469 }
43470
43471
43472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
43473   void * jresult ;
43474   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43475   Dali::Vector3 result;
43476
43477   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43478   {
43479     try {
43480       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
43481     } CALL_CATCH_EXCEPTION(0);
43482   }
43483
43484   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43485   return jresult;
43486 }
43487
43488
43489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
43490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43491   Dali::Vector3 *arg2 = 0 ;
43492
43493   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43494   arg2 = (Dali::Vector3 *)jarg2;
43495   if (!arg2) {
43496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43497     return ;
43498   }
43499   {
43500     try {
43501       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
43502     } CALL_CATCH_EXCEPTION();
43503   }
43504
43505 }
43506
43507
43508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
43509   void * jresult ;
43510   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43511   Dali::Vector3 result;
43512
43513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43514   {
43515     try {
43516       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
43517     } CALL_CATCH_EXCEPTION(0);
43518   }
43519
43520   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43521   return jresult;
43522 }
43523
43524
43525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
43526   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43527   Dali::Toolkit::ItemRange *arg2 = 0 ;
43528
43529   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43530   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43531   if (!arg2) {
43532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
43533     return ;
43534   }
43535   {
43536     try {
43537       (arg1)->GetItemsRange(*arg2);
43538     } CALL_CATCH_EXCEPTION();
43539   }
43540
43541 }
43542
43543
43544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
43545   void * jresult ;
43546   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43547   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
43548
43549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43550   {
43551     try {
43552       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
43553     } CALL_CATCH_EXCEPTION(0);
43554   }
43555
43556   jresult = (void *)result;
43557   return jresult;
43558 }
43559
43560
43561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
43562   Dali::Vector3 *arg1 = 0 ;
43563   PropertyInputContainer *arg2 = 0 ;
43564
43565   arg1 = (Dali::Vector3 *)jarg1;
43566   if (!arg1) {
43567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43568     return ;
43569   }
43570   arg2 = (PropertyInputContainer *)jarg2;
43571   if (!arg2) {
43572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43573     return ;
43574   }
43575   {
43576     try {
43577       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43578     } CALL_CATCH_EXCEPTION();
43579   }
43580
43581 }
43582
43583
43584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
43585   Dali::Vector3 *arg1 = 0 ;
43586   PropertyInputContainer *arg2 = 0 ;
43587
43588   arg1 = (Dali::Vector3 *)jarg1;
43589   if (!arg1) {
43590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43591     return ;
43592   }
43593   arg2 = (PropertyInputContainer *)jarg2;
43594   if (!arg2) {
43595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43596     return ;
43597   }
43598   {
43599     try {
43600       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43601     } CALL_CATCH_EXCEPTION();
43602   }
43603
43604 }
43605
43606
43607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
43608   void * jresult ;
43609   Dali::Toolkit::ScrollViewEffect *result = 0 ;
43610
43611   {
43612     try {
43613       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
43614     } CALL_CATCH_EXCEPTION(0);
43615   }
43616
43617   jresult = (void *)result;
43618   return jresult;
43619 }
43620
43621
43622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
43623   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
43624
43625   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
43626   {
43627     try {
43628       delete arg1;
43629     } CALL_CATCH_EXCEPTION();
43630   }
43631
43632 }
43633
43634
43635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
43636   void * jresult ;
43637   Dali::Path arg1 ;
43638   Dali::Vector3 *arg2 = 0 ;
43639   Dali::Property::Index arg3 ;
43640   Dali::Vector3 *arg4 = 0 ;
43641   unsigned int arg5 ;
43642   Dali::Path *argp1 ;
43643   Dali::Toolkit::ScrollViewPagePathEffect result;
43644
43645   argp1 = (Dali::Path *)jarg1;
43646   if (!argp1) {
43647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
43648     return 0;
43649   }
43650   arg1 = *argp1;
43651   arg2 = (Dali::Vector3 *)jarg2;
43652   if (!arg2) {
43653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43654     return 0;
43655   }
43656   arg3 = (Dali::Property::Index)jarg3;
43657   arg4 = (Dali::Vector3 *)jarg4;
43658   if (!arg4) {
43659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43660     return 0;
43661   }
43662   arg5 = (unsigned int)jarg5;
43663   {
43664     try {
43665       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
43666     } CALL_CATCH_EXCEPTION(0);
43667   }
43668
43669   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
43675   void * jresult ;
43676   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
43677
43678   {
43679     try {
43680       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
43681     } CALL_CATCH_EXCEPTION(0);
43682   }
43683
43684   jresult = (void *)result;
43685   return jresult;
43686 }
43687
43688
43689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
43690   void * jresult ;
43691   Dali::BaseHandle arg1 ;
43692   Dali::BaseHandle *argp1 ;
43693   Dali::Toolkit::ScrollViewPagePathEffect result;
43694
43695   argp1 = (Dali::BaseHandle *)jarg1;
43696   if (!argp1) {
43697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43698     return 0;
43699   }
43700   arg1 = *argp1;
43701   {
43702     try {
43703       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
43704     } CALL_CATCH_EXCEPTION(0);
43705   }
43706
43707   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
43713   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43714   Dali::Actor arg2 ;
43715   unsigned int arg3 ;
43716   Dali::Actor *argp2 ;
43717
43718   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43719   argp2 = (Dali::Actor *)jarg2;
43720   if (!argp2) {
43721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43722     return ;
43723   }
43724   arg2 = *argp2;
43725   arg3 = (unsigned int)jarg3;
43726   {
43727     try {
43728       (arg1)->ApplyToPage(arg2,arg3);
43729     } CALL_CATCH_EXCEPTION();
43730   }
43731
43732 }
43733
43734
43735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43736   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43737
43738   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43739   {
43740     try {
43741       delete arg1;
43742     } CALL_CATCH_EXCEPTION();
43743   }
43744
43745 }
43746
43747
43748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43749   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43750   Dali::Toolkit::ClampState arg2 ;
43751
43752   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43753   arg2 = (Dali::Toolkit::ClampState)jarg2;
43754   if (arg1) (arg1)->x = arg2;
43755 }
43756
43757
43758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43759   int jresult ;
43760   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43761   Dali::Toolkit::ClampState result;
43762
43763   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43764   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43765   jresult = (int)result;
43766   return jresult;
43767 }
43768
43769
43770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43771   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43772   Dali::Toolkit::ClampState arg2 ;
43773
43774   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43775   arg2 = (Dali::Toolkit::ClampState)jarg2;
43776   if (arg1) (arg1)->y = arg2;
43777 }
43778
43779
43780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43781   int jresult ;
43782   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43783   Dali::Toolkit::ClampState result;
43784
43785   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43786   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43787   jresult = (int)result;
43788   return jresult;
43789 }
43790
43791
43792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43793   void * jresult ;
43794   Dali::Toolkit::ClampState2D *result = 0 ;
43795
43796   {
43797     try {
43798       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43799     } CALL_CATCH_EXCEPTION(0);
43800   }
43801
43802   jresult = (void *)result;
43803   return jresult;
43804 }
43805
43806
43807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43808   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43809
43810   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43811   {
43812     try {
43813       delete arg1;
43814     } CALL_CATCH_EXCEPTION();
43815   }
43816
43817 }
43818
43819
43820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) {
43821   void * jresult ;
43822   float arg1 ;
43823   float arg2 ;
43824   bool arg3 ;
43825   Dali::Toolkit::RulerDomain *result = 0 ;
43826
43827   arg1 = (float)jarg1;
43828   arg2 = (float)jarg2;
43829   arg3 = jarg3 ? true : false;
43830   {
43831     try {
43832       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43833     } CALL_CATCH_EXCEPTION(0);
43834   }
43835
43836   jresult = (void *)result;
43837   return jresult;
43838 }
43839
43840
43841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43842   void * jresult ;
43843   float arg1 ;
43844   float arg2 ;
43845   Dali::Toolkit::RulerDomain *result = 0 ;
43846
43847   arg1 = (float)jarg1;
43848   arg2 = (float)jarg2;
43849   {
43850     try {
43851       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43852     } CALL_CATCH_EXCEPTION(0);
43853   }
43854
43855   jresult = (void *)result;
43856   return jresult;
43857 }
43858
43859
43860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43861   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43862   float arg2 ;
43863
43864   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43865   arg2 = (float)jarg2;
43866   if (arg1) (arg1)->min = arg2;
43867 }
43868
43869
43870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43871   float jresult ;
43872   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43873   float result;
43874
43875   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43876   result = (float) ((arg1)->min);
43877   jresult = result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43883   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43884   float arg2 ;
43885
43886   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43887   arg2 = (float)jarg2;
43888   if (arg1) (arg1)->max = arg2;
43889 }
43890
43891
43892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43893   float jresult ;
43894   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43895   float result;
43896
43897   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43898   result = (float) ((arg1)->max);
43899   jresult = result;
43900   return jresult;
43901 }
43902
43903
43904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) {
43905   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43906   bool arg2 ;
43907
43908   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43909   arg2 = jarg2 ? true : false;
43910   if (arg1) (arg1)->enabled = arg2;
43911 }
43912
43913
43914 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43915   bool jresult ;
43916   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43917   bool result;
43918
43919   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43920   result = (bool) ((arg1)->enabled);
43921   jresult = result;
43922   return jresult;
43923 }
43924
43925
43926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43927   float jresult ;
43928   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43929   float arg2 ;
43930   float arg3 ;
43931   float arg4 ;
43932   float result;
43933
43934   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43935   arg2 = (float)jarg2;
43936   arg3 = (float)jarg3;
43937   arg4 = (float)jarg4;
43938   {
43939     try {
43940       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43941     } CALL_CATCH_EXCEPTION(0);
43942   }
43943
43944   jresult = result;
43945   return jresult;
43946 }
43947
43948
43949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43950   float jresult ;
43951   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43952   float arg2 ;
43953   float arg3 ;
43954   float result;
43955
43956   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43957   arg2 = (float)jarg2;
43958   arg3 = (float)jarg3;
43959   {
43960     try {
43961       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43962     } CALL_CATCH_EXCEPTION(0);
43963   }
43964
43965   jresult = result;
43966   return jresult;
43967 }
43968
43969
43970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43971   float jresult ;
43972   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43973   float arg2 ;
43974   float result;
43975
43976   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43977   arg2 = (float)jarg2;
43978   {
43979     try {
43980       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43981     } CALL_CATCH_EXCEPTION(0);
43982   }
43983
43984   jresult = result;
43985   return jresult;
43986 }
43987
43988
43989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43990   float jresult ;
43991   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43992   float arg2 ;
43993   float arg3 ;
43994   float arg4 ;
43995   Dali::Toolkit::ClampState *arg5 = 0 ;
43996   float result;
43997
43998   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43999   arg2 = (float)jarg2;
44000   arg3 = (float)jarg3;
44001   arg4 = (float)jarg4;
44002   arg5 = (Dali::Toolkit::ClampState *)jarg5;
44003   if (!arg5) {
44004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44005     return 0;
44006   }
44007   {
44008     try {
44009       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
44010     } CALL_CATCH_EXCEPTION(0);
44011   }
44012
44013   jresult = result;
44014   return jresult;
44015 }
44016
44017
44018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
44019   float jresult ;
44020   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44021   float result;
44022
44023   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44024   {
44025     try {
44026       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
44027     } CALL_CATCH_EXCEPTION(0);
44028   }
44029
44030   jresult = result;
44031   return jresult;
44032 }
44033
44034
44035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
44036   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
44037
44038   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
44039   {
44040     try {
44041       delete arg1;
44042     } CALL_CATCH_EXCEPTION();
44043   }
44044
44045 }
44046
44047
44048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
44049   float jresult ;
44050   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44051   float arg2 ;
44052   float arg3 ;
44053   float result;
44054
44055   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44056   arg2 = (float)jarg2;
44057   arg3 = (float)jarg3;
44058   {
44059     try {
44060       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
44061     } CALL_CATCH_EXCEPTION(0);
44062   }
44063
44064   jresult = result;
44065   return jresult;
44066 }
44067
44068
44069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
44070   float jresult ;
44071   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44072   float arg2 ;
44073   float result;
44074
44075   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44076   arg2 = (float)jarg2;
44077   {
44078     try {
44079       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
44080     } CALL_CATCH_EXCEPTION(0);
44081   }
44082
44083   jresult = result;
44084   return jresult;
44085 }
44086
44087
44088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
44089   float jresult ;
44090   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44091   unsigned int arg2 ;
44092   unsigned int *arg3 = 0 ;
44093   bool arg4 ;
44094   float result;
44095
44096   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44097   arg2 = (unsigned int)jarg2;
44098   arg3 = (unsigned int *)jarg3;
44099   arg4 = jarg4 ? true : false;
44100   {
44101     try {
44102       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44103     } CALL_CATCH_EXCEPTION(0);
44104   }
44105
44106   jresult = result;
44107   return jresult;
44108 }
44109
44110
44111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
44112   unsigned int jresult ;
44113   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44114   float arg2 ;
44115   bool arg3 ;
44116   unsigned int result;
44117
44118   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44119   arg2 = (float)jarg2;
44120   arg3 = jarg3 ? true : false;
44121   {
44122     try {
44123       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
44124     } CALL_CATCH_EXCEPTION(0);
44125   }
44126
44127   jresult = result;
44128   return jresult;
44129 }
44130
44131
44132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
44133   unsigned int jresult ;
44134   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44135   unsigned int result;
44136
44137   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44138   {
44139     try {
44140       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
44141     } CALL_CATCH_EXCEPTION(0);
44142   }
44143
44144   jresult = result;
44145   return jresult;
44146 }
44147
44148
44149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
44150   int jresult ;
44151   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44152   Dali::Toolkit::Ruler::RulerType result;
44153
44154   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44155   {
44156     try {
44157       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
44158     } CALL_CATCH_EXCEPTION(0);
44159   }
44160
44161   jresult = (int)result;
44162   return jresult;
44163 }
44164
44165
44166 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
44167   bool jresult ;
44168   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44169   bool result;
44170
44171   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44172   {
44173     try {
44174       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
44175     } CALL_CATCH_EXCEPTION(0);
44176   }
44177
44178   jresult = result;
44179   return jresult;
44180 }
44181
44182
44183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
44184   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44185
44186   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44187   {
44188     try {
44189       (arg1)->Enable();
44190     } CALL_CATCH_EXCEPTION();
44191   }
44192
44193 }
44194
44195
44196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
44197   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44198
44199   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44200   {
44201     try {
44202       (arg1)->Disable();
44203     } CALL_CATCH_EXCEPTION();
44204   }
44205
44206 }
44207
44208
44209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
44210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44211   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
44212   Dali::Toolkit::RulerDomain *argp2 ;
44213
44214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44215   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
44216   if (!argp2) {
44217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
44218     return ;
44219   }
44220   arg2 = *argp2;
44221   {
44222     try {
44223       (arg1)->SetDomain(arg2);
44224     } CALL_CATCH_EXCEPTION();
44225   }
44226
44227 }
44228
44229
44230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
44231   void * jresult ;
44232   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44233   Dali::Toolkit::RulerDomain *result = 0 ;
44234
44235   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44236   {
44237     try {
44238       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
44239     } CALL_CATCH_EXCEPTION(0);
44240   }
44241
44242   jresult = (void *)result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
44248   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44249
44250   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44251   {
44252     try {
44253       (arg1)->DisableDomain();
44254     } CALL_CATCH_EXCEPTION();
44255   }
44256
44257 }
44258
44259
44260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
44261   float jresult ;
44262   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44263   float arg2 ;
44264   float arg3 ;
44265   float arg4 ;
44266   float result;
44267
44268   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44269   arg2 = (float)jarg2;
44270   arg3 = (float)jarg3;
44271   arg4 = (float)jarg4;
44272   {
44273     try {
44274       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
44275     } CALL_CATCH_EXCEPTION(0);
44276   }
44277
44278   jresult = result;
44279   return jresult;
44280 }
44281
44282
44283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
44284   float jresult ;
44285   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44286   float arg2 ;
44287   float arg3 ;
44288   float result;
44289
44290   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44291   arg2 = (float)jarg2;
44292   arg3 = (float)jarg3;
44293   {
44294     try {
44295       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
44296     } CALL_CATCH_EXCEPTION(0);
44297   }
44298
44299   jresult = result;
44300   return jresult;
44301 }
44302
44303
44304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
44305   float jresult ;
44306   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44307   float arg2 ;
44308   float result;
44309
44310   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44311   arg2 = (float)jarg2;
44312   {
44313     try {
44314       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
44315     } CALL_CATCH_EXCEPTION(0);
44316   }
44317
44318   jresult = result;
44319   return jresult;
44320 }
44321
44322
44323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
44324   float jresult ;
44325   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44326   float arg2 ;
44327   float arg3 ;
44328   float arg4 ;
44329   Dali::Toolkit::ClampState *arg5 = 0 ;
44330   float result;
44331
44332   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44333   arg2 = (float)jarg2;
44334   arg3 = (float)jarg3;
44335   arg4 = (float)jarg4;
44336   arg5 = (Dali::Toolkit::ClampState *)jarg5;
44337   if (!arg5) {
44338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44339     return 0;
44340   }
44341   {
44342     try {
44343       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
44344     } CALL_CATCH_EXCEPTION(0);
44345   }
44346
44347   jresult = result;
44348   return jresult;
44349 }
44350
44351
44352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44353   float jresult ;
44354   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44355   float arg2 ;
44356   float arg3 ;
44357   float arg4 ;
44358   float arg5 ;
44359   float result;
44360
44361   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44362   arg2 = (float)jarg2;
44363   arg3 = (float)jarg3;
44364   arg4 = (float)jarg4;
44365   arg5 = (float)jarg5;
44366   {
44367     try {
44368       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
44369     } CALL_CATCH_EXCEPTION(0);
44370   }
44371
44372   jresult = result;
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
44378   float jresult ;
44379   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44380   float arg2 ;
44381   float arg3 ;
44382   float arg4 ;
44383   float result;
44384
44385   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44386   arg2 = (float)jarg2;
44387   arg3 = (float)jarg3;
44388   arg4 = (float)jarg4;
44389   {
44390     try {
44391       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
44392     } CALL_CATCH_EXCEPTION(0);
44393   }
44394
44395   jresult = result;
44396   return jresult;
44397 }
44398
44399
44400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
44401   float jresult ;
44402   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44403   float arg2 ;
44404   float arg3 ;
44405   float result;
44406
44407   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44408   arg2 = (float)jarg2;
44409   arg3 = (float)jarg3;
44410   {
44411     try {
44412       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
44413     } CALL_CATCH_EXCEPTION(0);
44414   }
44415
44416   jresult = result;
44417   return jresult;
44418 }
44419
44420
44421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
44422   float jresult ;
44423   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44424   float arg2 ;
44425   float result;
44426
44427   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44428   arg2 = (float)jarg2;
44429   {
44430     try {
44431       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
44432     } CALL_CATCH_EXCEPTION(0);
44433   }
44434
44435   jresult = result;
44436   return jresult;
44437 }
44438
44439
44440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
44441   float jresult ;
44442   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
44443   float arg2 ;
44444   float arg3 ;
44445   float arg4 ;
44446   float arg5 ;
44447   Dali::Toolkit::ClampState *arg6 = 0 ;
44448   float result;
44449
44450   arg1 = (Dali::Toolkit::Ruler *)jarg1;
44451   arg2 = (float)jarg2;
44452   arg3 = (float)jarg3;
44453   arg4 = (float)jarg4;
44454   arg5 = (float)jarg5;
44455   arg6 = (Dali::Toolkit::ClampState *)jarg6;
44456   if (!arg6) {
44457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
44458     return 0;
44459   }
44460   {
44461     try {
44462       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
44463     } CALL_CATCH_EXCEPTION(0);
44464   }
44465
44466   jresult = result;
44467   return jresult;
44468 }
44469
44470
44471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
44472   void * jresult ;
44473   Dali::Toolkit::DefaultRuler *result = 0 ;
44474
44475   {
44476     try {
44477       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
44478     } CALL_CATCH_EXCEPTION(0);
44479   }
44480
44481   jresult = (void *)result;
44482   return jresult;
44483 }
44484
44485
44486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44487   float jresult ;
44488   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44489   float arg2 ;
44490   float arg3 ;
44491   float result;
44492
44493   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44494   arg2 = (float)jarg2;
44495   arg3 = (float)jarg3;
44496   {
44497     try {
44498       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
44499     } CALL_CATCH_EXCEPTION(0);
44500   }
44501
44502   jresult = result;
44503   return jresult;
44504 }
44505
44506
44507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
44508   float jresult ;
44509   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44510   unsigned int arg2 ;
44511   unsigned int *arg3 = 0 ;
44512   bool arg4 ;
44513   float result;
44514
44515   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44516   arg2 = (unsigned int)jarg2;
44517   arg3 = (unsigned int *)jarg3;
44518   arg4 = jarg4 ? true : false;
44519   {
44520     try {
44521       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44522     } CALL_CATCH_EXCEPTION(0);
44523   }
44524
44525   jresult = result;
44526   return jresult;
44527 }
44528
44529
44530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
44531   unsigned int jresult ;
44532   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44533   float arg2 ;
44534   bool arg3 ;
44535   unsigned int result;
44536
44537   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44538   arg2 = (float)jarg2;
44539   arg3 = jarg3 ? true : false;
44540   {
44541     try {
44542       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44543     } CALL_CATCH_EXCEPTION(0);
44544   }
44545
44546   jresult = result;
44547   return jresult;
44548 }
44549
44550
44551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
44552   unsigned int jresult ;
44553   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44554   unsigned int result;
44555
44556   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44557   {
44558     try {
44559       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
44560     } CALL_CATCH_EXCEPTION(0);
44561   }
44562
44563   jresult = result;
44564   return jresult;
44565 }
44566
44567
44568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
44569   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44570
44571   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44572   {
44573     try {
44574       delete arg1;
44575     } CALL_CATCH_EXCEPTION();
44576   }
44577
44578 }
44579
44580
44581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
44582   void * jresult ;
44583   float arg1 ;
44584   Dali::Toolkit::FixedRuler *result = 0 ;
44585
44586   arg1 = (float)jarg1;
44587   {
44588     try {
44589       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
44590     } CALL_CATCH_EXCEPTION(0);
44591   }
44592
44593   jresult = (void *)result;
44594   return jresult;
44595 }
44596
44597
44598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
44599   void * jresult ;
44600   Dali::Toolkit::FixedRuler *result = 0 ;
44601
44602   {
44603     try {
44604       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
44605     } CALL_CATCH_EXCEPTION(0);
44606   }
44607
44608   jresult = (void *)result;
44609   return jresult;
44610 }
44611
44612
44613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44614   float jresult ;
44615   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44616   float arg2 ;
44617   float arg3 ;
44618   float result;
44619
44620   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44621   arg2 = (float)jarg2;
44622   arg3 = (float)jarg3;
44623   {
44624     try {
44625       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
44626     } CALL_CATCH_EXCEPTION(0);
44627   }
44628
44629   jresult = result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
44635   float jresult ;
44636   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44637   unsigned int arg2 ;
44638   unsigned int *arg3 = 0 ;
44639   bool arg4 ;
44640   float result;
44641
44642   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44643   arg2 = (unsigned int)jarg2;
44644   arg3 = (unsigned int *)jarg3;
44645   arg4 = jarg4 ? true : false;
44646   {
44647     try {
44648       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44649     } CALL_CATCH_EXCEPTION(0);
44650   }
44651
44652   jresult = result;
44653   return jresult;
44654 }
44655
44656
44657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
44658   unsigned int jresult ;
44659   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44660   float arg2 ;
44661   bool arg3 ;
44662   unsigned int result;
44663
44664   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44665   arg2 = (float)jarg2;
44666   arg3 = jarg3 ? true : false;
44667   {
44668     try {
44669       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44670     } CALL_CATCH_EXCEPTION(0);
44671   }
44672
44673   jresult = result;
44674   return jresult;
44675 }
44676
44677
44678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
44679   unsigned int jresult ;
44680   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44681   unsigned int result;
44682
44683   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44684   {
44685     try {
44686       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
44687     } CALL_CATCH_EXCEPTION(0);
44688   }
44689
44690   jresult = result;
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
44696   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44697
44698   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44699   {
44700     try {
44701       delete arg1;
44702     } CALL_CATCH_EXCEPTION();
44703   }
44704
44705 }
44706
44707
44708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
44709   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44710   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44711
44712   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44713   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44714   if (arg1) (arg1)->scale = *arg2;
44715 }
44716
44717
44718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
44719   void * jresult ;
44720   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44721   Dali::Toolkit::ClampState2D *result = 0 ;
44722
44723   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44724   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
44725   jresult = (void *)result;
44726   return jresult;
44727 }
44728
44729
44730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44731   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44732   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44733
44734   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44735   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44736   if (arg1) (arg1)->position = *arg2;
44737 }
44738
44739
44740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44741   void * jresult ;
44742   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44743   Dali::Toolkit::ClampState2D *result = 0 ;
44744
44745   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44746   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44747   jresult = (void *)result;
44748   return jresult;
44749 }
44750
44751
44752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44753   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44754   Dali::Toolkit::ClampState arg2 ;
44755
44756   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44757   arg2 = (Dali::Toolkit::ClampState)jarg2;
44758   if (arg1) (arg1)->rotation = arg2;
44759 }
44760
44761
44762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44763   int jresult ;
44764   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44765   Dali::Toolkit::ClampState result;
44766
44767   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44768   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44769   jresult = (int)result;
44770   return jresult;
44771 }
44772
44773
44774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44775   void * jresult ;
44776   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44777
44778   {
44779     try {
44780       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44781     } CALL_CATCH_EXCEPTION(0);
44782   }
44783
44784   jresult = (void *)result;
44785   return jresult;
44786 }
44787
44788
44789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44790   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44791
44792   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44793   {
44794     try {
44795       delete arg1;
44796     } CALL_CATCH_EXCEPTION();
44797   }
44798
44799 }
44800
44801
44802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44803   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44804   Dali::Toolkit::SnapType arg2 ;
44805
44806   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44807   arg2 = (Dali::Toolkit::SnapType)jarg2;
44808   if (arg1) (arg1)->type = arg2;
44809 }
44810
44811
44812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44813   int jresult ;
44814   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44815   Dali::Toolkit::SnapType result;
44816
44817   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44818   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44819   jresult = (int)result;
44820   return jresult;
44821 }
44822
44823
44824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44825   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44826   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44827
44828   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44829   arg2 = (Dali::Vector2 *)jarg2;
44830   if (arg1) (arg1)->position = *arg2;
44831 }
44832
44833
44834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44835   void * jresult ;
44836   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44837   Dali::Vector2 *result = 0 ;
44838
44839   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44840   result = (Dali::Vector2 *)& ((arg1)->position);
44841   jresult = (void *)result;
44842   return jresult;
44843 }
44844
44845
44846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44847   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44848   float arg2 ;
44849
44850   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44851   arg2 = (float)jarg2;
44852   if (arg1) (arg1)->duration = arg2;
44853 }
44854
44855
44856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44857   float jresult ;
44858   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44859   float result;
44860
44861   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44862   result = (float) ((arg1)->duration);
44863   jresult = result;
44864   return jresult;
44865 }
44866
44867
44868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44869   void * jresult ;
44870   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44871
44872   {
44873     try {
44874       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44875     } CALL_CATCH_EXCEPTION(0);
44876   }
44877
44878   jresult = (void *)result;
44879   return jresult;
44880 }
44881
44882
44883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44884   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44885
44886   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44887   {
44888     try {
44889       delete arg1;
44890     } CALL_CATCH_EXCEPTION();
44891   }
44892
44893 }
44894
44895
44896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44897   int jresult ;
44898   int result;
44899
44900   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44901   jresult = (int)result;
44902   return jresult;
44903 }
44904
44905
44906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44907   int jresult ;
44908   int result;
44909
44910   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44911   jresult = (int)result;
44912   return jresult;
44913 }
44914
44915
44916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44917   int jresult ;
44918   int result;
44919
44920   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44921   jresult = (int)result;
44922   return jresult;
44923 }
44924
44925
44926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44927   int jresult ;
44928   int result;
44929
44930   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44931   jresult = (int)result;
44932   return jresult;
44933 }
44934
44935
44936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44937   int jresult ;
44938   int result;
44939
44940   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44941   jresult = (int)result;
44942   return jresult;
44943 }
44944
44945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44946   int jresult ;
44947   int result;
44948
44949   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44950   jresult = (int)result;
44951   return jresult;
44952 }
44953
44954
44955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44956   int jresult ;
44957   int result;
44958
44959   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44960   jresult = (int)result;
44961   return jresult;
44962 }
44963
44964
44965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44966   int jresult ;
44967   int result;
44968
44969   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44970   jresult = (int)result;
44971   return jresult;
44972 }
44973
44974
44975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44976   int jresult ;
44977   int result;
44978
44979   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44980   jresult = (int)result;
44981   return jresult;
44982 }
44983
44984
44985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44986   int jresult ;
44987   int result;
44988
44989   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44990   jresult = (int)result;
44991   return jresult;
44992 }
44993
44994
44995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44996   int jresult ;
44997   int result;
44998
44999   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
45000   jresult = (int)result;
45001   return jresult;
45002 }
45003
45004
45005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
45006   int jresult ;
45007   int result;
45008
45009   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
45010   jresult = (int)result;
45011   return jresult;
45012 }
45013
45014
45015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
45016   int jresult ;
45017   int result;
45018
45019   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
45020   jresult = (int)result;
45021   return jresult;
45022 }
45023
45024
45025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
45026   int jresult ;
45027   int result;
45028
45029   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
45030   jresult = (int)result;
45031   return jresult;
45032 }
45033
45034
45035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
45036   int jresult ;
45037   int result;
45038
45039   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
45040   jresult = (int)result;
45041   return jresult;
45042 }
45043
45044
45045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
45046   int jresult ;
45047   int result;
45048
45049   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
45050   jresult = (int)result;
45051   return jresult;
45052 }
45053
45054
45055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
45056   int jresult ;
45057   int result;
45058
45059   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
45060   jresult = (int)result;
45061   return jresult;
45062 }
45063
45064
45065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
45066   int jresult ;
45067   int result;
45068
45069   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
45070   jresult = (int)result;
45071   return jresult;
45072 }
45073
45074
45075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
45076   int jresult ;
45077   int result;
45078
45079   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
45080   jresult = (int)result;
45081   return jresult;
45082 }
45083
45084
45085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
45086   int jresult ;
45087   int result;
45088
45089   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
45090   jresult = (int)result;
45091   return jresult;
45092 }
45093
45094
45095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
45096   int jresult ;
45097   int result;
45098
45099   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
45100   jresult = (int)result;
45101   return jresult;
45102 }
45103
45104
45105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
45106   int jresult ;
45107   int result;
45108
45109   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
45110   jresult = (int)result;
45111   return jresult;
45112 }
45113
45114
45115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
45116   int jresult ;
45117   int result;
45118
45119   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
45120   jresult = (int)result;
45121   return jresult;
45122 }
45123
45124
45125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
45126   int jresult ;
45127   int result;
45128
45129   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
45130   jresult = (int)result;
45131   return jresult;
45132 }
45133
45134
45135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
45136   int jresult ;
45137   int result;
45138
45139   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
45140   jresult = (int)result;
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
45146   int jresult ;
45147   int result;
45148
45149   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
45150   jresult = (int)result;
45151   return jresult;
45152 }
45153
45154
45155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
45156   void * jresult ;
45157   Dali::Toolkit::ScrollView::Property *result = 0 ;
45158
45159   {
45160     try {
45161       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
45162     } CALL_CATCH_EXCEPTION(0);
45163   }
45164
45165   jresult = (void *)result;
45166   return jresult;
45167 }
45168
45169
45170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
45171   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
45172
45173   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
45174   {
45175     try {
45176       delete arg1;
45177     } CALL_CATCH_EXCEPTION();
45178   }
45179
45180 }
45181
45182
45183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
45184   void * jresult ;
45185   Dali::Toolkit::ScrollView *result = 0 ;
45186
45187   {
45188     try {
45189       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
45190     } CALL_CATCH_EXCEPTION(0);
45191   }
45192
45193   jresult = (void *)result;
45194   return jresult;
45195 }
45196
45197
45198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
45199   void * jresult ;
45200   Dali::Toolkit::ScrollView *arg1 = 0 ;
45201   Dali::Toolkit::ScrollView *result = 0 ;
45202
45203   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45204   if (!arg1) {
45205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
45206     return 0;
45207   }
45208   {
45209     try {
45210       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
45211     } CALL_CATCH_EXCEPTION(0);
45212   }
45213
45214   jresult = (void *)result;
45215   return jresult;
45216 }
45217
45218
45219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
45220   void * jresult ;
45221   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45222   Dali::Toolkit::ScrollView *arg2 = 0 ;
45223   Dali::Toolkit::ScrollView *result = 0 ;
45224
45225   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45226   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
45227   if (!arg2) {
45228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
45229     return 0;
45230   }
45231   {
45232     try {
45233       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
45234     } CALL_CATCH_EXCEPTION(0);
45235   }
45236
45237   jresult = (void *)result;
45238   return jresult;
45239 }
45240
45241
45242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
45243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45244
45245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45246   {
45247     try {
45248       delete arg1;
45249     } CALL_CATCH_EXCEPTION();
45250   }
45251
45252 }
45253
45254
45255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
45256   void * jresult ;
45257   Dali::Toolkit::ScrollView result;
45258
45259   {
45260     try {
45261       result = Dali::Toolkit::ScrollView::New();
45262     } CALL_CATCH_EXCEPTION(0);
45263   }
45264
45265   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
45266   return jresult;
45267 }
45268
45269
45270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
45271   void * jresult ;
45272   Dali::BaseHandle arg1 ;
45273   Dali::BaseHandle *argp1 ;
45274   Dali::Toolkit::ScrollView result;
45275
45276   argp1 = (Dali::BaseHandle *)jarg1;
45277   if (!argp1) {
45278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45279     return 0;
45280   }
45281   arg1 = *argp1;
45282   {
45283     try {
45284       result = Dali::Toolkit::ScrollView::DownCast(arg1);
45285     } CALL_CATCH_EXCEPTION(0);
45286   }
45287
45288   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
45289   return jresult;
45290 }
45291
45292
45293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
45294   void * jresult ;
45295   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45296   Dali::AlphaFunction result;
45297
45298   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45299   {
45300     try {
45301       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
45302     } CALL_CATCH_EXCEPTION(0);
45303   }
45304
45305   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
45306   return jresult;
45307 }
45308
45309
45310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
45311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45312   Dali::AlphaFunction arg2 ;
45313   Dali::AlphaFunction *argp2 ;
45314
45315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45316   argp2 = (Dali::AlphaFunction *)jarg2;
45317   if (!argp2) {
45318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45319     return ;
45320   }
45321   arg2 = *argp2;
45322   {
45323     try {
45324       (arg1)->SetScrollSnapAlphaFunction(arg2);
45325     } CALL_CATCH_EXCEPTION();
45326   }
45327
45328 }
45329
45330
45331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
45332   void * jresult ;
45333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45334   Dali::AlphaFunction result;
45335
45336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45337   {
45338     try {
45339       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
45340     } CALL_CATCH_EXCEPTION(0);
45341   }
45342
45343   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
45344   return jresult;
45345 }
45346
45347
45348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
45349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45350   Dali::AlphaFunction arg2 ;
45351   Dali::AlphaFunction *argp2 ;
45352
45353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45354   argp2 = (Dali::AlphaFunction *)jarg2;
45355   if (!argp2) {
45356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45357     return ;
45358   }
45359   arg2 = *argp2;
45360   {
45361     try {
45362       (arg1)->SetScrollFlickAlphaFunction(arg2);
45363     } CALL_CATCH_EXCEPTION();
45364   }
45365
45366 }
45367
45368
45369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
45370   float jresult ;
45371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45372   float result;
45373
45374   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45375   {
45376     try {
45377       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
45378     } CALL_CATCH_EXCEPTION(0);
45379   }
45380
45381   jresult = result;
45382   return jresult;
45383 }
45384
45385
45386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
45387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45388   float arg2 ;
45389
45390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45391   arg2 = (float)jarg2;
45392   {
45393     try {
45394       (arg1)->SetScrollSnapDuration(arg2);
45395     } CALL_CATCH_EXCEPTION();
45396   }
45397
45398 }
45399
45400
45401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
45402   float jresult ;
45403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45404   float result;
45405
45406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45407   {
45408     try {
45409       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
45410     } CALL_CATCH_EXCEPTION(0);
45411   }
45412
45413   jresult = result;
45414   return jresult;
45415 }
45416
45417
45418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
45419   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45420   float arg2 ;
45421
45422   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45423   arg2 = (float)jarg2;
45424   {
45425     try {
45426       (arg1)->SetScrollFlickDuration(arg2);
45427     } CALL_CATCH_EXCEPTION();
45428   }
45429
45430 }
45431
45432
45433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
45434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45435   Dali::Toolkit::RulerPtr arg2 ;
45436   Dali::Toolkit::RulerPtr *argp2 ;
45437
45438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45439   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
45440   if (!argp2) {
45441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
45442     return ;
45443   }
45444   arg2 = *argp2;
45445   {
45446     try {
45447       (arg1)->SetRulerX(arg2);
45448     } CALL_CATCH_EXCEPTION();
45449   }
45450
45451 }
45452
45453
45454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
45455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45456   Dali::Toolkit::RulerPtr arg2 ;
45457   Dali::Toolkit::RulerPtr *argp2 ;
45458
45459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45460   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
45461   if (!argp2) {
45462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
45463     return ;
45464   }
45465   arg2 = *argp2;
45466   {
45467     try {
45468       (arg1)->SetRulerY(arg2);
45469     } CALL_CATCH_EXCEPTION();
45470   }
45471
45472 }
45473
45474
45475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) {
45476   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45477   bool arg2 ;
45478
45479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45480   arg2 = jarg2 ? true : false;
45481   {
45482     try {
45483       (arg1)->SetScrollSensitive(arg2);
45484     } CALL_CATCH_EXCEPTION();
45485   }
45486
45487 }
45488
45489
45490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
45491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45492   float arg2 ;
45493   float arg3 ;
45494
45495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45496   arg2 = (float)jarg2;
45497   arg3 = (float)jarg3;
45498   {
45499     try {
45500       (arg1)->SetMaxOvershoot(arg2,arg3);
45501     } CALL_CATCH_EXCEPTION();
45502   }
45503
45504 }
45505
45506
45507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
45508   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45509   Dali::AlphaFunction arg2 ;
45510   Dali::AlphaFunction *argp2 ;
45511
45512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45513   argp2 = (Dali::AlphaFunction *)jarg2;
45514   if (!argp2) {
45515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45516     return ;
45517   }
45518   arg2 = *argp2;
45519   {
45520     try {
45521       (arg1)->SetSnapOvershootAlphaFunction(arg2);
45522     } CALL_CATCH_EXCEPTION();
45523   }
45524
45525 }
45526
45527
45528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
45529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45530   float arg2 ;
45531
45532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45533   arg2 = (float)jarg2;
45534   {
45535     try {
45536       (arg1)->SetSnapOvershootDuration(arg2);
45537     } CALL_CATCH_EXCEPTION();
45538   }
45539
45540 }
45541
45542
45543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) {
45544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45545   bool arg2 ;
45546
45547   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45548   arg2 = jarg2 ? true : false;
45549   {
45550     try {
45551       (arg1)->SetActorAutoSnap(arg2);
45552     } CALL_CATCH_EXCEPTION();
45553   }
45554
45555 }
45556
45557
45558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) {
45559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45560   bool arg2 ;
45561
45562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45563   arg2 = jarg2 ? true : false;
45564   {
45565     try {
45566       (arg1)->SetWrapMode(arg2);
45567     } CALL_CATCH_EXCEPTION();
45568   }
45569
45570 }
45571
45572
45573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
45574   int jresult ;
45575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45576   int result;
45577
45578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45579   {
45580     try {
45581       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
45582     } CALL_CATCH_EXCEPTION(0);
45583   }
45584
45585   jresult = result;
45586   return jresult;
45587 }
45588
45589
45590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
45591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45592   int arg2 ;
45593
45594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45595   arg2 = (int)jarg2;
45596   {
45597     try {
45598       (arg1)->SetScrollUpdateDistance(arg2);
45599     } CALL_CATCH_EXCEPTION();
45600   }
45601
45602 }
45603
45604
45605 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
45606   bool jresult ;
45607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45608   bool result;
45609
45610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45611   {
45612     try {
45613       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
45614     } CALL_CATCH_EXCEPTION(0);
45615   }
45616
45617   jresult = result;
45618   return jresult;
45619 }
45620
45621
45622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) {
45623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45624   bool arg2 ;
45625
45626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45627   arg2 = jarg2 ? true : false;
45628   {
45629     try {
45630       (arg1)->SetAxisAutoLock(arg2);
45631     } CALL_CATCH_EXCEPTION();
45632   }
45633
45634 }
45635
45636
45637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
45638   float jresult ;
45639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45640   float result;
45641
45642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45643   {
45644     try {
45645       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
45646     } CALL_CATCH_EXCEPTION(0);
45647   }
45648
45649   jresult = result;
45650   return jresult;
45651 }
45652
45653
45654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
45655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45656   float arg2 ;
45657
45658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45659   arg2 = (float)jarg2;
45660   {
45661     try {
45662       (arg1)->SetAxisAutoLockGradient(arg2);
45663     } CALL_CATCH_EXCEPTION();
45664   }
45665
45666 }
45667
45668
45669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
45670   float jresult ;
45671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45672   float result;
45673
45674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45675   {
45676     try {
45677       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
45678     } CALL_CATCH_EXCEPTION(0);
45679   }
45680
45681   jresult = result;
45682   return jresult;
45683 }
45684
45685
45686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
45687   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45688   float arg2 ;
45689
45690   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45691   arg2 = (float)jarg2;
45692   {
45693     try {
45694       (arg1)->SetFrictionCoefficient(arg2);
45695     } CALL_CATCH_EXCEPTION();
45696   }
45697
45698 }
45699
45700
45701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
45702   float jresult ;
45703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45704   float result;
45705
45706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45707   {
45708     try {
45709       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
45710     } CALL_CATCH_EXCEPTION(0);
45711   }
45712
45713   jresult = result;
45714   return jresult;
45715 }
45716
45717
45718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
45719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45720   float arg2 ;
45721
45722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45723   arg2 = (float)jarg2;
45724   {
45725     try {
45726       (arg1)->SetFlickSpeedCoefficient(arg2);
45727     } CALL_CATCH_EXCEPTION();
45728   }
45729
45730 }
45731
45732
45733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45734   void * jresult ;
45735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45736   Dali::Vector2 result;
45737
45738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45739   {
45740     try {
45741       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45742     } CALL_CATCH_EXCEPTION(0);
45743   }
45744
45745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45752   Dali::Vector2 *arg2 = 0 ;
45753
45754   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45755   arg2 = (Dali::Vector2 *)jarg2;
45756   if (!arg2) {
45757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45758     return ;
45759   }
45760   {
45761     try {
45762       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45763     } CALL_CATCH_EXCEPTION();
45764   }
45765
45766 }
45767
45768
45769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45770   float jresult ;
45771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45772   float result;
45773
45774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45775   {
45776     try {
45777       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45778     } CALL_CATCH_EXCEPTION(0);
45779   }
45780
45781   jresult = result;
45782   return jresult;
45783 }
45784
45785
45786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45788   float arg2 ;
45789
45790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45791   arg2 = (float)jarg2;
45792   {
45793     try {
45794       (arg1)->SetMinimumSpeedForFlick(arg2);
45795     } CALL_CATCH_EXCEPTION();
45796   }
45797
45798 }
45799
45800
45801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45802   float jresult ;
45803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45804   float result;
45805
45806   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45807   {
45808     try {
45809       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45810     } CALL_CATCH_EXCEPTION(0);
45811   }
45812
45813   jresult = result;
45814   return jresult;
45815 }
45816
45817
45818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45819   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45820   float arg2 ;
45821
45822   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45823   arg2 = (float)jarg2;
45824   {
45825     try {
45826       (arg1)->SetMaxFlickSpeed(arg2);
45827     } CALL_CATCH_EXCEPTION();
45828   }
45829
45830 }
45831
45832
45833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45834   void * jresult ;
45835   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45836   Dali::Vector2 result;
45837
45838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45839   {
45840     try {
45841       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45842     } CALL_CATCH_EXCEPTION(0);
45843   }
45844
45845   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45846   return jresult;
45847 }
45848
45849
45850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45852   Dali::Vector2 arg2 ;
45853   Dali::Vector2 *argp2 ;
45854
45855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45856   argp2 = (Dali::Vector2 *)jarg2;
45857   if (!argp2) {
45858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45859     return ;
45860   }
45861   arg2 = *argp2;
45862   {
45863     try {
45864       (arg1)->SetWheelScrollDistanceStep(arg2);
45865     } CALL_CATCH_EXCEPTION();
45866   }
45867
45868 }
45869
45870
45871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45872   void * jresult ;
45873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45874   Dali::Vector2 result;
45875
45876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45877   {
45878     try {
45879       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45880     } CALL_CATCH_EXCEPTION(0);
45881   }
45882
45883   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45884   return jresult;
45885 }
45886
45887
45888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45889   unsigned int jresult ;
45890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45891   unsigned int result;
45892
45893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45894   {
45895     try {
45896       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45897     } CALL_CATCH_EXCEPTION(0);
45898   }
45899
45900   jresult = result;
45901   return jresult;
45902 }
45903
45904
45905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45907   Dali::Vector2 *arg2 = 0 ;
45908
45909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45910   arg2 = (Dali::Vector2 *)jarg2;
45911   if (!arg2) {
45912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45913     return ;
45914   }
45915   {
45916     try {
45917       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45918     } CALL_CATCH_EXCEPTION();
45919   }
45920
45921 }
45922
45923
45924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45926   Dali::Vector2 *arg2 = 0 ;
45927   float arg3 ;
45928
45929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45930   arg2 = (Dali::Vector2 *)jarg2;
45931   if (!arg2) {
45932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45933     return ;
45934   }
45935   arg3 = (float)jarg3;
45936   {
45937     try {
45938       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45939     } CALL_CATCH_EXCEPTION();
45940   }
45941
45942 }
45943
45944
45945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45947   Dali::Vector2 *arg2 = 0 ;
45948   float arg3 ;
45949   Dali::AlphaFunction arg4 ;
45950   Dali::AlphaFunction *argp4 ;
45951
45952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45953   arg2 = (Dali::Vector2 *)jarg2;
45954   if (!arg2) {
45955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45956     return ;
45957   }
45958   arg3 = (float)jarg3;
45959   argp4 = (Dali::AlphaFunction *)jarg4;
45960   if (!argp4) {
45961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45962     return ;
45963   }
45964   arg4 = *argp4;
45965   {
45966     try {
45967       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45968     } CALL_CATCH_EXCEPTION();
45969   }
45970
45971 }
45972
45973
45974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45975   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45976   Dali::Vector2 *arg2 = 0 ;
45977   float arg3 ;
45978   Dali::Toolkit::DirectionBias arg4 ;
45979   Dali::Toolkit::DirectionBias arg5 ;
45980
45981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45982   arg2 = (Dali::Vector2 *)jarg2;
45983   if (!arg2) {
45984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45985     return ;
45986   }
45987   arg3 = (float)jarg3;
45988   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45989   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45990   {
45991     try {
45992       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45993     } CALL_CATCH_EXCEPTION();
45994   }
45995
45996 }
45997
45998
45999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
46000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46001   Dali::Vector2 *arg2 = 0 ;
46002   float arg3 ;
46003   Dali::AlphaFunction arg4 ;
46004   Dali::Toolkit::DirectionBias arg5 ;
46005   Dali::Toolkit::DirectionBias arg6 ;
46006   Dali::AlphaFunction *argp4 ;
46007
46008   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46009   arg2 = (Dali::Vector2 *)jarg2;
46010   if (!arg2) {
46011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
46012     return ;
46013   }
46014   arg3 = (float)jarg3;
46015   argp4 = (Dali::AlphaFunction *)jarg4;
46016   if (!argp4) {
46017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
46018     return ;
46019   }
46020   arg4 = *argp4;
46021   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
46022   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
46023   {
46024     try {
46025       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
46026     } CALL_CATCH_EXCEPTION();
46027   }
46028
46029 }
46030
46031
46032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
46033   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46034   unsigned int arg2 ;
46035
46036   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46037   arg2 = (unsigned int)jarg2;
46038   {
46039     try {
46040       (arg1)->ScrollTo(arg2);
46041     } CALL_CATCH_EXCEPTION();
46042   }
46043
46044 }
46045
46046
46047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
46048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46049   unsigned int arg2 ;
46050   float arg3 ;
46051
46052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46053   arg2 = (unsigned int)jarg2;
46054   arg3 = (float)jarg3;
46055   {
46056     try {
46057       (arg1)->ScrollTo(arg2,arg3);
46058     } CALL_CATCH_EXCEPTION();
46059   }
46060
46061 }
46062
46063
46064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
46065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46066   unsigned int arg2 ;
46067   float arg3 ;
46068   Dali::Toolkit::DirectionBias arg4 ;
46069
46070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46071   arg2 = (unsigned int)jarg2;
46072   arg3 = (float)jarg3;
46073   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
46074   {
46075     try {
46076       (arg1)->ScrollTo(arg2,arg3,arg4);
46077     } CALL_CATCH_EXCEPTION();
46078   }
46079
46080 }
46081
46082
46083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
46084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46085   Dali::Actor *arg2 = 0 ;
46086
46087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46088   arg2 = (Dali::Actor *)jarg2;
46089   if (!arg2) {
46090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
46091     return ;
46092   }
46093   {
46094     try {
46095       (arg1)->ScrollTo(*arg2);
46096     } CALL_CATCH_EXCEPTION();
46097   }
46098
46099 }
46100
46101
46102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
46103   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46104   Dali::Actor *arg2 = 0 ;
46105   float arg3 ;
46106
46107   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46108   arg2 = (Dali::Actor *)jarg2;
46109   if (!arg2) {
46110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
46111     return ;
46112   }
46113   arg3 = (float)jarg3;
46114   {
46115     try {
46116       (arg1)->ScrollTo(*arg2,arg3);
46117     } CALL_CATCH_EXCEPTION();
46118   }
46119
46120 }
46121
46122
46123 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
46124   bool jresult ;
46125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46126   bool result;
46127
46128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46129   {
46130     try {
46131       result = (bool)(arg1)->ScrollToSnapPoint();
46132     } CALL_CATCH_EXCEPTION(0);
46133   }
46134
46135   jresult = result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
46141   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46142   Dali::Constraint arg2 ;
46143   Dali::Constraint *argp2 ;
46144
46145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46146   argp2 = (Dali::Constraint *)jarg2;
46147   if (!argp2) {
46148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
46149     return ;
46150   }
46151   arg2 = *argp2;
46152   {
46153     try {
46154       (arg1)->ApplyConstraintToChildren(arg2);
46155     } CALL_CATCH_EXCEPTION();
46156   }
46157
46158 }
46159
46160
46161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
46162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46163
46164   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46165   {
46166     try {
46167       (arg1)->RemoveConstraintsFromChildren();
46168     } CALL_CATCH_EXCEPTION();
46169   }
46170
46171 }
46172
46173
46174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
46175   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46176   Dali::Toolkit::ScrollViewEffect arg2 ;
46177   Dali::Toolkit::ScrollViewEffect *argp2 ;
46178
46179   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46180   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
46181   if (!argp2) {
46182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
46183     return ;
46184   }
46185   arg2 = *argp2;
46186   {
46187     try {
46188       (arg1)->ApplyEffect(arg2);
46189     } CALL_CATCH_EXCEPTION();
46190   }
46191
46192 }
46193
46194
46195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
46196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46197   Dali::Toolkit::ScrollViewEffect arg2 ;
46198   Dali::Toolkit::ScrollViewEffect *argp2 ;
46199
46200   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46201   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
46202   if (!argp2) {
46203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
46204     return ;
46205   }
46206   arg2 = *argp2;
46207   {
46208     try {
46209       (arg1)->RemoveEffect(arg2);
46210     } CALL_CATCH_EXCEPTION();
46211   }
46212
46213 }
46214
46215
46216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
46217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46218
46219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46220   {
46221     try {
46222       (arg1)->RemoveAllEffects();
46223     } CALL_CATCH_EXCEPTION();
46224   }
46225
46226 }
46227
46228
46229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
46230   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46231   Dali::Actor arg2 ;
46232   Dali::Actor *argp2 ;
46233
46234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46235   argp2 = (Dali::Actor *)jarg2;
46236   if (!argp2) {
46237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46238     return ;
46239   }
46240   arg2 = *argp2;
46241   {
46242     try {
46243       (arg1)->BindActor(arg2);
46244     } CALL_CATCH_EXCEPTION();
46245   }
46246
46247 }
46248
46249
46250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
46251   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46252   Dali::Actor arg2 ;
46253   Dali::Actor *argp2 ;
46254
46255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46256   argp2 = (Dali::Actor *)jarg2;
46257   if (!argp2) {
46258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46259     return ;
46260   }
46261   arg2 = *argp2;
46262   {
46263     try {
46264       (arg1)->UnbindActor(arg2);
46265     } CALL_CATCH_EXCEPTION();
46266   }
46267
46268 }
46269
46270
46271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46273   Dali::Radian arg2 ;
46274   Dali::Radian arg3 ;
46275   Dali::Radian *argp2 ;
46276   Dali::Radian *argp3 ;
46277
46278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46279   argp2 = (Dali::Radian *)jarg2;
46280   if (!argp2) {
46281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46282     return ;
46283   }
46284   arg2 = *argp2;
46285   argp3 = (Dali::Radian *)jarg3;
46286   if (!argp3) {
46287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46288     return ;
46289   }
46290   arg3 = *argp3;
46291   {
46292     try {
46293       (arg1)->SetScrollingDirection(arg2,arg3);
46294     } CALL_CATCH_EXCEPTION();
46295   }
46296
46297 }
46298
46299
46300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
46301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46302   Dali::Radian arg2 ;
46303   Dali::Radian *argp2 ;
46304
46305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46306   argp2 = (Dali::Radian *)jarg2;
46307   if (!argp2) {
46308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46309     return ;
46310   }
46311   arg2 = *argp2;
46312   {
46313     try {
46314       (arg1)->SetScrollingDirection(arg2);
46315     } CALL_CATCH_EXCEPTION();
46316   }
46317
46318 }
46319
46320
46321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
46322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46323   Dali::Radian arg2 ;
46324   Dali::Radian *argp2 ;
46325
46326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46327   argp2 = (Dali::Radian *)jarg2;
46328   if (!argp2) {
46329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
46330     return ;
46331   }
46332   arg2 = *argp2;
46333   {
46334     try {
46335       (arg1)->RemoveScrollingDirection(arg2);
46336     } CALL_CATCH_EXCEPTION();
46337   }
46338
46339 }
46340
46341
46342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
46343   void * jresult ;
46344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
46345   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
46346
46347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
46348   {
46349     try {
46350       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
46351     } CALL_CATCH_EXCEPTION(0);
46352   }
46353
46354   jresult = (void *)result;
46355   return jresult;
46356 }
46357
46358
46359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
46360   int jresult ;
46361   int result;
46362
46363   result = (int)Dali::Toolkit::TableView::Property::ROWS;
46364   jresult = (int)result;
46365   return jresult;
46366 }
46367
46368
46369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
46370   int jresult ;
46371   int result;
46372
46373   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
46374   jresult = (int)result;
46375   return jresult;
46376 }
46377
46378
46379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
46380   int jresult ;
46381   int result;
46382
46383   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
46384   jresult = (int)result;
46385   return jresult;
46386 }
46387
46388
46389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
46390   int jresult ;
46391   int result;
46392
46393   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
46394   jresult = (int)result;
46395   return jresult;
46396 }
46397
46398
46399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
46400   int jresult ;
46401   int result;
46402
46403   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
46404   jresult = (int)result;
46405   return jresult;
46406 }
46407
46408
46409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
46410   void * jresult ;
46411   Dali::Toolkit::TableView::Property *result = 0 ;
46412
46413   {
46414     try {
46415       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
46416     } CALL_CATCH_EXCEPTION(0);
46417   }
46418
46419   jresult = (void *)result;
46420   return jresult;
46421 }
46422
46423
46424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
46425   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
46426
46427   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
46428   {
46429     try {
46430       delete arg1;
46431     } CALL_CATCH_EXCEPTION();
46432   }
46433
46434 }
46435
46436
46437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
46438   int jresult ;
46439   int result;
46440
46441   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
46442   jresult = (int)result;
46443   return jresult;
46444 }
46445
46446
46447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
46448   int jresult ;
46449   int result;
46450
46451   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
46452   jresult = (int)result;
46453   return jresult;
46454 }
46455
46456
46457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
46458   int jresult ;
46459   int result;
46460
46461   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
46462   jresult = (int)result;
46463   return jresult;
46464 }
46465
46466
46467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
46468   int jresult ;
46469   int result;
46470
46471   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
46472   jresult = (int)result;
46473   return jresult;
46474 }
46475
46476
46477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
46478   int jresult ;
46479   int result;
46480
46481   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
46482   jresult = (int)result;
46483   return jresult;
46484 }
46485
46486
46487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
46488   void * jresult ;
46489   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
46490
46491   {
46492     try {
46493       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
46494     } CALL_CATCH_EXCEPTION(0);
46495   }
46496
46497   jresult = (void *)result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
46503   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
46504
46505   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
46506   {
46507     try {
46508       delete arg1;
46509     } CALL_CATCH_EXCEPTION();
46510   }
46511
46512 }
46513
46514
46515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46516   void * jresult ;
46517   unsigned int arg1 ;
46518   unsigned int arg2 ;
46519   unsigned int arg3 ;
46520   unsigned int arg4 ;
46521   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46522
46523   arg1 = (unsigned int)jarg1;
46524   arg2 = (unsigned int)jarg2;
46525   arg3 = (unsigned int)jarg3;
46526   arg4 = (unsigned int)jarg4;
46527   {
46528     try {
46529       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
46530     } CALL_CATCH_EXCEPTION(0);
46531   }
46532
46533   jresult = (void *)result;
46534   return jresult;
46535 }
46536
46537
46538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
46539   void * jresult ;
46540   unsigned int arg1 ;
46541   unsigned int arg2 ;
46542   unsigned int arg3 ;
46543   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46544
46545   arg1 = (unsigned int)jarg1;
46546   arg2 = (unsigned int)jarg2;
46547   arg3 = (unsigned int)jarg3;
46548   {
46549     try {
46550       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
46551     } CALL_CATCH_EXCEPTION(0);
46552   }
46553
46554   jresult = (void *)result;
46555   return jresult;
46556 }
46557
46558
46559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46560   void * jresult ;
46561   unsigned int arg1 ;
46562   unsigned int arg2 ;
46563   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46564
46565   arg1 = (unsigned int)jarg1;
46566   arg2 = (unsigned int)jarg2;
46567   {
46568     try {
46569       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
46570     } CALL_CATCH_EXCEPTION(0);
46571   }
46572
46573   jresult = (void *)result;
46574   return jresult;
46575 }
46576
46577
46578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
46579   void * jresult ;
46580   unsigned int arg1 ;
46581   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46582
46583   arg1 = (unsigned int)jarg1;
46584   {
46585     try {
46586       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
46587     } CALL_CATCH_EXCEPTION(0);
46588   }
46589
46590   jresult = (void *)result;
46591   return jresult;
46592 }
46593
46594
46595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
46596   void * jresult ;
46597   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46598
46599   {
46600     try {
46601       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
46602     } CALL_CATCH_EXCEPTION(0);
46603   }
46604
46605   jresult = (void *)result;
46606   return jresult;
46607 }
46608
46609
46610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
46611   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46612   unsigned int arg2 ;
46613
46614   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46615   arg2 = (unsigned int)jarg2;
46616   if (arg1) (arg1)->rowIndex = arg2;
46617 }
46618
46619
46620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
46621   unsigned int jresult ;
46622   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46623   unsigned int result;
46624
46625   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46626   result = (unsigned int) ((arg1)->rowIndex);
46627   jresult = result;
46628   return jresult;
46629 }
46630
46631
46632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
46633   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46634   unsigned int arg2 ;
46635
46636   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46637   arg2 = (unsigned int)jarg2;
46638   if (arg1) (arg1)->columnIndex = arg2;
46639 }
46640
46641
46642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
46643   unsigned int jresult ;
46644   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46645   unsigned int result;
46646
46647   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46648   result = (unsigned int) ((arg1)->columnIndex);
46649   jresult = result;
46650   return jresult;
46651 }
46652
46653
46654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
46655   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46656   unsigned int arg2 ;
46657
46658   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46659   arg2 = (unsigned int)jarg2;
46660   if (arg1) (arg1)->rowSpan = arg2;
46661 }
46662
46663
46664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
46665   unsigned int jresult ;
46666   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46667   unsigned int result;
46668
46669   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46670   result = (unsigned int) ((arg1)->rowSpan);
46671   jresult = result;
46672   return jresult;
46673 }
46674
46675
46676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
46677   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46678   unsigned int arg2 ;
46679
46680   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46681   arg2 = (unsigned int)jarg2;
46682   if (arg1) (arg1)->columnSpan = arg2;
46683 }
46684
46685
46686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
46687   unsigned int jresult ;
46688   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46689   unsigned int result;
46690
46691   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46692   result = (unsigned int) ((arg1)->columnSpan);
46693   jresult = result;
46694   return jresult;
46695 }
46696
46697
46698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
46699   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46700
46701   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46702   {
46703     try {
46704       delete arg1;
46705     } CALL_CATCH_EXCEPTION();
46706   }
46707
46708 }
46709
46710
46711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
46712   void * jresult ;
46713   Dali::Toolkit::TableView *result = 0 ;
46714
46715   {
46716     try {
46717       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
46718     } CALL_CATCH_EXCEPTION(0);
46719   }
46720
46721   jresult = (void *)result;
46722   return jresult;
46723 }
46724
46725
46726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
46727   void * jresult ;
46728   Dali::Toolkit::TableView *arg1 = 0 ;
46729   Dali::Toolkit::TableView *result = 0 ;
46730
46731   arg1 = (Dali::Toolkit::TableView *)jarg1;
46732   if (!arg1) {
46733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46734     return 0;
46735   }
46736   {
46737     try {
46738       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46739     } CALL_CATCH_EXCEPTION(0);
46740   }
46741
46742   jresult = (void *)result;
46743   return jresult;
46744 }
46745
46746
46747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46748   void * jresult ;
46749   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46750   Dali::Toolkit::TableView *arg2 = 0 ;
46751   Dali::Toolkit::TableView *result = 0 ;
46752
46753   arg1 = (Dali::Toolkit::TableView *)jarg1;
46754   arg2 = (Dali::Toolkit::TableView *)jarg2;
46755   if (!arg2) {
46756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46757     return 0;
46758   }
46759   {
46760     try {
46761       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46762     } CALL_CATCH_EXCEPTION(0);
46763   }
46764
46765   jresult = (void *)result;
46766   return jresult;
46767 }
46768
46769
46770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46771   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46772
46773   arg1 = (Dali::Toolkit::TableView *)jarg1;
46774   {
46775     try {
46776       delete arg1;
46777     } CALL_CATCH_EXCEPTION();
46778   }
46779
46780 }
46781
46782
46783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46784   void * jresult ;
46785   unsigned int arg1 ;
46786   unsigned int arg2 ;
46787   Dali::Toolkit::TableView result;
46788
46789   arg1 = (unsigned int)jarg1;
46790   arg2 = (unsigned int)jarg2;
46791   {
46792     try {
46793       result = Dali::Toolkit::TableView::New(arg1,arg2);
46794     } CALL_CATCH_EXCEPTION(0);
46795   }
46796
46797   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46798   return jresult;
46799 }
46800
46801
46802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46803   void * jresult ;
46804   Dali::BaseHandle arg1 ;
46805   Dali::BaseHandle *argp1 ;
46806   Dali::Toolkit::TableView result;
46807
46808   argp1 = (Dali::BaseHandle *)jarg1;
46809   if (!argp1) {
46810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46811     return 0;
46812   }
46813   arg1 = *argp1;
46814   {
46815     try {
46816       result = Dali::Toolkit::TableView::DownCast(arg1);
46817     } CALL_CATCH_EXCEPTION(0);
46818   }
46819
46820   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46821   return jresult;
46822 }
46823
46824
46825 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46826   bool jresult ;
46827   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46828   Dali::Actor arg2 ;
46829   Dali::Toolkit::TableView::CellPosition arg3 ;
46830   Dali::Actor *argp2 ;
46831   Dali::Toolkit::TableView::CellPosition *argp3 ;
46832   bool result;
46833
46834   arg1 = (Dali::Toolkit::TableView *)jarg1;
46835   argp2 = (Dali::Actor *)jarg2;
46836   if (!argp2) {
46837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46838     return 0;
46839   }
46840   arg2 = *argp2;
46841   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46842   if (!argp3) {
46843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46844     return 0;
46845   }
46846   arg3 = *argp3;
46847   {
46848     try {
46849       result = (bool)(arg1)->AddChild(arg2,arg3);
46850     } CALL_CATCH_EXCEPTION(0);
46851   }
46852
46853   jresult = result;
46854   return jresult;
46855 }
46856
46857
46858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46859   void * jresult ;
46860   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46861   Dali::Toolkit::TableView::CellPosition arg2 ;
46862   Dali::Toolkit::TableView::CellPosition *argp2 ;
46863   Dali::Actor result;
46864
46865   arg1 = (Dali::Toolkit::TableView *)jarg1;
46866   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46867   if (!argp2) {
46868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46869     return 0;
46870   }
46871   arg2 = *argp2;
46872   {
46873     try {
46874       result = (arg1)->GetChildAt(arg2);
46875     } CALL_CATCH_EXCEPTION(0);
46876   }
46877
46878   jresult = new Dali::Actor((const Dali::Actor &)result);
46879   return jresult;
46880 }
46881
46882
46883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46884   void * jresult ;
46885   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46886   Dali::Toolkit::TableView::CellPosition arg2 ;
46887   Dali::Toolkit::TableView::CellPosition *argp2 ;
46888   Dali::Actor result;
46889
46890   arg1 = (Dali::Toolkit::TableView *)jarg1;
46891   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46892   if (!argp2) {
46893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46894     return 0;
46895   }
46896   arg2 = *argp2;
46897   {
46898     try {
46899       result = (arg1)->RemoveChildAt(arg2);
46900     } CALL_CATCH_EXCEPTION(0);
46901   }
46902
46903   jresult = new Dali::Actor((const Dali::Actor &)result);
46904   return jresult;
46905 }
46906
46907
46908 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46909   bool jresult ;
46910   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46911   Dali::Actor arg2 ;
46912   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46913   Dali::Actor *argp2 ;
46914   bool result;
46915
46916   arg1 = (Dali::Toolkit::TableView *)jarg1;
46917   argp2 = (Dali::Actor *)jarg2;
46918   if (!argp2) {
46919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46920     return 0;
46921   }
46922   arg2 = *argp2;
46923   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46924   if (!arg3) {
46925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46926     return 0;
46927   }
46928   {
46929     try {
46930       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46931     } CALL_CATCH_EXCEPTION(0);
46932   }
46933
46934   jresult = result;
46935   return jresult;
46936 }
46937
46938
46939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46940   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46941   unsigned int arg2 ;
46942
46943   arg1 = (Dali::Toolkit::TableView *)jarg1;
46944   arg2 = (unsigned int)jarg2;
46945   {
46946     try {
46947       (arg1)->InsertRow(arg2);
46948     } CALL_CATCH_EXCEPTION();
46949   }
46950
46951 }
46952
46953
46954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46955   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46956   unsigned int arg2 ;
46957
46958   arg1 = (Dali::Toolkit::TableView *)jarg1;
46959   arg2 = (unsigned int)jarg2;
46960   {
46961     try {
46962       (arg1)->DeleteRow(arg2);
46963     } CALL_CATCH_EXCEPTION();
46964   }
46965
46966 }
46967
46968
46969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46970   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46971   unsigned int arg2 ;
46972   std::vector< Dali::Actor > *arg3 = 0 ;
46973
46974   arg1 = (Dali::Toolkit::TableView *)jarg1;
46975   arg2 = (unsigned int)jarg2;
46976   arg3 = (std::vector< Dali::Actor > *)jarg3;
46977   if (!arg3) {
46978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46979     return ;
46980   }
46981   {
46982     try {
46983       (arg1)->DeleteRow(arg2,*arg3);
46984     } CALL_CATCH_EXCEPTION();
46985   }
46986
46987 }
46988
46989
46990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46991   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46992   unsigned int arg2 ;
46993
46994   arg1 = (Dali::Toolkit::TableView *)jarg1;
46995   arg2 = (unsigned int)jarg2;
46996   {
46997     try {
46998       (arg1)->InsertColumn(arg2);
46999     } CALL_CATCH_EXCEPTION();
47000   }
47001
47002 }
47003
47004
47005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
47006   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47007   unsigned int arg2 ;
47008
47009   arg1 = (Dali::Toolkit::TableView *)jarg1;
47010   arg2 = (unsigned int)jarg2;
47011   {
47012     try {
47013       (arg1)->DeleteColumn(arg2);
47014     } CALL_CATCH_EXCEPTION();
47015   }
47016
47017 }
47018
47019
47020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
47021   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47022   unsigned int arg2 ;
47023   std::vector< Dali::Actor > *arg3 = 0 ;
47024
47025   arg1 = (Dali::Toolkit::TableView *)jarg1;
47026   arg2 = (unsigned int)jarg2;
47027   arg3 = (std::vector< Dali::Actor > *)jarg3;
47028   if (!arg3) {
47029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47030     return ;
47031   }
47032   {
47033     try {
47034       (arg1)->DeleteColumn(arg2,*arg3);
47035     } CALL_CATCH_EXCEPTION();
47036   }
47037
47038 }
47039
47040
47041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
47042   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47043   unsigned int arg2 ;
47044   unsigned int arg3 ;
47045
47046   arg1 = (Dali::Toolkit::TableView *)jarg1;
47047   arg2 = (unsigned int)jarg2;
47048   arg3 = (unsigned int)jarg3;
47049   {
47050     try {
47051       (arg1)->Resize(arg2,arg3);
47052     } CALL_CATCH_EXCEPTION();
47053   }
47054
47055 }
47056
47057
47058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
47059   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47060   unsigned int arg2 ;
47061   unsigned int arg3 ;
47062   std::vector< Dali::Actor > *arg4 = 0 ;
47063
47064   arg1 = (Dali::Toolkit::TableView *)jarg1;
47065   arg2 = (unsigned int)jarg2;
47066   arg3 = (unsigned int)jarg3;
47067   arg4 = (std::vector< Dali::Actor > *)jarg4;
47068   if (!arg4) {
47069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
47070     return ;
47071   }
47072   {
47073     try {
47074       (arg1)->Resize(arg2,arg3,*arg4);
47075     } CALL_CATCH_EXCEPTION();
47076   }
47077
47078 }
47079
47080
47081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
47082   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47083   Dali::Size arg2 ;
47084   Dali::Size *argp2 ;
47085
47086   arg1 = (Dali::Toolkit::TableView *)jarg1;
47087   argp2 = (Dali::Size *)jarg2;
47088   if (!argp2) {
47089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
47090     return ;
47091   }
47092   arg2 = *argp2;
47093   {
47094     try {
47095       (arg1)->SetCellPadding(arg2);
47096     } CALL_CATCH_EXCEPTION();
47097   }
47098
47099 }
47100
47101
47102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
47103   void * jresult ;
47104   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47105   Dali::Size result;
47106
47107   arg1 = (Dali::Toolkit::TableView *)jarg1;
47108   {
47109     try {
47110       result = (arg1)->GetCellPadding();
47111     } CALL_CATCH_EXCEPTION(0);
47112   }
47113
47114   jresult = new Dali::Size((const Dali::Size &)result);
47115   return jresult;
47116 }
47117
47118
47119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
47120   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47121   unsigned int arg2 ;
47122
47123   arg1 = (Dali::Toolkit::TableView *)jarg1;
47124   arg2 = (unsigned int)jarg2;
47125   {
47126     try {
47127       (arg1)->SetFitHeight(arg2);
47128     } CALL_CATCH_EXCEPTION();
47129   }
47130
47131 }
47132
47133
47134 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
47135   bool jresult ;
47136   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47137   unsigned int arg2 ;
47138   bool result;
47139
47140   arg1 = (Dali::Toolkit::TableView *)jarg1;
47141   arg2 = (unsigned int)jarg2;
47142   {
47143     try {
47144       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
47145     } CALL_CATCH_EXCEPTION(0);
47146   }
47147
47148   jresult = result;
47149   return jresult;
47150 }
47151
47152
47153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
47154   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47155   unsigned int arg2 ;
47156
47157   arg1 = (Dali::Toolkit::TableView *)jarg1;
47158   arg2 = (unsigned int)jarg2;
47159   {
47160     try {
47161       (arg1)->SetFitWidth(arg2);
47162     } CALL_CATCH_EXCEPTION();
47163   }
47164
47165 }
47166
47167
47168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
47169   bool jresult ;
47170   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47171   unsigned int arg2 ;
47172   bool result;
47173
47174   arg1 = (Dali::Toolkit::TableView *)jarg1;
47175   arg2 = (unsigned int)jarg2;
47176   {
47177     try {
47178       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
47179     } CALL_CATCH_EXCEPTION(0);
47180   }
47181
47182   jresult = result;
47183   return jresult;
47184 }
47185
47186
47187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
47188   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47189   unsigned int arg2 ;
47190   float arg3 ;
47191
47192   arg1 = (Dali::Toolkit::TableView *)jarg1;
47193   arg2 = (unsigned int)jarg2;
47194   arg3 = (float)jarg3;
47195   {
47196     try {
47197       (arg1)->SetFixedHeight(arg2,arg3);
47198     } CALL_CATCH_EXCEPTION();
47199   }
47200
47201 }
47202
47203
47204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
47205   float jresult ;
47206   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47207   unsigned int arg2 ;
47208   float result;
47209
47210   arg1 = (Dali::Toolkit::TableView *)jarg1;
47211   arg2 = (unsigned int)jarg2;
47212   {
47213     try {
47214       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
47215     } CALL_CATCH_EXCEPTION(0);
47216   }
47217
47218   jresult = result;
47219   return jresult;
47220 }
47221
47222
47223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
47224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47225   unsigned int arg2 ;
47226   float arg3 ;
47227
47228   arg1 = (Dali::Toolkit::TableView *)jarg1;
47229   arg2 = (unsigned int)jarg2;
47230   arg3 = (float)jarg3;
47231   {
47232     try {
47233       (arg1)->SetRelativeHeight(arg2,arg3);
47234     } CALL_CATCH_EXCEPTION();
47235   }
47236
47237 }
47238
47239
47240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
47241   float jresult ;
47242   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47243   unsigned int arg2 ;
47244   float result;
47245
47246   arg1 = (Dali::Toolkit::TableView *)jarg1;
47247   arg2 = (unsigned int)jarg2;
47248   {
47249     try {
47250       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
47251     } CALL_CATCH_EXCEPTION(0);
47252   }
47253
47254   jresult = result;
47255   return jresult;
47256 }
47257
47258
47259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
47260   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47261   unsigned int arg2 ;
47262   float arg3 ;
47263
47264   arg1 = (Dali::Toolkit::TableView *)jarg1;
47265   arg2 = (unsigned int)jarg2;
47266   arg3 = (float)jarg3;
47267   {
47268     try {
47269       (arg1)->SetFixedWidth(arg2,arg3);
47270     } CALL_CATCH_EXCEPTION();
47271   }
47272
47273 }
47274
47275
47276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
47277   float jresult ;
47278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47279   unsigned int arg2 ;
47280   float result;
47281
47282   arg1 = (Dali::Toolkit::TableView *)jarg1;
47283   arg2 = (unsigned int)jarg2;
47284   {
47285     try {
47286       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
47287     } CALL_CATCH_EXCEPTION(0);
47288   }
47289
47290   jresult = result;
47291   return jresult;
47292 }
47293
47294
47295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
47296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47297   unsigned int arg2 ;
47298   float arg3 ;
47299
47300   arg1 = (Dali::Toolkit::TableView *)jarg1;
47301   arg2 = (unsigned int)jarg2;
47302   arg3 = (float)jarg3;
47303   {
47304     try {
47305       (arg1)->SetRelativeWidth(arg2,arg3);
47306     } CALL_CATCH_EXCEPTION();
47307   }
47308
47309 }
47310
47311
47312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
47313   float jresult ;
47314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47315   unsigned int arg2 ;
47316   float result;
47317
47318   arg1 = (Dali::Toolkit::TableView *)jarg1;
47319   arg2 = (unsigned int)jarg2;
47320   {
47321     try {
47322       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
47323     } CALL_CATCH_EXCEPTION(0);
47324   }
47325
47326   jresult = result;
47327   return jresult;
47328 }
47329
47330
47331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
47332   unsigned int jresult ;
47333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47334   unsigned int result;
47335
47336   arg1 = (Dali::Toolkit::TableView *)jarg1;
47337   {
47338     try {
47339       result = (unsigned int)(arg1)->GetRows();
47340     } CALL_CATCH_EXCEPTION(0);
47341   }
47342
47343   jresult = result;
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
47349   unsigned int jresult ;
47350   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47351   unsigned int result;
47352
47353   arg1 = (Dali::Toolkit::TableView *)jarg1;
47354   {
47355     try {
47356       result = (unsigned int)(arg1)->GetColumns();
47357     } CALL_CATCH_EXCEPTION(0);
47358   }
47359
47360   jresult = result;
47361   return jresult;
47362 }
47363
47364
47365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
47366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
47367   Dali::Toolkit::TableView::CellPosition arg2 ;
47368   Dali::HorizontalAlignment::Type arg3 ;
47369   Dali::VerticalAlignment::Type arg4 ;
47370   Dali::Toolkit::TableView::CellPosition *argp2 ;
47371
47372   arg1 = (Dali::Toolkit::TableView *)jarg1;
47373   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
47374   if (!argp2) {
47375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
47376     return ;
47377   }
47378   arg2 = *argp2;
47379   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
47380   arg4 = (Dali::VerticalAlignment::Type)jarg4;
47381   {
47382     try {
47383       (arg1)->SetCellAlignment(arg2,arg3,arg4);
47384     } CALL_CATCH_EXCEPTION();
47385   }
47386
47387 }
47388
47389
47390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
47391   unsigned int jresult ;
47392   unsigned int result;
47393
47394   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
47395   jresult = result;
47396   return jresult;
47397 }
47398
47399
47400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
47401   int jresult ;
47402   int result;
47403
47404   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
47405   jresult = (int)result;
47406   return jresult;
47407 }
47408
47409
47410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
47411   int jresult ;
47412   int result;
47413
47414   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
47415   jresult = (int)result;
47416   return jresult;
47417 }
47418
47419
47420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
47421   int jresult ;
47422   int result;
47423
47424   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
47425   jresult = (int)result;
47426   return jresult;
47427 }
47428
47429
47430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
47431   int jresult ;
47432   int result;
47433
47434   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
47435   jresult = (int)result;
47436   return jresult;
47437 }
47438
47439
47440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
47441   int jresult ;
47442   int result;
47443
47444   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
47445   jresult = (int)result;
47446   return jresult;
47447 }
47448
47449
47450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
47451   int jresult ;
47452   int result;
47453
47454   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
47455   jresult = (int)result;
47456   return jresult;
47457 }
47458
47459
47460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
47461   int jresult ;
47462   int result;
47463
47464   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
47465   jresult = (int)result;
47466   return jresult;
47467 }
47468
47469
47470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
47471   int jresult ;
47472   int result;
47473
47474   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
47475   jresult = (int)result;
47476   return jresult;
47477 }
47478
47479
47480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
47481   int jresult ;
47482   int result;
47483
47484   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
47485   jresult = (int)result;
47486   return jresult;
47487 }
47488
47489
47490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
47491   int jresult ;
47492   int result;
47493
47494   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
47495   jresult = (int)result;
47496   return jresult;
47497 }
47498
47499
47500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
47501   int jresult ;
47502   int result;
47503
47504   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
47505   jresult = (int)result;
47506   return jresult;
47507 }
47508
47509
47510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
47511   int jresult ;
47512   int result;
47513
47514   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
47515   jresult = (int)result;
47516   return jresult;
47517 }
47518
47519
47520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
47521   int jresult ;
47522   int result;
47523
47524   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
47525   jresult = (int)result;
47526   return jresult;
47527 }
47528
47529
47530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
47531   int jresult ;
47532   int result;
47533
47534   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
47535   jresult = (int)result;
47536   return jresult;
47537 }
47538
47539
47540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
47541   int jresult ;
47542   int result;
47543
47544   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
47545   jresult = (int)result;
47546   return jresult;
47547 }
47548
47549
47550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
47551   int jresult ;
47552   int result;
47553
47554   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
47555   jresult = (int)result;
47556   return jresult;
47557 }
47558
47559
47560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
47561   int jresult ;
47562   int result;
47563
47564   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
47565   jresult = (int)result;
47566   return jresult;
47567 }
47568
47569
47570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
47571   int jresult ;
47572   int result;
47573
47574   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
47575   jresult = (int)result;
47576   return jresult;
47577 }
47578
47579
47580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
47581   void * jresult ;
47582   Dali::Toolkit::TextLabel::Property *result = 0 ;
47583
47584   {
47585     try {
47586       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
47587     } CALL_CATCH_EXCEPTION(0);
47588   }
47589
47590   jresult = (void *)result;
47591   return jresult;
47592 }
47593
47594
47595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
47596   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
47597
47598   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
47599   {
47600     try {
47601       delete arg1;
47602     } CALL_CATCH_EXCEPTION();
47603   }
47604
47605 }
47606
47607
47608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
47609   void * jresult ;
47610   Dali::Toolkit::TextLabel result;
47611
47612   {
47613     try {
47614       result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
47615     } CALL_CATCH_EXCEPTION(0);
47616   }
47617
47618   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47619   return jresult;
47620 }
47621
47622
47623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
47624   void * jresult ;
47625   std::string *arg1 = 0 ;
47626   Dali::Toolkit::TextLabel result;
47627
47628   if (!jarg1) {
47629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47630     return 0;
47631   }
47632   std::string arg1_str(jarg1);
47633   arg1 = &arg1_str;
47634   {
47635     try {
47636       result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1);
47637     } CALL_CATCH_EXCEPTION(0);
47638   }
47639
47640   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47641
47642   //argout typemap for const std::string&
47643
47644   return jresult;
47645 }
47646
47647
47648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
47649   void * jresult ;
47650   Dali::Toolkit::TextLabel *result = 0 ;
47651
47652   {
47653     try {
47654       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
47655     } CALL_CATCH_EXCEPTION(0);
47656   }
47657
47658   jresult = (void *)result;
47659   return jresult;
47660 }
47661
47662
47663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
47664   void * jresult ;
47665   Dali::Toolkit::TextLabel *arg1 = 0 ;
47666   Dali::Toolkit::TextLabel *result = 0 ;
47667
47668   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47669   if (!arg1) {
47670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47671     return 0;
47672   }
47673   {
47674     try {
47675       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
47676     } CALL_CATCH_EXCEPTION(0);
47677   }
47678
47679   jresult = (void *)result;
47680   return jresult;
47681 }
47682
47683
47684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
47685   void * jresult ;
47686   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47687   Dali::Toolkit::TextLabel *arg2 = 0 ;
47688   Dali::Toolkit::TextLabel *result = 0 ;
47689
47690   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47691   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
47692   if (!arg2) {
47693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47694     return 0;
47695   }
47696   {
47697     try {
47698       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
47699     } CALL_CATCH_EXCEPTION(0);
47700   }
47701
47702   jresult = (void *)result;
47703   return jresult;
47704 }
47705
47706
47707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
47708   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47709
47710   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47711   {
47712     try {
47713       delete arg1;
47714     } CALL_CATCH_EXCEPTION();
47715   }
47716
47717 }
47718
47719
47720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
47721   void * jresult ;
47722   Dali::BaseHandle arg1 ;
47723   Dali::BaseHandle *argp1 ;
47724   Dali::Toolkit::TextLabel result;
47725
47726   argp1 = (Dali::BaseHandle *)jarg1;
47727   if (!argp1) {
47728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47729     return 0;
47730   }
47731   arg1 = *argp1;
47732   {
47733     try {
47734       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47735     } CALL_CATCH_EXCEPTION(0);
47736   }
47737
47738   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47739   return jresult;
47740 }
47741
47742
47743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47744   void * jresult ;
47745   Dali::Toolkit::AccessibilityManager *result = 0 ;
47746
47747   {
47748     try {
47749       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47750     } CALL_CATCH_EXCEPTION(0);
47751   }
47752
47753   jresult = (void *)result;
47754   return jresult;
47755 }
47756
47757
47758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47760
47761   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47762   {
47763     try {
47764       delete arg1;
47765     } CALL_CATCH_EXCEPTION();
47766   }
47767
47768 }
47769
47770
47771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47772   void * jresult ;
47773   Dali::Toolkit::AccessibilityManager result;
47774
47775   {
47776     try {
47777       result = Dali::Toolkit::AccessibilityManager::Get();
47778     } CALL_CATCH_EXCEPTION(0);
47779   }
47780
47781   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47782   return jresult;
47783 }
47784
47785
47786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47788   Dali::Actor arg2 ;
47789   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47790   std::string *arg4 = 0 ;
47791   Dali::Actor *argp2 ;
47792
47793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47794   argp2 = (Dali::Actor *)jarg2;
47795   if (!argp2) {
47796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47797     return ;
47798   }
47799   arg2 = *argp2;
47800   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47801   if (!jarg4) {
47802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47803     return ;
47804   }
47805   std::string arg4_str(jarg4);
47806   arg4 = &arg4_str;
47807   {
47808     try {
47809       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47810     } CALL_CATCH_EXCEPTION();
47811   }
47812
47813
47814   //argout typemap for const std::string&
47815
47816 }
47817
47818
47819 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47820   char * jresult ;
47821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47822   Dali::Actor arg2 ;
47823   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47824   Dali::Actor *argp2 ;
47825   std::string result;
47826
47827   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47828   argp2 = (Dali::Actor *)jarg2;
47829   if (!argp2) {
47830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47831     return 0;
47832   }
47833   arg2 = *argp2;
47834   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47835   {
47836     try {
47837       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47838     } CALL_CATCH_EXCEPTION(0);
47839   }
47840
47841   jresult = SWIG_csharp_string_callback((&result)->c_str());
47842   return jresult;
47843 }
47844
47845
47846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47847   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47848   Dali::Actor arg2 ;
47849   unsigned int arg3 ;
47850   Dali::Actor *argp2 ;
47851
47852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47853   argp2 = (Dali::Actor *)jarg2;
47854   if (!argp2) {
47855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47856     return ;
47857   }
47858   arg2 = *argp2;
47859   arg3 = (unsigned int)jarg3;
47860   {
47861     try {
47862       (arg1)->SetFocusOrder(arg2,arg3);
47863     } CALL_CATCH_EXCEPTION();
47864   }
47865
47866 }
47867
47868
47869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47870   unsigned int jresult ;
47871   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47872   Dali::Actor arg2 ;
47873   Dali::Actor *argp2 ;
47874   unsigned int result;
47875
47876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47877   argp2 = (Dali::Actor *)jarg2;
47878   if (!argp2) {
47879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47880     return 0;
47881   }
47882   arg2 = *argp2;
47883   {
47884     try {
47885       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47886     } CALL_CATCH_EXCEPTION(0);
47887   }
47888
47889   jresult = result;
47890   return jresult;
47891 }
47892
47893
47894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47895   unsigned int jresult ;
47896   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47897   unsigned int result;
47898
47899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47900   {
47901     try {
47902       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47903     } CALL_CATCH_EXCEPTION(0);
47904   }
47905
47906   jresult = result;
47907   return jresult;
47908 }
47909
47910
47911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47912   void * jresult ;
47913   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47914   unsigned int arg2 ;
47915   Dali::Actor result;
47916
47917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47918   arg2 = (unsigned int)jarg2;
47919   {
47920     try {
47921       result = (arg1)->GetActorByFocusOrder(arg2);
47922     } CALL_CATCH_EXCEPTION(0);
47923   }
47924
47925   jresult = new Dali::Actor((const Dali::Actor &)result);
47926   return jresult;
47927 }
47928
47929
47930 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47931   bool jresult ;
47932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47933   Dali::Actor arg2 ;
47934   Dali::Actor *argp2 ;
47935   bool result;
47936
47937   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47938   argp2 = (Dali::Actor *)jarg2;
47939   if (!argp2) {
47940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47941     return 0;
47942   }
47943   arg2 = *argp2;
47944   {
47945     try {
47946       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47947     } CALL_CATCH_EXCEPTION(0);
47948   }
47949
47950   jresult = result;
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47956   void * jresult ;
47957   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47958   Dali::Actor result;
47959
47960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47961   {
47962     try {
47963       result = (arg1)->GetCurrentFocusActor();
47964     } CALL_CATCH_EXCEPTION(0);
47965   }
47966
47967   jresult = new Dali::Actor((const Dali::Actor &)result);
47968   return jresult;
47969 }
47970
47971
47972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47973   void * jresult ;
47974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47975   Dali::Actor result;
47976
47977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47978   {
47979     try {
47980       result = (arg1)->GetCurrentFocusGroup();
47981     } CALL_CATCH_EXCEPTION(0);
47982   }
47983
47984   jresult = new Dali::Actor((const Dali::Actor &)result);
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47990   unsigned int jresult ;
47991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47992   unsigned int result;
47993
47994   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47995   {
47996     try {
47997       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47998     } CALL_CATCH_EXCEPTION(0);
47999   }
48000
48001   jresult = result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
48007   bool jresult ;
48008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48009   bool result;
48010
48011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48012   {
48013     try {
48014       result = (bool)(arg1)->MoveFocusForward();
48015     } CALL_CATCH_EXCEPTION(0);
48016   }
48017
48018   jresult = result;
48019   return jresult;
48020 }
48021
48022
48023 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
48024   bool jresult ;
48025   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48026   bool result;
48027
48028   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48029   {
48030     try {
48031       result = (bool)(arg1)->MoveFocusBackward();
48032     } CALL_CATCH_EXCEPTION(0);
48033   }
48034
48035   jresult = result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
48041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48042
48043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48044   {
48045     try {
48046       (arg1)->ClearFocus();
48047     } CALL_CATCH_EXCEPTION();
48048   }
48049
48050 }
48051
48052
48053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
48054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48055
48056   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48057   {
48058     try {
48059       (arg1)->Reset();
48060     } CALL_CATCH_EXCEPTION();
48061   }
48062
48063 }
48064
48065
48066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) {
48067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48068   Dali::Actor arg2 ;
48069   bool arg3 ;
48070   Dali::Actor *argp2 ;
48071
48072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48073   argp2 = (Dali::Actor *)jarg2;
48074   if (!argp2) {
48075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48076     return ;
48077   }
48078   arg2 = *argp2;
48079   arg3 = jarg3 ? true : false;
48080   {
48081     try {
48082       (arg1)->SetFocusGroup(arg2,arg3);
48083     } CALL_CATCH_EXCEPTION();
48084   }
48085
48086 }
48087
48088
48089 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
48090   bool jresult ;
48091   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48092   Dali::Actor arg2 ;
48093   Dali::Actor *argp2 ;
48094   bool result;
48095
48096   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48097   argp2 = (Dali::Actor *)jarg2;
48098   if (!argp2) {
48099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48100     return 0;
48101   }
48102   arg2 = *argp2;
48103   {
48104     try {
48105       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
48106     } CALL_CATCH_EXCEPTION(0);
48107   }
48108
48109   jresult = result;
48110   return jresult;
48111 }
48112
48113
48114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) {
48115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48116   bool arg2 ;
48117
48118   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48119   arg2 = jarg2 ? true : false;
48120   {
48121     try {
48122       (arg1)->SetGroupMode(arg2);
48123     } CALL_CATCH_EXCEPTION();
48124   }
48125
48126 }
48127
48128
48129 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
48130   bool jresult ;
48131   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48132   bool result;
48133
48134   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48135   {
48136     try {
48137       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
48138     } CALL_CATCH_EXCEPTION(0);
48139   }
48140
48141   jresult = result;
48142   return jresult;
48143 }
48144
48145
48146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) {
48147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48148   bool arg2 ;
48149
48150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48151   arg2 = jarg2 ? true : false;
48152   {
48153     try {
48154       (arg1)->SetWrapMode(arg2);
48155     } CALL_CATCH_EXCEPTION();
48156   }
48157
48158 }
48159
48160
48161 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
48162   bool jresult ;
48163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48164   bool result;
48165
48166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48167   {
48168     try {
48169       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
48170     } CALL_CATCH_EXCEPTION(0);
48171   }
48172
48173   jresult = result;
48174   return jresult;
48175 }
48176
48177
48178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
48179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48180   Dali::Actor arg2 ;
48181   Dali::Actor *argp2 ;
48182
48183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48184   argp2 = (Dali::Actor *)jarg2;
48185   if (!argp2) {
48186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48187     return ;
48188   }
48189   arg2 = *argp2;
48190   {
48191     try {
48192       (arg1)->SetFocusIndicatorActor(arg2);
48193     } CALL_CATCH_EXCEPTION();
48194   }
48195
48196 }
48197
48198
48199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
48200   void * jresult ;
48201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48202   Dali::Actor result;
48203
48204   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48205   {
48206     try {
48207       result = (arg1)->GetFocusIndicatorActor();
48208     } CALL_CATCH_EXCEPTION(0);
48209   }
48210
48211   jresult = new Dali::Actor((const Dali::Actor &)result);
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
48217   void * jresult ;
48218   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48219   Dali::Actor arg2 ;
48220   Dali::Actor *argp2 ;
48221   Dali::Actor result;
48222
48223   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48224   argp2 = (Dali::Actor *)jarg2;
48225   if (!argp2) {
48226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48227     return 0;
48228   }
48229   arg2 = *argp2;
48230   {
48231     try {
48232       result = (arg1)->GetFocusGroup(arg2);
48233     } CALL_CATCH_EXCEPTION(0);
48234   }
48235
48236   jresult = new Dali::Actor((const Dali::Actor &)result);
48237   return jresult;
48238 }
48239
48240
48241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
48242   void * jresult ;
48243   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48244   Dali::Vector2 result;
48245
48246   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48247   {
48248     try {
48249       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
48250     } CALL_CATCH_EXCEPTION(0);
48251   }
48252
48253   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
48254   return jresult;
48255 }
48256
48257
48258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
48259   void * jresult ;
48260   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48261   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
48262
48263   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48264   {
48265     try {
48266       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
48267     } CALL_CATCH_EXCEPTION(0);
48268   }
48269
48270   jresult = (void *)result;
48271   return jresult;
48272 }
48273
48274
48275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
48276   void * jresult ;
48277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48278   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
48279
48280   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48281   {
48282     try {
48283       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
48284     } CALL_CATCH_EXCEPTION(0);
48285   }
48286
48287   jresult = (void *)result;
48288   return jresult;
48289 }
48290
48291
48292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
48293   void * jresult ;
48294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48295   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
48296
48297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48298   {
48299     try {
48300       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
48301     } CALL_CATCH_EXCEPTION(0);
48302   }
48303
48304   jresult = (void *)result;
48305   return jresult;
48306 }
48307
48308
48309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
48310   void * jresult ;
48311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48312   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48313
48314   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48315   {
48316     try {
48317       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
48318     } CALL_CATCH_EXCEPTION(0);
48319   }
48320
48321   jresult = (void *)result;
48322   return jresult;
48323 }
48324
48325
48326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
48327   void * jresult ;
48328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48329   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48330
48331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48332   {
48333     try {
48334       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
48335     } CALL_CATCH_EXCEPTION(0);
48336   }
48337
48338   jresult = (void *)result;
48339   return jresult;
48340 }
48341
48342
48343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
48344   void * jresult ;
48345   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48346   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48347
48348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48349   {
48350     try {
48351       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
48352     } CALL_CATCH_EXCEPTION(0);
48353   }
48354
48355   jresult = (void *)result;
48356   return jresult;
48357 }
48358
48359
48360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
48361   void * jresult ;
48362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48363   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48364
48365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48366   {
48367     try {
48368       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
48369     } CALL_CATCH_EXCEPTION(0);
48370   }
48371
48372   jresult = (void *)result;
48373   return jresult;
48374 }
48375
48376
48377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
48378   void * jresult ;
48379   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48380   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48381
48382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48383   {
48384     try {
48385       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
48386     } CALL_CATCH_EXCEPTION(0);
48387   }
48388
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
48395   void * jresult ;
48396   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48397   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48398
48399   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48400   {
48401     try {
48402       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
48403     } CALL_CATCH_EXCEPTION(0);
48404   }
48405
48406   jresult = (void *)result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
48412   void * jresult ;
48413   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48414   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48415
48416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48417   {
48418     try {
48419       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
48420     } CALL_CATCH_EXCEPTION(0);
48421   }
48422
48423   jresult = (void *)result;
48424   return jresult;
48425 }
48426
48427
48428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
48429   void * jresult ;
48430   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48431   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48432
48433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48434   {
48435     try {
48436       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
48437     } CALL_CATCH_EXCEPTION(0);
48438   }
48439
48440   jresult = (void *)result;
48441   return jresult;
48442 }
48443
48444
48445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
48446   void * jresult ;
48447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48448   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48449
48450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48451   {
48452     try {
48453       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
48454     } CALL_CATCH_EXCEPTION(0);
48455   }
48456
48457   jresult = (void *)result;
48458   return jresult;
48459 }
48460
48461
48462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
48463   void * jresult ;
48464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48465   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48466
48467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48468   {
48469     try {
48470       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
48471     } CALL_CATCH_EXCEPTION(0);
48472   }
48473
48474   jresult = (void *)result;
48475   return jresult;
48476 }
48477
48478
48479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
48480   void * jresult ;
48481   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48482   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48483
48484   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48485   {
48486     try {
48487       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
48488     } CALL_CATCH_EXCEPTION(0);
48489   }
48490
48491   jresult = (void *)result;
48492   return jresult;
48493 }
48494
48495
48496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
48497   void * jresult ;
48498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48499   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48500
48501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48502   {
48503     try {
48504       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
48505     } CALL_CATCH_EXCEPTION(0);
48506   }
48507
48508   jresult = (void *)result;
48509   return jresult;
48510 }
48511
48512
48513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
48514   void * jresult ;
48515   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48516   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48517
48518   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48519   {
48520     try {
48521       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
48522     } CALL_CATCH_EXCEPTION(0);
48523   }
48524
48525   jresult = (void *)result;
48526   return jresult;
48527 }
48528
48529
48530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
48531   void * jresult ;
48532   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48533   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48534
48535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48536   {
48537     try {
48538       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
48539     } CALL_CATCH_EXCEPTION(0);
48540   }
48541
48542   jresult = (void *)result;
48543   return jresult;
48544 }
48545
48546
48547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
48548   void * jresult ;
48549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48550   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48551
48552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48553   {
48554     try {
48555       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
48556     } CALL_CATCH_EXCEPTION(0);
48557   }
48558
48559   jresult = (void *)result;
48560   return jresult;
48561 }
48562
48563
48564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
48565   void * jresult ;
48566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48567   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48568
48569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48570   {
48571     try {
48572       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
48573     } CALL_CATCH_EXCEPTION(0);
48574   }
48575
48576   jresult = (void *)result;
48577   return jresult;
48578 }
48579
48580
48581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
48582   void * jresult ;
48583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48584   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48585
48586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48587   {
48588     try {
48589       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
48590     } CALL_CATCH_EXCEPTION(0);
48591   }
48592
48593   jresult = (void *)result;
48594   return jresult;
48595 }
48596
48597
48598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
48599   void * jresult ;
48600   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48601   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48602
48603   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48604   {
48605     try {
48606       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
48607     } CALL_CATCH_EXCEPTION(0);
48608   }
48609
48610   jresult = (void *)result;
48611   return jresult;
48612 }
48613
48614
48615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
48616   void * jresult ;
48617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48618   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48619
48620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48621   {
48622     try {
48623       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
48624     } CALL_CATCH_EXCEPTION(0);
48625   }
48626
48627   jresult = (void *)result;
48628   return jresult;
48629 }
48630
48631
48632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
48633   void * jresult ;
48634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48635   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48636
48637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48638   {
48639     try {
48640       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
48641     } CALL_CATCH_EXCEPTION(0);
48642   }
48643
48644   jresult = (void *)result;
48645   return jresult;
48646 }
48647
48648
48649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
48650   void * jresult ;
48651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48652   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48653
48654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48655   {
48656     try {
48657       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
48658     } CALL_CATCH_EXCEPTION(0);
48659   }
48660
48661   jresult = (void *)result;
48662   return jresult;
48663 }
48664
48665
48666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
48667   void * jresult ;
48668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48669   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48670
48671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48672   {
48673     try {
48674       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
48675     } CALL_CATCH_EXCEPTION(0);
48676   }
48677
48678   jresult = (void *)result;
48679   return jresult;
48680 }
48681
48682
48683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
48684   void * jresult ;
48685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48686   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48687
48688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48689   {
48690     try {
48691       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
48692     } CALL_CATCH_EXCEPTION(0);
48693   }
48694
48695   jresult = (void *)result;
48696   return jresult;
48697 }
48698
48699
48700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
48701   void * jresult ;
48702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48703   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48704
48705   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48706   {
48707     try {
48708       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
48709     } CALL_CATCH_EXCEPTION(0);
48710   }
48711
48712   jresult = (void *)result;
48713   return jresult;
48714 }
48715
48716
48717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
48718   void * jresult ;
48719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48720   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48721
48722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48723   {
48724     try {
48725       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
48726     } CALL_CATCH_EXCEPTION(0);
48727   }
48728
48729   jresult = (void *)result;
48730   return jresult;
48731 }
48732
48733
48734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48735   void * jresult ;
48736   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48737   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48738
48739   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48740   {
48741     try {
48742       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48743     } CALL_CATCH_EXCEPTION(0);
48744   }
48745
48746   jresult = (void *)result;
48747   return jresult;
48748 }
48749
48750
48751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48752   void * jresult ;
48753   Dali::Toolkit::StyleManager *result = 0 ;
48754
48755   {
48756     try {
48757       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48758     } CALL_CATCH_EXCEPTION(0);
48759   }
48760
48761   jresult = (void *)result;
48762   return jresult;
48763 }
48764
48765
48766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48767   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48768
48769   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48770   {
48771     try {
48772       delete arg1;
48773     } CALL_CATCH_EXCEPTION();
48774   }
48775
48776 }
48777
48778
48779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48780   void * jresult ;
48781   Dali::Toolkit::StyleManager result;
48782
48783   {
48784     try {
48785       result = Dali::Toolkit::StyleManager::Get();
48786     } CALL_CATCH_EXCEPTION(0);
48787   }
48788
48789   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48790   return jresult;
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48795   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48796   std::string *arg2 = 0 ;
48797
48798   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48799   if (!jarg2) {
48800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48801     return ;
48802   }
48803   std::string arg2_str(jarg2);
48804   arg2 = &arg2_str;
48805   {
48806     try {
48807       (arg1)->ApplyTheme((std::string const &)*arg2);
48808     } CALL_CATCH_EXCEPTION();
48809   }
48810
48811
48812   //argout typemap for const std::string&
48813
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48818   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48819
48820   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48821   {
48822     try {
48823       (arg1)->ApplyDefaultTheme();
48824     } CALL_CATCH_EXCEPTION();
48825   }
48826
48827 }
48828
48829
48830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48831   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48832   std::string *arg2 = 0 ;
48833   Dali::Property::Value *arg3 = 0 ;
48834
48835   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48836   if (!jarg2) {
48837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48838     return ;
48839   }
48840   std::string arg2_str(jarg2);
48841   arg2 = &arg2_str;
48842   arg3 = (Dali::Property::Value *)jarg3;
48843   if (!arg3) {
48844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48845     return ;
48846   }
48847   {
48848     try {
48849       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48850     } CALL_CATCH_EXCEPTION();
48851   }
48852
48853
48854   //argout typemap for const std::string&
48855
48856 }
48857
48858
48859 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48860   bool jresult ;
48861   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48862   std::string *arg2 = 0 ;
48863   Dali::Property::Value *arg3 = 0 ;
48864   bool result;
48865
48866   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48867   if (!jarg2) {
48868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48869     return 0;
48870   }
48871   std::string arg2_str(jarg2);
48872   arg2 = &arg2_str;
48873   arg3 = (Dali::Property::Value *)jarg3;
48874   if (!arg3) {
48875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48876     return 0;
48877   }
48878   {
48879     try {
48880       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48881     } CALL_CATCH_EXCEPTION(0);
48882   }
48883
48884   jresult = result;
48885
48886   //argout typemap for const std::string&
48887
48888   return jresult;
48889 }
48890
48891
48892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48893   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48894   Dali::Toolkit::Control arg2 ;
48895   std::string *arg3 = 0 ;
48896   std::string *arg4 = 0 ;
48897   Dali::Toolkit::Control *argp2 ;
48898
48899   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48900   argp2 = (Dali::Toolkit::Control *)jarg2;
48901   if (!argp2) {
48902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48903     return ;
48904   }
48905   arg2 = *argp2;
48906   if (!jarg3) {
48907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48908     return ;
48909   }
48910   std::string arg3_str(jarg3);
48911   arg3 = &arg3_str;
48912   if (!jarg4) {
48913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48914     return ;
48915   }
48916   std::string arg4_str(jarg4);
48917   arg4 = &arg4_str;
48918   {
48919     try {
48920       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48921     } CALL_CATCH_EXCEPTION();
48922   }
48923
48924
48925   //argout typemap for const std::string&
48926
48927
48928   //argout typemap for const std::string&
48929
48930 }
48931
48932
48933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48934   void * jresult ;
48935   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48936   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48937
48938   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48939   {
48940     try {
48941       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48942     } CALL_CATCH_EXCEPTION(0);
48943   }
48944
48945   jresult = (void *)result;
48946   return jresult;
48947 }
48948
48949
48950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48951   int jresult ;
48952   int result;
48953
48954   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48955   jresult = (int)result;
48956   return jresult;
48957 }
48958
48959
48960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48961   int jresult ;
48962   int result;
48963
48964   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48965   jresult = (int)result;
48966   return jresult;
48967 }
48968
48969
48970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48971   int jresult ;
48972   int result;
48973
48974   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48975   jresult = (int)result;
48976   return jresult;
48977 }
48978
48979
48980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48981   int jresult ;
48982   int result;
48983
48984   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48985   jresult = (int)result;
48986   return jresult;
48987 }
48988
48989
48990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48991   int jresult ;
48992   int result;
48993
48994   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48995   jresult = (int)result;
48996   return jresult;
48997 }
48998
48999
49000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
49001   int jresult ;
49002   int result;
49003
49004   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
49005   jresult = (int)result;
49006   return jresult;
49007 }
49008
49009
49010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
49011   int jresult ;
49012   int result;
49013
49014   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
49015   jresult = (int)result;
49016   return jresult;
49017 }
49018
49019
49020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
49021   int jresult ;
49022   int result;
49023
49024   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
49025   jresult = (int)result;
49026   return jresult;
49027 }
49028
49029
49030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
49031   int jresult ;
49032   int result;
49033
49034   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
49035   jresult = (int)result;
49036   return jresult;
49037 }
49038
49039
49040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
49041   int jresult ;
49042   int result;
49043
49044   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
49045   jresult = (int)result;
49046   return jresult;
49047 }
49048
49049
49050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
49051   int jresult ;
49052   int result;
49053
49054   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
49055   jresult = (int)result;
49056   return jresult;
49057 }
49058
49059
49060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
49061   int jresult ;
49062   int result;
49063
49064   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
49065   jresult = (int)result;
49066   return jresult;
49067 }
49068
49069
49070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
49071   int jresult ;
49072   int result;
49073
49074   result = (int)Dali::Toolkit::Slider::Property::MARKS;
49075   jresult = (int)result;
49076   return jresult;
49077 }
49078
49079
49080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
49081   int jresult ;
49082   int result;
49083
49084   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
49085   jresult = (int)result;
49086   return jresult;
49087 }
49088
49089
49090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
49091   int jresult ;
49092   int result;
49093
49094   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
49095   jresult = (int)result;
49096   return jresult;
49097 }
49098
49099
49100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
49101   void * jresult ;
49102   Dali::Toolkit::Slider::Property *result = 0 ;
49103
49104   {
49105     try {
49106       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
49107     } CALL_CATCH_EXCEPTION(0);
49108   }
49109
49110   jresult = (void *)result;
49111   return jresult;
49112 }
49113
49114
49115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
49116   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
49117
49118   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
49119   {
49120     try {
49121       delete arg1;
49122     } CALL_CATCH_EXCEPTION();
49123   }
49124
49125 }
49126
49127
49128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
49129   void * jresult ;
49130   Dali::Toolkit::Slider result;
49131
49132   {
49133     try {
49134       result = Dali::Toolkit::Slider::New();
49135     } CALL_CATCH_EXCEPTION(0);
49136   }
49137
49138   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
49139   return jresult;
49140 }
49141
49142
49143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
49144   void * jresult ;
49145   Dali::Toolkit::Slider *result = 0 ;
49146
49147   {
49148     try {
49149       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
49150     } CALL_CATCH_EXCEPTION(0);
49151   }
49152
49153   jresult = (void *)result;
49154   return jresult;
49155 }
49156
49157
49158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
49159   void * jresult ;
49160   Dali::Toolkit::Slider *arg1 = 0 ;
49161   Dali::Toolkit::Slider *result = 0 ;
49162
49163   arg1 = (Dali::Toolkit::Slider *)jarg1;
49164   if (!arg1) {
49165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
49166     return 0;
49167   }
49168   {
49169     try {
49170       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
49171     } CALL_CATCH_EXCEPTION(0);
49172   }
49173
49174   jresult = (void *)result;
49175   return jresult;
49176 }
49177
49178
49179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
49180   void * jresult ;
49181   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49182   Dali::Toolkit::Slider *arg2 = 0 ;
49183   Dali::Toolkit::Slider *result = 0 ;
49184
49185   arg1 = (Dali::Toolkit::Slider *)jarg1;
49186   arg2 = (Dali::Toolkit::Slider *)jarg2;
49187   if (!arg2) {
49188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
49189     return 0;
49190   }
49191   {
49192     try {
49193       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
49194     } CALL_CATCH_EXCEPTION(0);
49195   }
49196
49197   jresult = (void *)result;
49198   return jresult;
49199 }
49200
49201
49202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
49203   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49204
49205   arg1 = (Dali::Toolkit::Slider *)jarg1;
49206   {
49207     try {
49208       delete arg1;
49209     } CALL_CATCH_EXCEPTION();
49210   }
49211
49212 }
49213
49214
49215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
49216   void * jresult ;
49217   Dali::BaseHandle arg1 ;
49218   Dali::BaseHandle *argp1 ;
49219   Dali::Toolkit::Slider result;
49220
49221   argp1 = (Dali::BaseHandle *)jarg1;
49222   if (!argp1) {
49223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49224     return 0;
49225   }
49226   arg1 = *argp1;
49227   {
49228     try {
49229       result = Dali::Toolkit::Slider::DownCast(arg1);
49230     } CALL_CATCH_EXCEPTION(0);
49231   }
49232
49233   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
49234   return jresult;
49235 }
49236
49237
49238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
49239   void * jresult ;
49240   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49241   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
49242
49243   arg1 = (Dali::Toolkit::Slider *)jarg1;
49244   {
49245     try {
49246       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49247     } CALL_CATCH_EXCEPTION(0);
49248   }
49249
49250   jresult = (void *)result;
49251   return jresult;
49252 }
49253
49254
49255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
49256   void * jresult ;
49257   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49258   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
49259
49260   arg1 = (Dali::Toolkit::Slider *)jarg1;
49261   {
49262     try {
49263       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
49264     } CALL_CATCH_EXCEPTION(0);
49265   }
49266
49267   jresult = (void *)result;
49268   return jresult;
49269 }
49270
49271
49272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
49273   void * jresult ;
49274   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
49275   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
49276
49277   arg1 = (Dali::Toolkit::Slider *)jarg1;
49278   {
49279     try {
49280       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
49281     } CALL_CATCH_EXCEPTION(0);
49282   }
49283
49284   jresult = (void *)result;
49285   return jresult;
49286 }
49287
49288
49289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
49290   int jresult ;
49291   int result;
49292
49293   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
49294   jresult = (int)result;
49295   return jresult;
49296 }
49297
49298
49299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
49300   int jresult ;
49301   int result;
49302
49303   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
49304   jresult = (int)result;
49305   return jresult;
49306 }
49307
49308
49309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
49310   int jresult ;
49311   int result;
49312
49313   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
49314   jresult = (int)result;
49315   return jresult;
49316 }
49317
49318
49319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
49320   int jresult ;
49321   int result;
49322
49323   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
49324   jresult = (int)result;
49325   return jresult;
49326 }
49327
49328
49329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
49330   int result;
49331
49332   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
49333
49334   return result;
49335 }
49336
49337
49338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
49339   void * jresult ;
49340   Dali::Toolkit::VideoView::Property *result = 0 ;
49341
49342   {
49343     try {
49344       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
49345     } CALL_CATCH_EXCEPTION(0);
49346   }
49347
49348   jresult = (void *)result;
49349   return jresult;
49350 }
49351
49352
49353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
49354   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
49355
49356   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
49357   {
49358     try {
49359       delete arg1;
49360     } CALL_CATCH_EXCEPTION();
49361   }
49362
49363 }
49364
49365
49366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
49367   void * jresult ;
49368   Dali::Toolkit::VideoView result;
49369
49370   {
49371     try {
49372       result = Dali::Toolkit::VideoView::New();
49373     } CALL_CATCH_EXCEPTION(0);
49374   }
49375
49376   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49377   return jresult;
49378 }
49379
49380
49381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
49382   void * jresult ;
49383   std::string *arg1 = 0 ;
49384   Dali::Toolkit::VideoView result;
49385
49386   if (!jarg1) {
49387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49388     return 0;
49389   }
49390   std::string arg1_str(jarg1);
49391   arg1 = &arg1_str;
49392   {
49393     try {
49394       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
49395     } CALL_CATCH_EXCEPTION(0);
49396   }
49397
49398   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49399
49400   //argout typemap for const std::string&
49401
49402   return jresult;
49403 }
49404
49405
49406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
49407   void * jresult ;
49408   Dali::Toolkit::VideoView result;
49409   {
49410     try {
49411       result = Dali::Toolkit::VideoView::New(swCodec);
49412     } CALL_CATCH_EXCEPTION(0);
49413   }
49414
49415   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49416
49417   //argout typemap for const std::string&
49418
49419   return jresult;
49420 }
49421
49422
49423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
49424   void * jresult ;
49425   std::string *arg1 = 0 ;
49426   Dali::Toolkit::VideoView result;
49427
49428   if (!jarg1) {
49429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49430     return 0;
49431   }
49432   std::string arg1_str(jarg1);
49433   arg1 = &arg1_str;
49434   {
49435     try {
49436       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
49437     } CALL_CATCH_EXCEPTION(0);
49438   }
49439
49440   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49441
49442   //argout typemap for const std::string&
49443
49444   return jresult;
49445 }
49446
49447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) {
49448   void * jresult ;
49449   Dali::VideoSyncMode syncMode;
49450   Dali::Toolkit::VideoView result;
49451
49452   syncMode = static_cast<Dali::VideoSyncMode>(jarg1);
49453
49454   {
49455     try {
49456       result = Dali::Toolkit::DevelVideoView::New(syncMode);
49457     } CALL_CATCH_EXCEPTION(0);
49458   }
49459
49460   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49461
49462   return jresult;
49463 }
49464
49465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
49466   void * jresult ;
49467   Dali::Toolkit::VideoView *result = 0 ;
49468
49469   {
49470     try {
49471       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
49472     } CALL_CATCH_EXCEPTION(0);
49473   }
49474
49475   jresult = (void *)result;
49476   return jresult;
49477 }
49478
49479
49480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
49481   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49482
49483   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49484   {
49485     try {
49486       delete arg1;
49487     } CALL_CATCH_EXCEPTION();
49488   }
49489
49490 }
49491
49492
49493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
49494   void * jresult ;
49495   Dali::Toolkit::VideoView *arg1 = 0 ;
49496   Dali::Toolkit::VideoView *result = 0 ;
49497
49498   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49499   if (!arg1) {
49500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
49501     return 0;
49502   }
49503   {
49504     try {
49505       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
49506     } CALL_CATCH_EXCEPTION(0);
49507   }
49508
49509   jresult = (void *)result;
49510   return jresult;
49511 }
49512
49513
49514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
49515   void * jresult ;
49516   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49517   Dali::Toolkit::VideoView *arg2 = 0 ;
49518   Dali::Toolkit::VideoView *result = 0 ;
49519
49520   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49521   arg2 = (Dali::Toolkit::VideoView *)jarg2;
49522   if (!arg2) {
49523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
49524     return 0;
49525   }
49526   {
49527     try {
49528       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
49529     } CALL_CATCH_EXCEPTION(0);
49530   }
49531
49532   jresult = (void *)result;
49533   return jresult;
49534 }
49535
49536
49537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
49538   void * jresult ;
49539   Dali::BaseHandle arg1 ;
49540   Dali::BaseHandle *argp1 ;
49541   Dali::Toolkit::VideoView result;
49542
49543   argp1 = (Dali::BaseHandle *)jarg1;
49544   if (!argp1) {
49545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49546     return 0;
49547   }
49548   arg1 = *argp1;
49549   {
49550     try {
49551       result = Dali::Toolkit::VideoView::DownCast(arg1);
49552     } CALL_CATCH_EXCEPTION(0);
49553   }
49554
49555   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
49561   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49562
49563   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49564   {
49565     try {
49566       (arg1)->Play();
49567     } CALL_CATCH_EXCEPTION();
49568   }
49569
49570 }
49571
49572
49573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
49574   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49575
49576   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49577   {
49578     try {
49579       (arg1)->Pause();
49580     } CALL_CATCH_EXCEPTION();
49581   }
49582
49583 }
49584
49585
49586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
49587   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49588
49589   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49590   {
49591     try {
49592       (arg1)->Stop();
49593     } CALL_CATCH_EXCEPTION();
49594   }
49595
49596 }
49597
49598
49599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
49600   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49601   int arg2 ;
49602
49603   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49604   arg2 = (int)jarg2;
49605   {
49606     try {
49607       (arg1)->Forward(arg2);
49608     } CALL_CATCH_EXCEPTION();
49609   }
49610
49611 }
49612
49613
49614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
49615   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49616   int arg2 ;
49617
49618   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49619   arg2 = (int)jarg2;
49620   {
49621     try {
49622       (arg1)->Backward(arg2);
49623     } CALL_CATCH_EXCEPTION();
49624   }
49625
49626 }
49627
49628
49629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
49630   void * jresult ;
49631   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49632   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
49633
49634   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49635   {
49636     try {
49637       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
49638     } CALL_CATCH_EXCEPTION(0);
49639   }
49640
49641   jresult = (void *)result;
49642   return jresult;
49643 }
49644
49645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1)
49646 {
49647   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
49648   if( arg1 == nullptr )
49649   {
49650     DALI_LOG_ERROR("VideoView is nullptr!");
49651     return nullptr;
49652   }
49653   void * ret = nullptr;
49654   {
49655     try{
49656
49657       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
49658       ret = Dali::AnyCast< void * >( result );
49659
49660     } CALL_CATCH_EXCEPTION(0);
49661   }
49662   return ret;
49663 }
49664
49665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) {
49666   void * jresult ;
49667   Dali::Toolkit::CameraView result;
49668
49669   Dali::Any arg1(jarg1);
49670   Dali::Toolkit::CameraView::DisplayType arg2 = static_cast<Dali::Toolkit::CameraView::DisplayType>(jarg2);
49671   {
49672     try {
49673       result = Dali::Toolkit::CameraView::New(arg1, arg2);
49674     } CALL_CATCH_EXCEPTION(0);
49675   }
49676
49677   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
49678   return jresult;
49679 }
49680
49681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() {
49682   void * jresult ;
49683   Dali::Toolkit::CameraView *result = 0 ;
49684
49685   {
49686     try {
49687       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView();
49688     } CALL_CATCH_EXCEPTION(0);
49689   }
49690
49691   jresult = (void *)result;
49692   return jresult;
49693 }
49694
49695
49696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) {
49697   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
49698
49699   arg1 = (Dali::Toolkit::CameraView *)jarg1;
49700   {
49701     try {
49702       delete arg1;
49703     } CALL_CATCH_EXCEPTION();
49704   }
49705
49706 }
49707
49708
49709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) {
49710   void * jresult ;
49711   Dali::Toolkit::CameraView *arg1 = 0 ;
49712   Dali::Toolkit::CameraView *result = 0 ;
49713
49714   arg1 = (Dali::Toolkit::CameraView *)jarg1;
49715   if (!arg1) {
49716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
49717     return 0;
49718   }
49719   {
49720     try {
49721       result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1);
49722     } CALL_CATCH_EXCEPTION(0);
49723   }
49724
49725   jresult = (void *)result;
49726   return jresult;
49727 }
49728
49729
49730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) {
49731   void * jresult ;
49732   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
49733   Dali::Toolkit::CameraView *arg2 = 0 ;
49734   Dali::Toolkit::CameraView *result = 0 ;
49735
49736   arg1 = (Dali::Toolkit::CameraView *)jarg1;
49737   arg2 = (Dali::Toolkit::CameraView *)jarg2;
49738   if (!arg2) {
49739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0);
49740     return 0;
49741   }
49742   {
49743     try {
49744       result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2);
49745     } CALL_CATCH_EXCEPTION(0);
49746   }
49747
49748   jresult = (void *)result;
49749   return jresult;
49750 }
49751
49752
49753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) {
49754   void * jresult ;
49755   Dali::BaseHandle arg1 ;
49756   Dali::BaseHandle *argp1 ;
49757   Dali::Toolkit::CameraView result;
49758
49759   argp1 = (Dali::BaseHandle *)jarg1;
49760   if (!argp1) {
49761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49762     return 0;
49763   }
49764   arg1 = *argp1;
49765   {
49766     try {
49767       result = Dali::Toolkit::CameraView::DownCast(arg1);
49768     } CALL_CATCH_EXCEPTION(0);
49769   }
49770
49771   jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result);
49772   return jresult;
49773 }
49774
49775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) {
49776   Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ;
49777
49778   arg1 = (Dali::Toolkit::CameraView *)jarg1;
49779   {
49780     try {
49781       (arg1)->Update();
49782     } CALL_CATCH_EXCEPTION();
49783   }
49784 }
49785
49786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2)
49787 {
49788   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1;
49789   if(arg1 == nullptr)
49790   {
49791     DALI_LOG_ERROR("VideoView is nullptr!");
49792     return;
49793   }
49794   Dali::Animation *arg2 = (Dali::Animation*)jarg2;
49795   if(arg2 == nullptr)
49796   {
49797     DALI_LOG_ERROR("Animation is nullptr!");
49798     return;
49799   }
49800
49801   {
49802     try{
49803
49804       Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2);
49805     } CALL_CATCH_EXCEPTION();
49806   }
49807
49808 }
49809
49810
49811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
49812   int jresult ;
49813   int result;
49814
49815   result = (int)Dali::Toolkit::Popup::Property::TITLE;
49816   jresult = (int)result;
49817   return jresult;
49818 }
49819
49820
49821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
49822   int jresult ;
49823   int result;
49824
49825   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
49826   jresult = (int)result;
49827   return jresult;
49828 }
49829
49830
49831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
49832   int jresult ;
49833   int result;
49834
49835   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
49836   jresult = (int)result;
49837   return jresult;
49838 }
49839
49840
49841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
49842   int jresult ;
49843   int result;
49844
49845   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
49846   jresult = (int)result;
49847   return jresult;
49848 }
49849
49850
49851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
49852   int jresult ;
49853   int result;
49854
49855   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
49856   jresult = (int)result;
49857   return jresult;
49858 }
49859
49860
49861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
49862   int jresult ;
49863   int result;
49864
49865   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
49866   jresult = (int)result;
49867   return jresult;
49868 }
49869
49870
49871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
49872   int jresult ;
49873   int result;
49874
49875   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
49876   jresult = (int)result;
49877   return jresult;
49878 }
49879
49880
49881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
49882   int jresult ;
49883   int result;
49884
49885   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
49886   jresult = (int)result;
49887   return jresult;
49888 }
49889
49890
49891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49892   int jresult ;
49893   int result;
49894
49895   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49896   jresult = (int)result;
49897   return jresult;
49898 }
49899
49900
49901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49902   int jresult ;
49903   int result;
49904
49905   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49906   jresult = (int)result;
49907   return jresult;
49908 }
49909
49910
49911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49912   int jresult ;
49913   int result;
49914
49915   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49916   jresult = (int)result;
49917   return jresult;
49918 }
49919
49920
49921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49922   int jresult ;
49923   int result;
49924
49925   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49926   jresult = (int)result;
49927   return jresult;
49928 }
49929
49930
49931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49932   int jresult ;
49933   int result;
49934
49935   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49936   jresult = (int)result;
49937   return jresult;
49938 }
49939
49940
49941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49942   int jresult ;
49943   int result;
49944
49945   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49946   jresult = (int)result;
49947   return jresult;
49948 }
49949
49950
49951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49952   int jresult ;
49953   int result;
49954
49955   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49956   jresult = (int)result;
49957   return jresult;
49958 }
49959
49960
49961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49962   int jresult ;
49963   int result;
49964
49965   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49966   jresult = (int)result;
49967   return jresult;
49968 }
49969
49970
49971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49972   int jresult ;
49973   int result;
49974
49975   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49976   jresult = (int)result;
49977   return jresult;
49978 }
49979
49980
49981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49982   int jresult ;
49983   int result;
49984
49985   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49986   jresult = (int)result;
49987   return jresult;
49988 }
49989
49990
49991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49992   int jresult ;
49993   int result;
49994
49995   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49996   jresult = (int)result;
49997   return jresult;
49998 }
49999
50000
50001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
50002   int jresult ;
50003   int result;
50004
50005   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
50006   jresult = (int)result;
50007   return jresult;
50008 }
50009
50010
50011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
50012   int jresult ;
50013   int result;
50014
50015   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
50016   jresult = (int)result;
50017   return jresult;
50018 }
50019
50020
50021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
50022   void * jresult ;
50023   Dali::Toolkit::Popup::Property *result = 0 ;
50024
50025   {
50026     try {
50027       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
50028     } CALL_CATCH_EXCEPTION(0);
50029   }
50030
50031   jresult = (void *)result;
50032   return jresult;
50033 }
50034
50035
50036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
50037   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
50038
50039   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
50040   {
50041     try {
50042       delete arg1;
50043     } CALL_CATCH_EXCEPTION();
50044   }
50045
50046 }
50047
50048
50049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
50050   void * jresult ;
50051   Dali::Toolkit::Popup *result = 0 ;
50052
50053   {
50054     try {
50055       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
50056     } CALL_CATCH_EXCEPTION(0);
50057   }
50058
50059   jresult = (void *)result;
50060   return jresult;
50061 }
50062
50063
50064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
50065   void * jresult ;
50066   Dali::Toolkit::Popup result;
50067
50068   {
50069     try {
50070       result = Dali::Toolkit::Popup::New();
50071     } CALL_CATCH_EXCEPTION(0);
50072   }
50073
50074   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
50075   return jresult;
50076 }
50077
50078
50079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
50080   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50081
50082   arg1 = (Dali::Toolkit::Popup *)jarg1;
50083   {
50084     try {
50085       delete arg1;
50086     } CALL_CATCH_EXCEPTION();
50087   }
50088
50089 }
50090
50091
50092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
50093   void * jresult ;
50094   Dali::Toolkit::Popup *arg1 = 0 ;
50095   Dali::Toolkit::Popup *result = 0 ;
50096
50097   arg1 = (Dali::Toolkit::Popup *)jarg1;
50098   if (!arg1) {
50099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
50100     return 0;
50101   }
50102   {
50103     try {
50104       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
50105     } CALL_CATCH_EXCEPTION(0);
50106   }
50107
50108   jresult = (void *)result;
50109   return jresult;
50110 }
50111
50112
50113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
50114   void * jresult ;
50115   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50116   Dali::Toolkit::Popup *arg2 = 0 ;
50117   Dali::Toolkit::Popup *result = 0 ;
50118
50119   arg1 = (Dali::Toolkit::Popup *)jarg1;
50120   arg2 = (Dali::Toolkit::Popup *)jarg2;
50121   if (!arg2) {
50122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
50123     return 0;
50124   }
50125   {
50126     try {
50127       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
50128     } CALL_CATCH_EXCEPTION(0);
50129   }
50130
50131   jresult = (void *)result;
50132   return jresult;
50133 }
50134
50135
50136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
50137   void * jresult ;
50138   Dali::BaseHandle arg1 ;
50139   Dali::BaseHandle *argp1 ;
50140   Dali::Toolkit::Popup result;
50141
50142   argp1 = (Dali::BaseHandle *)jarg1;
50143   if (!argp1) {
50144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50145     return 0;
50146   }
50147   arg1 = *argp1;
50148   {
50149     try {
50150       result = Dali::Toolkit::Popup::DownCast(arg1);
50151     } CALL_CATCH_EXCEPTION(0);
50152   }
50153
50154   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
50155   return jresult;
50156 }
50157
50158
50159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
50160   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50161   Dali::Actor arg2 ;
50162   Dali::Actor *argp2 ;
50163
50164   arg1 = (Dali::Toolkit::Popup *)jarg1;
50165   argp2 = (Dali::Actor *)jarg2;
50166   if (!argp2) {
50167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50168     return ;
50169   }
50170   arg2 = *argp2;
50171   {
50172     try {
50173       (arg1)->SetTitle(arg2);
50174     } CALL_CATCH_EXCEPTION();
50175   }
50176
50177 }
50178
50179
50180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
50181   void * jresult ;
50182   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50183   Dali::Actor result;
50184
50185   arg1 = (Dali::Toolkit::Popup *)jarg1;
50186   {
50187     try {
50188       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
50189     } CALL_CATCH_EXCEPTION(0);
50190   }
50191
50192   jresult = new Dali::Actor((const Dali::Actor &)result);
50193   return jresult;
50194 }
50195
50196
50197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
50198   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50199   Dali::Actor arg2 ;
50200   Dali::Actor *argp2 ;
50201
50202   arg1 = (Dali::Toolkit::Popup *)jarg1;
50203   argp2 = (Dali::Actor *)jarg2;
50204   if (!argp2) {
50205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50206     return ;
50207   }
50208   arg2 = *argp2;
50209   {
50210     try {
50211       (arg1)->SetContent(arg2);
50212     } CALL_CATCH_EXCEPTION();
50213   }
50214
50215 }
50216
50217
50218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
50219   void * jresult ;
50220   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50221   Dali::Actor result;
50222
50223   arg1 = (Dali::Toolkit::Popup *)jarg1;
50224   {
50225     try {
50226       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
50227     } CALL_CATCH_EXCEPTION(0);
50228   }
50229
50230   jresult = new Dali::Actor((const Dali::Actor &)result);
50231   return jresult;
50232 }
50233
50234
50235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
50236   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50237   Dali::Actor arg2 ;
50238   Dali::Actor *argp2 ;
50239
50240   arg1 = (Dali::Toolkit::Popup *)jarg1;
50241   argp2 = (Dali::Actor *)jarg2;
50242   if (!argp2) {
50243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50244     return ;
50245   }
50246   arg2 = *argp2;
50247   {
50248     try {
50249       (arg1)->SetFooter(arg2);
50250     } CALL_CATCH_EXCEPTION();
50251   }
50252
50253 }
50254
50255
50256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
50257   void * jresult ;
50258   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50259   Dali::Actor result;
50260
50261   arg1 = (Dali::Toolkit::Popup *)jarg1;
50262   {
50263     try {
50264       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
50265     } CALL_CATCH_EXCEPTION(0);
50266   }
50267
50268   jresult = new Dali::Actor((const Dali::Actor &)result);
50269   return jresult;
50270 }
50271
50272
50273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
50274   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50275   Dali::Toolkit::Popup::DisplayState arg2 ;
50276
50277   arg1 = (Dali::Toolkit::Popup *)jarg1;
50278   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
50279   {
50280     try {
50281       (arg1)->SetDisplayState(arg2);
50282     } CALL_CATCH_EXCEPTION();
50283   }
50284
50285 }
50286
50287
50288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
50289   int jresult ;
50290   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50291   Dali::Toolkit::Popup::DisplayState result;
50292
50293   arg1 = (Dali::Toolkit::Popup *)jarg1;
50294   {
50295     try {
50296       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
50297     } CALL_CATCH_EXCEPTION(0);
50298   }
50299
50300   jresult = (int)result;
50301   return jresult;
50302 }
50303
50304
50305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
50306   void * jresult ;
50307   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50308   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
50309
50310   arg1 = (Dali::Toolkit::Popup *)jarg1;
50311   {
50312     try {
50313       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
50314     } CALL_CATCH_EXCEPTION(0);
50315   }
50316
50317   jresult = (void *)result;
50318   return jresult;
50319 }
50320
50321
50322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
50323   void * jresult ;
50324   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50325   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50326
50327   arg1 = (Dali::Toolkit::Popup *)jarg1;
50328   {
50329     try {
50330       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
50331     } CALL_CATCH_EXCEPTION(0);
50332   }
50333
50334   jresult = (void *)result;
50335   return jresult;
50336 }
50337
50338
50339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
50340   void * jresult ;
50341   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50342   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50343
50344   arg1 = (Dali::Toolkit::Popup *)jarg1;
50345   {
50346     try {
50347       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
50348     } CALL_CATCH_EXCEPTION(0);
50349   }
50350
50351   jresult = (void *)result;
50352   return jresult;
50353 }
50354
50355
50356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
50357   void * jresult ;
50358   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50359   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50360
50361   arg1 = (Dali::Toolkit::Popup *)jarg1;
50362   {
50363     try {
50364       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
50365     } CALL_CATCH_EXCEPTION(0);
50366   }
50367
50368   jresult = (void *)result;
50369   return jresult;
50370 }
50371
50372
50373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
50374   void * jresult ;
50375   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
50376   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
50377
50378   arg1 = (Dali::Toolkit::Popup *)jarg1;
50379   {
50380     try {
50381       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
50382     } CALL_CATCH_EXCEPTION(0);
50383   }
50384
50385   jresult = (void *)result;
50386   return jresult;
50387 }
50388
50389
50390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
50391   int jresult ;
50392   int result;
50393
50394   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
50395   jresult = (int)result;
50396   return jresult;
50397 }
50398
50399
50400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
50401   int jresult ;
50402   int result;
50403
50404   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
50405   jresult = (int)result;
50406   return jresult;
50407 }
50408
50409
50410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
50411   int jresult ;
50412   int result;
50413
50414   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
50415   jresult = (int)result;
50416   return jresult;
50417 }
50418
50419
50420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
50421   int jresult ;
50422   int result;
50423
50424   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
50425   jresult = (int)result;
50426   return jresult;
50427 }
50428
50429
50430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
50431   int jresult ;
50432   int result;
50433
50434   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
50435   jresult = (int)result;
50436   return jresult;
50437 }
50438
50439
50440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
50441   int jresult ;
50442   int result;
50443
50444   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
50445   jresult = (int)result;
50446   return jresult;
50447 }
50448
50449
50450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
50451   int jresult ;
50452   int result;
50453
50454   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
50455   jresult = (int)result;
50456   return jresult;
50457 }
50458
50459
50460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
50461   int jresult ;
50462   int result;
50463
50464   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
50465   jresult = (int)result;
50466   return jresult;
50467 }
50468
50469
50470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
50471   int jresult ;
50472   int result;
50473
50474   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
50475   jresult = (int)result;
50476   return jresult;
50477 }
50478
50479
50480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
50481   void * jresult ;
50482   Dali::Toolkit::ProgressBar::Property *result = 0 ;
50483
50484   {
50485     try {
50486       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
50487     } CALL_CATCH_EXCEPTION(0);
50488   }
50489
50490   jresult = (void *)result;
50491   return jresult;
50492 }
50493
50494
50495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
50496   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
50497
50498   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
50499   {
50500     try {
50501       delete arg1;
50502     } CALL_CATCH_EXCEPTION();
50503   }
50504
50505 }
50506
50507
50508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
50509   void * jresult ;
50510   Dali::Toolkit::ProgressBar result;
50511
50512   {
50513     try {
50514       result = Dali::Toolkit::ProgressBar::New();
50515     } CALL_CATCH_EXCEPTION(0);
50516   }
50517
50518   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
50519   return jresult;
50520 }
50521
50522
50523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
50524   void * jresult ;
50525   Dali::Toolkit::ProgressBar *result = 0 ;
50526
50527   {
50528     try {
50529       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
50530     } CALL_CATCH_EXCEPTION(0);
50531   }
50532
50533   jresult = (void *)result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
50539   void * jresult ;
50540   Dali::Toolkit::ProgressBar *arg1 = 0 ;
50541   Dali::Toolkit::ProgressBar *result = 0 ;
50542
50543   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
50544   if (!arg1) {
50545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
50546     return 0;
50547   }
50548   {
50549     try {
50550       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
50551     } CALL_CATCH_EXCEPTION(0);
50552   }
50553
50554   jresult = (void *)result;
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
50560   void * jresult ;
50561   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
50562   Dali::Toolkit::ProgressBar *arg2 = 0 ;
50563   Dali::Toolkit::ProgressBar *result = 0 ;
50564
50565   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
50566   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
50567   if (!arg2) {
50568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
50569     return 0;
50570   }
50571   {
50572     try {
50573       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
50574     } CALL_CATCH_EXCEPTION(0);
50575   }
50576
50577   jresult = (void *)result;
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
50583   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
50584
50585   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
50586   {
50587     try {
50588       delete arg1;
50589     } CALL_CATCH_EXCEPTION();
50590   }
50591
50592 }
50593
50594
50595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
50596   void * jresult ;
50597   Dali::BaseHandle arg1 ;
50598   Dali::BaseHandle *argp1 ;
50599   Dali::Toolkit::ProgressBar result;
50600
50601   argp1 = (Dali::BaseHandle *)jarg1;
50602   if (!argp1) {
50603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50604     return 0;
50605   }
50606   arg1 = *argp1;
50607   {
50608     try {
50609       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
50610     } CALL_CATCH_EXCEPTION(0);
50611   }
50612
50613   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
50614   return jresult;
50615 }
50616
50617
50618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
50619   void * jresult ;
50620   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
50621   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
50622
50623   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
50624   {
50625     try {
50626       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
50627     } CALL_CATCH_EXCEPTION(0);
50628   }
50629
50630   jresult = (void *)result;
50631   return jresult;
50632 }
50633
50634
50635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
50636   void * jresult ;
50637   Dali::Toolkit::GaussianBlurView *result = 0 ;
50638
50639   {
50640     try {
50641       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
50642     } CALL_CATCH_EXCEPTION(0);
50643   }
50644
50645   jresult = (void *)result;
50646   return jresult;
50647 }
50648
50649
50650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
50651   void * jresult ;
50652   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
50653   Dali::Toolkit::GaussianBlurView *result = 0 ;
50654
50655   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50656   if (!arg1) {
50657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
50658     return 0;
50659   }
50660   {
50661     try {
50662       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
50663     } CALL_CATCH_EXCEPTION(0);
50664   }
50665
50666   jresult = (void *)result;
50667   return jresult;
50668 }
50669
50670
50671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
50672   void * jresult ;
50673   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50674   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
50675   Dali::Toolkit::GaussianBlurView *result = 0 ;
50676
50677   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50678   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
50679   if (!arg2) {
50680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
50681     return 0;
50682   }
50683   {
50684     try {
50685       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
50686     } CALL_CATCH_EXCEPTION(0);
50687   }
50688
50689   jresult = (void *)result;
50690   return jresult;
50691 }
50692
50693
50694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
50695   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50696
50697   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50698   {
50699     try {
50700       delete arg1;
50701     } CALL_CATCH_EXCEPTION();
50702   }
50703
50704 }
50705
50706
50707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
50708   void * jresult ;
50709   Dali::BaseHandle arg1 ;
50710   Dali::BaseHandle *argp1 ;
50711   Dali::Toolkit::GaussianBlurView result;
50712
50713   argp1 = (Dali::BaseHandle *)jarg1;
50714   if (!argp1) {
50715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50716     return 0;
50717   }
50718   arg1 = *argp1;
50719   {
50720     try {
50721       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
50722     } CALL_CATCH_EXCEPTION(0);
50723   }
50724
50725   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50726   return jresult;
50727 }
50728
50729
50730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
50731   void * jresult ;
50732   Dali::Toolkit::GaussianBlurView result;
50733
50734   {
50735     try {
50736       result = Dali::Toolkit::GaussianBlurView::New();
50737     } CALL_CATCH_EXCEPTION(0);
50738   }
50739
50740   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50741   return jresult;
50742 }
50743
50744
50745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) {
50746   void * jresult ;
50747   unsigned int arg1 ;
50748   float arg2 ;
50749   Dali::Pixel::Format arg3 ;
50750   float arg4 ;
50751   float arg5 ;
50752   bool arg6 ;
50753   Dali::Toolkit::GaussianBlurView result;
50754
50755   arg1 = (unsigned int)jarg1;
50756   arg2 = (float)jarg2;
50757   arg3 = (Dali::Pixel::Format)jarg3;
50758   arg4 = (float)jarg4;
50759   arg5 = (float)jarg5;
50760   arg6 = jarg6 ? true : false;
50761   {
50762     try {
50763       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
50764     } CALL_CATCH_EXCEPTION(0);
50765   }
50766
50767   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50768   return jresult;
50769 }
50770
50771
50772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
50773   void * jresult ;
50774   unsigned int arg1 ;
50775   float arg2 ;
50776   Dali::Pixel::Format arg3 ;
50777   float arg4 ;
50778   float arg5 ;
50779   Dali::Toolkit::GaussianBlurView result;
50780
50781   arg1 = (unsigned int)jarg1;
50782   arg2 = (float)jarg2;
50783   arg3 = (Dali::Pixel::Format)jarg3;
50784   arg4 = (float)jarg4;
50785   arg5 = (float)jarg5;
50786   {
50787     try {
50788       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
50789     } CALL_CATCH_EXCEPTION(0);
50790   }
50791
50792   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50793   return jresult;
50794 }
50795
50796
50797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
50798   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50799   Dali::Actor arg2 ;
50800   Dali::Actor *argp2 ;
50801
50802   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50803   argp2 = (Dali::Actor *)jarg2;
50804   if (!argp2) {
50805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50806     return ;
50807   }
50808   arg2 = *argp2;
50809   {
50810     try {
50811       (arg1)->Add(arg2);
50812     } CALL_CATCH_EXCEPTION();
50813   }
50814
50815 }
50816
50817
50818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
50819   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50820   Dali::Actor arg2 ;
50821   Dali::Actor *argp2 ;
50822
50823   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50824   argp2 = (Dali::Actor *)jarg2;
50825   if (!argp2) {
50826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50827     return ;
50828   }
50829   arg2 = *argp2;
50830   {
50831     try {
50832       (arg1)->Remove(arg2);
50833     } CALL_CATCH_EXCEPTION();
50834   }
50835
50836 }
50837
50838
50839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
50840   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50841
50842   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50843   {
50844     try {
50845       (arg1)->Activate();
50846     } CALL_CATCH_EXCEPTION();
50847   }
50848
50849 }
50850
50851
50852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
50853   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50854
50855   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50856   {
50857     try {
50858       (arg1)->ActivateOnce();
50859     } CALL_CATCH_EXCEPTION();
50860   }
50861
50862 }
50863
50864
50865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
50866   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50867
50868   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50869   {
50870     try {
50871       (arg1)->Deactivate();
50872     } CALL_CATCH_EXCEPTION();
50873   }
50874
50875 }
50876
50877
50878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
50879   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50880   Dali::Texture arg2 ;
50881   Dali::FrameBuffer arg3 ;
50882   Dali::Texture *argp2 ;
50883   Dali::FrameBuffer *argp3 ;
50884
50885   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50886   argp2 = (Dali::Texture *)jarg2;
50887   if (!argp2) {
50888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
50889     return ;
50890   }
50891   arg2 = *argp2;
50892   argp3 = (Dali::FrameBuffer *)jarg3;
50893   if (!argp3) {
50894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50895     return ;
50896   }
50897   arg3 = *argp3;
50898   {
50899     try {
50900       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50901     } CALL_CATCH_EXCEPTION();
50902   }
50903
50904 }
50905
50906
50907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50908   int jresult ;
50909   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50910   Dali::Property::Index result;
50911
50912   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50913   {
50914     try {
50915       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50916     } CALL_CATCH_EXCEPTION(0);
50917   }
50918
50919   jresult = result;
50920   return jresult;
50921 }
50922
50923
50924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50925   void * jresult ;
50926   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50927   Dali::FrameBuffer result;
50928
50929   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50930   {
50931     try {
50932       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50933     } CALL_CATCH_EXCEPTION(0);
50934   }
50935
50936   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50937   return jresult;
50938 }
50939
50940
50941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50942   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50943   Dali::Vector4 *arg2 = 0 ;
50944
50945   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50946   arg2 = (Dali::Vector4 *)jarg2;
50947   if (!arg2) {
50948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50949     return ;
50950   }
50951   {
50952     try {
50953       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50954     } CALL_CATCH_EXCEPTION();
50955   }
50956
50957 }
50958
50959
50960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50961   void * jresult ;
50962   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50963   Dali::Vector4 result;
50964
50965   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50966   {
50967     try {
50968       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50969     } CALL_CATCH_EXCEPTION(0);
50970   }
50971
50972   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50973   return jresult;
50974 }
50975
50976
50977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50978   void * jresult ;
50979   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50980   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50981
50982   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50983   {
50984     try {
50985       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50986     } CALL_CATCH_EXCEPTION(0);
50987   }
50988
50989   jresult = (void *)result;
50990   return jresult;
50991 }
50992
50993
50994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50995   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50996
50997   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50998   {
50999     try {
51000       delete arg1;
51001     } CALL_CATCH_EXCEPTION();
51002   }
51003
51004 }
51005
51006
51007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
51008   unsigned int jresult ;
51009   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51010   unsigned int result;
51011
51012   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51013   {
51014     try {
51015       result = (unsigned int)(arg1)->GetNumberOfPages();
51016     } CALL_CATCH_EXCEPTION(0);
51017   }
51018
51019   jresult = result;
51020   return jresult;
51021 }
51022
51023
51024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
51025   void * jresult ;
51026   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
51027   unsigned int arg2 ;
51028   Dali::Texture result;
51029
51030   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51031   arg2 = (unsigned int)jarg2;
51032   {
51033     try {
51034       result = (arg1)->NewPage(arg2);
51035     } CALL_CATCH_EXCEPTION(0);
51036   }
51037
51038   jresult = new Dali::Texture((const Dali::Texture &)result);
51039   return jresult;
51040 }
51041
51042
51043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
51044   int jresult ;
51045   int result;
51046
51047   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
51048   jresult = (int)result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
51054   int jresult ;
51055   int result;
51056
51057   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
51058   jresult = (int)result;
51059   return jresult;
51060 }
51061
51062
51063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
51064   int jresult ;
51065   int result;
51066
51067   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
51068   jresult = (int)result;
51069   return jresult;
51070 }
51071
51072
51073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
51074   void * jresult ;
51075   Dali::Toolkit::PageTurnView::Property *result = 0 ;
51076
51077   {
51078     try {
51079       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
51080     } CALL_CATCH_EXCEPTION(0);
51081   }
51082
51083   jresult = (void *)result;
51084   return jresult;
51085 }
51086
51087
51088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
51089   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
51090
51091   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
51092   {
51093     try {
51094       delete arg1;
51095     } CALL_CATCH_EXCEPTION();
51096   }
51097
51098 }
51099
51100
51101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
51102   void * jresult ;
51103   Dali::Toolkit::PageTurnView *result = 0 ;
51104
51105   {
51106     try {
51107       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
51108     } CALL_CATCH_EXCEPTION(0);
51109   }
51110
51111   jresult = (void *)result;
51112   return jresult;
51113 }
51114
51115
51116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
51117   void * jresult ;
51118   Dali::Toolkit::PageTurnView *arg1 = 0 ;
51119   Dali::Toolkit::PageTurnView *result = 0 ;
51120
51121   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51122   if (!arg1) {
51123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
51124     return 0;
51125   }
51126   {
51127     try {
51128       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
51129     } CALL_CATCH_EXCEPTION(0);
51130   }
51131
51132   jresult = (void *)result;
51133   return jresult;
51134 }
51135
51136
51137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
51138   void * jresult ;
51139   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51140   Dali::Toolkit::PageTurnView *arg2 = 0 ;
51141   Dali::Toolkit::PageTurnView *result = 0 ;
51142
51143   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51144   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
51145   if (!arg2) {
51146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
51147     return 0;
51148   }
51149   {
51150     try {
51151       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
51152     } CALL_CATCH_EXCEPTION(0);
51153   }
51154
51155   jresult = (void *)result;
51156   return jresult;
51157 }
51158
51159
51160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
51161   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51162
51163   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51164   {
51165     try {
51166       delete arg1;
51167     } CALL_CATCH_EXCEPTION();
51168   }
51169
51170 }
51171
51172
51173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
51174   void * jresult ;
51175   Dali::BaseHandle arg1 ;
51176   Dali::BaseHandle *argp1 ;
51177   Dali::Toolkit::PageTurnView result;
51178
51179   argp1 = (Dali::BaseHandle *)jarg1;
51180   if (!argp1) {
51181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51182     return 0;
51183   }
51184   arg1 = *argp1;
51185   {
51186     try {
51187       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
51188     } CALL_CATCH_EXCEPTION(0);
51189   }
51190
51191   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
51192   return jresult;
51193 }
51194
51195
51196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
51197   void * jresult ;
51198   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51199   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
51200
51201   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51202   {
51203     try {
51204       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
51205     } CALL_CATCH_EXCEPTION(0);
51206   }
51207
51208   jresult = (void *)result;
51209   return jresult;
51210 }
51211
51212
51213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
51214   void * jresult ;
51215   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51216   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
51217
51218   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51219   {
51220     try {
51221       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
51222     } CALL_CATCH_EXCEPTION(0);
51223   }
51224
51225   jresult = (void *)result;
51226   return jresult;
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
51231   void * jresult ;
51232   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51233   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
51234
51235   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51236   {
51237     try {
51238       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
51239     } CALL_CATCH_EXCEPTION(0);
51240   }
51241
51242   jresult = (void *)result;
51243   return jresult;
51244 }
51245
51246
51247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
51248   void * jresult ;
51249   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
51250   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
51251
51252   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
51253   {
51254     try {
51255       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
51256     } CALL_CATCH_EXCEPTION(0);
51257   }
51258
51259   jresult = (void *)result;
51260   return jresult;
51261 }
51262
51263
51264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
51265   void * jresult ;
51266   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51267
51268   {
51269     try {
51270       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
51271     } CALL_CATCH_EXCEPTION(0);
51272   }
51273
51274   jresult = (void *)result;
51275   return jresult;
51276 }
51277
51278
51279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
51280   void * jresult ;
51281   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
51282   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51283
51284   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51285   if (!arg1) {
51286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
51287     return 0;
51288   }
51289   {
51290     try {
51291       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
51292     } CALL_CATCH_EXCEPTION(0);
51293   }
51294
51295   jresult = (void *)result;
51296   return jresult;
51297 }
51298
51299
51300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
51301   void * jresult ;
51302   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
51303   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
51304   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
51305
51306   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51307   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
51308   if (!arg2) {
51309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
51310     return 0;
51311   }
51312   {
51313     try {
51314       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
51315     } CALL_CATCH_EXCEPTION(0);
51316   }
51317
51318   jresult = (void *)result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
51324   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
51325
51326   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
51327   {
51328     try {
51329       delete arg1;
51330     } CALL_CATCH_EXCEPTION();
51331   }
51332
51333 }
51334
51335
51336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
51337   void * jresult ;
51338   Dali::Toolkit::PageFactory *arg1 = 0 ;
51339   Dali::Vector2 *arg2 = 0 ;
51340   Dali::Toolkit::PageTurnLandscapeView result;
51341
51342   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51343   if (!arg1) {
51344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
51345     return 0;
51346   }
51347   arg2 = (Dali::Vector2 *)jarg2;
51348   if (!arg2) {
51349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
51350     return 0;
51351   }
51352   {
51353     try {
51354       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
51355     } CALL_CATCH_EXCEPTION(0);
51356   }
51357
51358   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
51359   return jresult;
51360 }
51361
51362
51363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
51364   void * jresult ;
51365   Dali::BaseHandle arg1 ;
51366   Dali::BaseHandle *argp1 ;
51367   Dali::Toolkit::PageTurnLandscapeView result;
51368
51369   argp1 = (Dali::BaseHandle *)jarg1;
51370   if (!argp1) {
51371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51372     return 0;
51373   }
51374   arg1 = *argp1;
51375   {
51376     try {
51377       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
51378     } CALL_CATCH_EXCEPTION(0);
51379   }
51380
51381   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
51382   return jresult;
51383 }
51384
51385
51386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
51387   void * jresult ;
51388   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51389
51390   {
51391     try {
51392       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
51393     } CALL_CATCH_EXCEPTION(0);
51394   }
51395
51396   jresult = (void *)result;
51397   return jresult;
51398 }
51399
51400
51401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
51402   void * jresult ;
51403   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
51404   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51405
51406   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51407   if (!arg1) {
51408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
51409     return 0;
51410   }
51411   {
51412     try {
51413       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
51414     } CALL_CATCH_EXCEPTION(0);
51415   }
51416
51417   jresult = (void *)result;
51418   return jresult;
51419 }
51420
51421
51422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
51423   void * jresult ;
51424   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
51425   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
51426   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
51427
51428   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51429   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
51430   if (!arg2) {
51431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
51432     return 0;
51433   }
51434   {
51435     try {
51436       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
51437     } CALL_CATCH_EXCEPTION(0);
51438   }
51439
51440   jresult = (void *)result;
51441   return jresult;
51442 }
51443
51444
51445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
51446   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
51447
51448   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
51449   {
51450     try {
51451       delete arg1;
51452     } CALL_CATCH_EXCEPTION();
51453   }
51454
51455 }
51456
51457
51458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
51459   void * jresult ;
51460   Dali::Toolkit::PageFactory *arg1 = 0 ;
51461   Dali::Vector2 *arg2 = 0 ;
51462   Dali::Toolkit::PageTurnPortraitView result;
51463
51464   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
51465   if (!arg1) {
51466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
51467     return 0;
51468   }
51469   arg2 = (Dali::Vector2 *)jarg2;
51470   if (!arg2) {
51471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
51472     return 0;
51473   }
51474   {
51475     try {
51476       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
51477     } CALL_CATCH_EXCEPTION(0);
51478   }
51479
51480   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
51481   return jresult;
51482 }
51483
51484
51485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
51486   void * jresult ;
51487   Dali::BaseHandle arg1 ;
51488   Dali::BaseHandle *argp1 ;
51489   Dali::Toolkit::PageTurnPortraitView result;
51490
51491   argp1 = (Dali::BaseHandle *)jarg1;
51492   if (!argp1) {
51493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51494     return 0;
51495   }
51496   arg1 = *argp1;
51497   {
51498     try {
51499       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
51500     } CALL_CATCH_EXCEPTION(0);
51501   }
51502
51503   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
51504   return jresult;
51505 }
51506
51507
51508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
51509   int jresult ;
51510   int result;
51511
51512   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
51513   jresult = (int)result;
51514   return jresult;
51515 }
51516
51517
51518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
51519   int jresult ;
51520   int result;
51521
51522   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
51523   jresult = (int)result;
51524   return jresult;
51525 }
51526
51527
51528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
51529   int jresult ;
51530   int result;
51531
51532   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
51533   jresult = (int)result;
51534   return jresult;
51535 }
51536
51537
51538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
51539   void * jresult ;
51540   Dali::Toolkit::ToggleButton::Property *result = 0 ;
51541
51542   {
51543     try {
51544       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
51545     } CALL_CATCH_EXCEPTION(0);
51546   }
51547
51548   jresult = (void *)result;
51549   return jresult;
51550 }
51551
51552
51553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
51554   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
51555
51556   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
51557   {
51558     try {
51559       delete arg1;
51560     } CALL_CATCH_EXCEPTION();
51561   }
51562
51563 }
51564
51565
51566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
51567   void * jresult ;
51568   Dali::Toolkit::ToggleButton *result = 0 ;
51569
51570   {
51571     try {
51572       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
51573     } CALL_CATCH_EXCEPTION(0);
51574   }
51575
51576   jresult = (void *)result;
51577   return jresult;
51578 }
51579
51580
51581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
51582   void * jresult ;
51583   Dali::Toolkit::ToggleButton *arg1 = 0 ;
51584   Dali::Toolkit::ToggleButton *result = 0 ;
51585
51586   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
51587   if (!arg1) {
51588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
51589     return 0;
51590   }
51591   {
51592     try {
51593       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
51594     } CALL_CATCH_EXCEPTION(0);
51595   }
51596
51597   jresult = (void *)result;
51598   return jresult;
51599 }
51600
51601
51602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
51603   void * jresult ;
51604   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
51605   Dali::Toolkit::ToggleButton *arg2 = 0 ;
51606   Dali::Toolkit::ToggleButton *result = 0 ;
51607
51608   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
51609   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
51610   if (!arg2) {
51611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
51612     return 0;
51613   }
51614   {
51615     try {
51616       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
51617     } CALL_CATCH_EXCEPTION(0);
51618   }
51619
51620   jresult = (void *)result;
51621   return jresult;
51622 }
51623
51624
51625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
51626   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
51627
51628   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
51629   {
51630     try {
51631       delete arg1;
51632     } CALL_CATCH_EXCEPTION();
51633   }
51634
51635 }
51636
51637
51638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
51639   void * jresult ;
51640   Dali::Toolkit::ToggleButton result;
51641
51642   {
51643     try {
51644       result = Dali::Toolkit::ToggleButton::New();
51645     } CALL_CATCH_EXCEPTION(0);
51646   }
51647
51648   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
51649   return jresult;
51650 }
51651
51652
51653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
51654   void * jresult ;
51655   Dali::BaseHandle arg1 ;
51656   Dali::BaseHandle *argp1 ;
51657   Dali::Toolkit::ToggleButton result;
51658
51659   argp1 = (Dali::BaseHandle *)jarg1;
51660   if (!argp1) {
51661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51662     return 0;
51663   }
51664   arg1 = *argp1;
51665   {
51666     try {
51667       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
51668     } CALL_CATCH_EXCEPTION(0);
51669   }
51670
51671   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
51672   return jresult;
51673 }
51674
51675
51676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
51677   void * jresult ;
51678   Dali::Toolkit::Visual::Base *result = 0 ;
51679
51680   {
51681     try {
51682       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
51683     } CALL_CATCH_EXCEPTION(0);
51684   }
51685
51686   jresult = (void *)result;
51687   return jresult;
51688 }
51689
51690
51691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
51692   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51693
51694   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51695   {
51696     try {
51697       delete arg1;
51698     } CALL_CATCH_EXCEPTION();
51699   }
51700
51701 }
51702
51703
51704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
51705   void * jresult ;
51706   Dali::Toolkit::Visual::Base *arg1 = 0 ;
51707   Dali::Toolkit::Visual::Base *result = 0 ;
51708
51709   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51710   if (!arg1) {
51711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51712     return 0;
51713   }
51714   {
51715     try {
51716       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
51717     } CALL_CATCH_EXCEPTION(0);
51718   }
51719
51720   jresult = (void *)result;
51721   return jresult;
51722 }
51723
51724
51725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
51726   void * jresult ;
51727   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51728   Dali::Toolkit::Visual::Base *arg2 = 0 ;
51729   Dali::Toolkit::Visual::Base *result = 0 ;
51730
51731   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51732   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
51733   if (!arg2) {
51734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51735     return 0;
51736   }
51737   {
51738     try {
51739       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
51740     } CALL_CATCH_EXCEPTION(0);
51741   }
51742
51743   jresult = (void *)result;
51744   return jresult;
51745 }
51746
51747
51748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
51749   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51750   std::string *arg2 = 0 ;
51751
51752   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51753   if (!jarg2) {
51754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51755     return ;
51756   }
51757   std::string arg2_str(jarg2);
51758   arg2 = &arg2_str;
51759   {
51760     try {
51761       (arg1)->SetName((std::string const &)*arg2);
51762     } CALL_CATCH_EXCEPTION();
51763   }
51764
51765
51766   //argout typemap for const std::string&
51767
51768 }
51769
51770
51771 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
51772   char * jresult ;
51773   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51774   std::string *result = 0 ;
51775
51776   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51777   {
51778     try {
51779       result = (std::string *) &(arg1)->GetName();
51780     } CALL_CATCH_EXCEPTION(0);
51781   }
51782
51783   jresult = SWIG_csharp_string_callback(result->c_str());
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
51789   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51790   Dali::Property::Map *arg2 = 0 ;
51791   Dali::Size arg3 ;
51792   Dali::Size *argp3 ;
51793
51794   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51795   arg2 = (Dali::Property::Map *)jarg2;
51796   if (!arg2) {
51797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51798     return ;
51799   }
51800   argp3 = (Dali::Size *)jarg3;
51801   if (!argp3) {
51802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
51803     return ;
51804   }
51805   arg3 = *argp3;
51806   {
51807     try {
51808       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
51809     } CALL_CATCH_EXCEPTION();
51810   }
51811
51812 }
51813
51814
51815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
51816   float jresult ;
51817   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51818   float arg2 ;
51819   float result;
51820
51821   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51822   arg2 = (float)jarg2;
51823   {
51824     try {
51825       result = (float)(arg1)->GetHeightForWidth(arg2);
51826     } CALL_CATCH_EXCEPTION(0);
51827   }
51828
51829   jresult = result;
51830   return jresult;
51831 }
51832
51833
51834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
51835   float jresult ;
51836   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51837   float arg2 ;
51838   float result;
51839
51840   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51841   arg2 = (float)jarg2;
51842   {
51843     try {
51844       result = (float)(arg1)->GetWidthForHeight(arg2);
51845     } CALL_CATCH_EXCEPTION(0);
51846   }
51847
51848   jresult = result;
51849   return jresult;
51850 }
51851
51852
51853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
51854   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51855   Dali::Vector2 *arg2 = 0 ;
51856
51857   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51858   arg2 = (Dali::Vector2 *)jarg2;
51859   if (!arg2) {
51860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
51861     return ;
51862   }
51863   {
51864     try {
51865       (arg1)->GetNaturalSize(*arg2);
51866     } CALL_CATCH_EXCEPTION();
51867   }
51868
51869 }
51870
51871
51872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
51873   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51874   float arg2 ;
51875
51876   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51877   arg2 = (int)jarg2;
51878   {
51879     try {
51880       (arg1)->SetDepthIndex(arg2);
51881     } CALL_CATCH_EXCEPTION();
51882   }
51883
51884 }
51885
51886
51887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
51888   int jresult ;
51889   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51890   int result;
51891
51892   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51893   {
51894     try {
51895       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51896     } CALL_CATCH_EXCEPTION(0);
51897   }
51898
51899   jresult = result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51905   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51906   Dali::Property::Map *arg2 = 0 ;
51907
51908   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51909   arg2 = (Dali::Property::Map *)jarg2;
51910   if (!arg2) {
51911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51912     return ;
51913   }
51914   {
51915     try {
51916       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51917     } CALL_CATCH_EXCEPTION();
51918   }
51919
51920 }
51921
51922
51923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51924   void * jresult ;
51925   Dali::Toolkit::VisualFactory result;
51926
51927   {
51928     try {
51929       result = Dali::Toolkit::VisualFactory::Get();
51930     } CALL_CATCH_EXCEPTION(0);
51931   }
51932
51933   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51934   return jresult;
51935 }
51936
51937
51938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51939   void * jresult ;
51940   Dali::Toolkit::VisualFactory *result = 0 ;
51941
51942   {
51943     try {
51944       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51945     } CALL_CATCH_EXCEPTION(0);
51946   }
51947
51948   jresult = (void *)result;
51949   return jresult;
51950 }
51951
51952
51953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51954   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51955
51956   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51957   {
51958     try {
51959       delete arg1;
51960     } CALL_CATCH_EXCEPTION();
51961   }
51962
51963 }
51964
51965
51966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51967   void * jresult ;
51968   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51969   Dali::Toolkit::VisualFactory *result = 0 ;
51970
51971   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51972   if (!arg1) {
51973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51974     return 0;
51975   }
51976   {
51977     try {
51978       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51979     } CALL_CATCH_EXCEPTION(0);
51980   }
51981
51982   jresult = (void *)result;
51983   return jresult;
51984 }
51985
51986
51987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51988   void * jresult ;
51989   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51990   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51991   Dali::Toolkit::VisualFactory *result = 0 ;
51992
51993   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51994   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51995   if (!arg2) {
51996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51997     return 0;
51998   }
51999   {
52000     try {
52001       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
52002     } CALL_CATCH_EXCEPTION(0);
52003   }
52004
52005   jresult = (void *)result;
52006   return jresult;
52007 }
52008
52009
52010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
52011   void * jresult ;
52012   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52013   Dali::Property::Map *arg2 = 0 ;
52014   Dali::Toolkit::Visual::Base result;
52015
52016   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52017   arg2 = (Dali::Property::Map *)jarg2;
52018   if (!arg2) {
52019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
52020     return 0;
52021   }
52022   {
52023     try {
52024       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
52025     } CALL_CATCH_EXCEPTION(0);
52026   }
52027
52028   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
52029   return jresult;
52030 }
52031
52032
52033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
52034   void * jresult ;
52035   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
52036   std::string *arg2 = 0 ;
52037   Dali::ImageDimensions arg3 ;
52038   Dali::ImageDimensions *argp3 ;
52039   Dali::Toolkit::Visual::Base result;
52040
52041   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
52042   if (!jarg2) {
52043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52044     return 0;
52045   }
52046   std::string arg2_str(jarg2);
52047   arg2 = &arg2_str;
52048   argp3 = (Dali::ImageDimensions *)jarg3;
52049   if (!argp3) {
52050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52051     return 0;
52052   }
52053   arg3 = *argp3;
52054   {
52055     try {
52056       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
52057     } CALL_CATCH_EXCEPTION(0);
52058   }
52059
52060   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
52061
52062   //argout typemap for const std::string&
52063
52064   return jresult;
52065 }
52066
52067
52068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
52069   void * jresult ;
52070   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52071
52072   {
52073     try {
52074       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
52075     } CALL_CATCH_EXCEPTION(0);
52076   }
52077
52078   jresult = (void *)result;
52079   return jresult;
52080 }
52081
52082
52083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
52084   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52085
52086   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52087   {
52088     try {
52089       delete arg1;
52090     } CALL_CATCH_EXCEPTION();
52091   }
52092
52093 }
52094
52095
52096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
52097   void * jresult ;
52098   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
52099   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52100
52101   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52102   if (!arg1) {
52103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
52104     return 0;
52105   }
52106   {
52107     try {
52108       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
52109     } CALL_CATCH_EXCEPTION(0);
52110   }
52111
52112   jresult = (void *)result;
52113   return jresult;
52114 }
52115
52116
52117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
52118   void * jresult ;
52119   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52120   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
52121   Dali::Toolkit::AsyncImageLoader *result = 0 ;
52122
52123   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52124   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
52125   if (!arg2) {
52126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
52127     return 0;
52128   }
52129   {
52130     try {
52131       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
52132     } CALL_CATCH_EXCEPTION(0);
52133   }
52134
52135   jresult = (void *)result;
52136   return jresult;
52137 }
52138
52139
52140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
52141   void * jresult ;
52142   Dali::Toolkit::AsyncImageLoader result;
52143
52144   {
52145     try {
52146       result = Dali::Toolkit::AsyncImageLoader::New();
52147     } CALL_CATCH_EXCEPTION(0);
52148   }
52149
52150   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
52151   return jresult;
52152 }
52153
52154
52155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
52156   void * jresult ;
52157   Dali::BaseHandle arg1 ;
52158   Dali::BaseHandle *argp1 ;
52159   Dali::Toolkit::AsyncImageLoader result;
52160
52161   argp1 = (Dali::BaseHandle *)jarg1;
52162   if (!argp1) {
52163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52164     return 0;
52165   }
52166   arg1 = *argp1;
52167   {
52168     try {
52169       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
52170     } CALL_CATCH_EXCEPTION(0);
52171   }
52172
52173   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
52174   return jresult;
52175 }
52176
52177
52178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
52179   unsigned int jresult ;
52180   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52181   std::string *arg2 = 0 ;
52182   uint32_t result;
52183
52184   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52185   if (!jarg2) {
52186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52187     return 0;
52188   }
52189   std::string arg2_str(jarg2);
52190   arg2 = &arg2_str;
52191   {
52192     try {
52193       result = (arg1)->Load((std::string const &)*arg2);
52194     } CALL_CATCH_EXCEPTION(0);
52195   }
52196
52197   jresult = result;
52198
52199   //argout typemap for const std::string&
52200
52201   return jresult;
52202 }
52203
52204
52205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
52206   unsigned int jresult ;
52207   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52208   std::string *arg2 = 0 ;
52209   Dali::ImageDimensions arg3 ;
52210   Dali::ImageDimensions *argp3 ;
52211   uint32_t result;
52212
52213   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52214   if (!jarg2) {
52215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52216     return 0;
52217   }
52218   std::string arg2_str(jarg2);
52219   arg2 = &arg2_str;
52220   argp3 = (Dali::ImageDimensions *)jarg3;
52221   if (!argp3) {
52222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52223     return 0;
52224   }
52225   arg3 = *argp3;
52226   {
52227     try {
52228       result = (arg1)->Load((std::string const &)*arg2,arg3);
52229     } CALL_CATCH_EXCEPTION(0);
52230   }
52231
52232   jresult = result;
52233
52234   //argout typemap for const std::string&
52235
52236   return jresult;
52237 }
52238
52239
52240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) {
52241   unsigned int jresult ;
52242   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52243   std::string *arg2 = 0 ;
52244   Dali::ImageDimensions arg3 ;
52245   Dali::FittingMode::Type arg4 ;
52246   Dali::SamplingMode::Type arg5 ;
52247   bool arg6 ;
52248   Dali::ImageDimensions *argp3 ;
52249   uint32_t result;
52250
52251   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52252   if (!jarg2) {
52253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52254     return 0;
52255   }
52256   std::string arg2_str(jarg2);
52257   arg2 = &arg2_str;
52258   argp3 = (Dali::ImageDimensions *)jarg3;
52259   if (!argp3) {
52260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52261     return 0;
52262   }
52263   arg3 = *argp3;
52264   arg4 = (Dali::FittingMode::Type)jarg4;
52265   arg5 = (Dali::SamplingMode::Type)jarg5;
52266   arg6 = jarg6 ? true : false;
52267   {
52268     try {
52269       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
52270     } CALL_CATCH_EXCEPTION(0);
52271   }
52272
52273   jresult = result;
52274
52275   //argout typemap for const std::string&
52276
52277   return jresult;
52278 }
52279
52280
52281 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
52282   bool jresult ;
52283   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52284   uint32_t arg2 ;
52285   bool result;
52286
52287   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52288   arg2 = (uint32_t)jarg2;
52289   {
52290     try {
52291       result = (bool)(arg1)->Cancel(arg2);
52292     } CALL_CATCH_EXCEPTION(0);
52293   }
52294
52295   jresult = result;
52296   return jresult;
52297 }
52298
52299
52300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
52301   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52302
52303   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52304   {
52305     try {
52306       (arg1)->CancelAll();
52307     } CALL_CATCH_EXCEPTION();
52308   }
52309
52310 }
52311
52312
52313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
52314   void * jresult ;
52315   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
52316   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
52317
52318   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
52319   {
52320     try {
52321       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
52322     } CALL_CATCH_EXCEPTION(0);
52323   }
52324
52325   jresult = (void *)result;
52326   return jresult;
52327 }
52328
52329
52330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
52331   void * jresult ;
52332   std::string *arg1 = 0 ;
52333   Dali::PixelData result;
52334
52335   if (!jarg1) {
52336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52337     return 0;
52338   }
52339   std::string arg1_str(jarg1);
52340   arg1 = &arg1_str;
52341   {
52342     try {
52343       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
52344     } CALL_CATCH_EXCEPTION(0);
52345   }
52346
52347   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52348
52349   //argout typemap for const std::string&
52350
52351   return jresult;
52352 }
52353
52354
52355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
52356   void * jresult ;
52357   std::string *arg1 = 0 ;
52358   Dali::ImageDimensions arg2 ;
52359   Dali::ImageDimensions *argp2 ;
52360   Dali::PixelData result;
52361
52362   if (!jarg1) {
52363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52364     return 0;
52365   }
52366   std::string arg1_str(jarg1);
52367   arg1 = &arg1_str;
52368   argp2 = (Dali::ImageDimensions *)jarg2;
52369   if (!argp2) {
52370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52371     return 0;
52372   }
52373   arg2 = *argp2;
52374   {
52375     try {
52376       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
52377     } CALL_CATCH_EXCEPTION(0);
52378   }
52379
52380   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52381
52382   //argout typemap for const std::string&
52383
52384   return jresult;
52385 }
52386
52387
52388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
52389   void * jresult ;
52390   std::string *arg1 = 0 ;
52391   Dali::ImageDimensions arg2 ;
52392   Dali::FittingMode::Type arg3 ;
52393   Dali::SamplingMode::Type arg4 ;
52394   bool arg5 ;
52395   Dali::ImageDimensions *argp2 ;
52396   Dali::PixelData result;
52397
52398   if (!jarg1) {
52399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52400     return 0;
52401   }
52402   std::string arg1_str(jarg1);
52403   arg1 = &arg1_str;
52404   argp2 = (Dali::ImageDimensions *)jarg2;
52405   if (!argp2) {
52406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
52407     return 0;
52408   }
52409   arg2 = *argp2;
52410   arg3 = (Dali::FittingMode::Type)jarg3;
52411   arg4 = (Dali::SamplingMode::Type)jarg4;
52412   arg5 = jarg5 ? true : false;
52413   {
52414     try {
52415       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
52416     } CALL_CATCH_EXCEPTION(0);
52417   }
52418
52419   jresult = new Dali::PixelData((const Dali::PixelData &)result);
52420
52421   //argout typemap for const std::string&
52422
52423   return jresult;
52424 }
52425
52426
52427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
52428   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
52429
52430   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
52431   {
52432     try {
52433       delete arg1;
52434     } CALL_CATCH_EXCEPTION();
52435   }
52436
52437 }
52438
52439
52440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) {
52441   void * jresult ;
52442   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
52443   Dali::Actor arg2 ;
52444   Dali::Actor arg3 ;
52445   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
52446   std::string *arg5 = 0 ;
52447   Dali::Actor *argp2 ;
52448   Dali::Actor *argp3 ;
52449   Dali::Actor result;
52450
52451   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface;
52452   argp2 = (Dali::Actor *)currentFocusedActor;
52453   if (!argp2) {
52454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52455     return 0;
52456   }
52457   arg2 = *argp2;
52458   argp3 = (Dali::Actor *)proposedActorToFocus;
52459   if (!argp3) {
52460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52461     return 0;
52462   }
52463   arg3 = *argp3;
52464   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction;
52465
52466   std::string arg5_str(deviceName);
52467   arg5 = &arg5_str;
52468
52469   {
52470     try {
52471       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5);
52472     } CALL_CATCH_EXCEPTION(0);
52473   }
52474
52475   jresult = new Dali::Actor((const Dali::Actor &)result);
52476   return jresult;
52477 }
52478
52479
52480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
52481   void * jresult ;
52482   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
52483
52484   {
52485     try {
52486       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
52487     } CALL_CATCH_EXCEPTION(0);
52488   }
52489
52490   jresult = (void *)result;
52491   return jresult;
52492 }
52493
52494
52495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
52496   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
52497   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
52498   if (director) {
52499     director->swig_connect_director(callback0);
52500   }
52501 }
52502
52503
52504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
52505   void * jresult ;
52506   Dali::FrameCallbackInterface *result = 0 ;
52507
52508   {
52509     try {
52510       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
52511     } CALL_CATCH_EXCEPTION(0);
52512   }
52513
52514   jresult = (void *)result;
52515   return jresult;
52516 }
52517
52518 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
52519   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52520   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
52521   return proxy->GetPosition(id, *vector3);
52522 }
52523
52524 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
52525   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52526   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
52527   return proxy->SetPosition(id, *vector3);
52528 }
52529
52530 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
52531   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52532   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
52533   return proxy->BakePosition(id, *vector3);
52534 }
52535
52536 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
52537   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52538   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
52539   return proxy->GetSize(id, *vector3);
52540 }
52541
52542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
52543   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52544   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
52545   return proxy->SetSize(id, *vector3);
52546 }
52547 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
52548   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52549   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
52550   return proxy->BakeSize(id, *vector3);
52551 }
52552
52553 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
52554   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52555   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
52556   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
52557   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
52558 }
52559
52560 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
52561   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52562   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
52563   return proxy->GetScale(id,* vector3);
52564 }
52565
52566 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
52567   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52568   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
52569   return proxy->SetScale(id, *vector3);
52570 }
52571
52572 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
52573   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52574   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
52575   return proxy->BakeScale(id, *vector3);
52576 }
52577
52578 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
52579   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52580   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
52581   return proxy->GetColor(id, *vector4);
52582 }
52583
52584 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
52585   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52586   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
52587   return proxy->SetColor(id, *vector4);
52588 }
52589
52590 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
52591   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
52592   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
52593   return proxy->BakeColor(id, *vector4);
52594 }
52595
52596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
52597   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
52598   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
52599
52600   Dali::Stage *arg1 = (Dali::Stage *) 0;
52601   Dali::Actor *arg3 = 0;
52602
52603   arg1 = (Dali::Stage *)jarg1;
52604   arg3 = (Dali::Actor *)jarg3;
52605
52606   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
52607   return;
52608 }
52609
52610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
52611
52612   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
52613   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
52614
52615   Dali::Stage *arg1 = (Dali::Stage *) 0;
52616
52617   arg1 = (Dali::Stage *)jarg1;
52618
52619   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
52620   return;
52621 }
52622
52623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
52624   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
52625   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
52626   if (director) {
52627     director->swig_connect_director(callback0);
52628   }
52629 }
52630
52631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
52632   KeyboardFocusManager arg1 ;
52633   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
52634   KeyboardFocusManager *argp1 ;
52635
52636   argp1 = (KeyboardFocusManager *)jarg1;
52637   if (!argp1) {
52638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
52639     return ;
52640   }
52641   arg1 = *argp1;
52642   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
52643   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
52644   {
52645     try {
52646       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
52647     } CALL_CATCH_EXCEPTION();
52648   }
52649
52650 }
52651
52652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) {
52653   KeyboardFocusManager arg1 ;
52654   bool arg2 ;
52655   KeyboardFocusManager *argp1 ;
52656
52657   argp1 = (KeyboardFocusManager *)jarg1;
52658   if (!argp1) {
52659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
52660     return ;
52661   }
52662   arg1 = *argp1;
52663   arg2 = jarg2;
52664   {
52665     try {
52666       Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2);
52667     } CALL_CATCH_EXCEPTION();
52668   }
52669 }
52670
52671 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) {
52672   bool jresult ;
52673   KeyboardFocusManager arg1 ;
52674   KeyboardFocusManager *argp1 ;
52675   bool result;
52676
52677   argp1 = (KeyboardFocusManager *)jarg1;
52678   if (!argp1) {
52679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
52680     return false;
52681   }
52682   arg1 = *argp1;
52683   {
52684     try {
52685       result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1);
52686     } CALL_CATCH_EXCEPTION(0);
52687   }
52688   jresult = result;
52689   return jresult;
52690 }
52691
52692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) {
52693   if (!manager) {
52694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
52695     return ;
52696   }
52697   if (!actor) {
52698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
52699     return ;
52700   }
52701   {
52702     try {
52703       Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor);
52704     } CALL_CATCH_EXCEPTION();
52705   }
52706 }
52707
52708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) {
52709   if (!manager) {
52710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
52711     return ;
52712   }
52713   {
52714     try {
52715       Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager);
52716     } CALL_CATCH_EXCEPTION();
52717   }
52718 }
52719
52720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
52721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52722
52723   arg1 = (std::vector< unsigned int > *)jarg1;
52724   {
52725     try {
52726       (arg1)->clear();
52727     } CALL_CATCH_EXCEPTION();
52728   }
52729
52730 }
52731
52732
52733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
52734   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52735   unsigned int *arg2 = 0 ;
52736   unsigned int temp2 ;
52737
52738   arg1 = (std::vector< unsigned int > *)jarg1;
52739   temp2 = (unsigned int)jarg2;
52740   arg2 = &temp2;
52741   {
52742     try {
52743       (arg1)->push_back((unsigned int const &)*arg2);
52744     } CALL_CATCH_EXCEPTION();
52745   }
52746
52747 }
52748
52749
52750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
52751   unsigned long jresult ;
52752   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52753   std::vector< unsigned int >::size_type result;
52754
52755   arg1 = (std::vector< unsigned int > *)jarg1;
52756   {
52757     try {
52758       result = ((std::vector< unsigned int > const *)arg1)->size();
52759     } CALL_CATCH_EXCEPTION(0);
52760   }
52761
52762   jresult = (unsigned long)result;
52763   return jresult;
52764 }
52765
52766
52767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
52768   unsigned long jresult ;
52769   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52770   std::vector< unsigned int >::size_type result;
52771
52772   arg1 = (std::vector< unsigned int > *)jarg1;
52773   {
52774     try {
52775       result = ((std::vector< unsigned int > const *)arg1)->capacity();
52776     } CALL_CATCH_EXCEPTION(0);
52777   }
52778
52779   jresult = (unsigned long)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
52785   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52786   std::vector< unsigned int >::size_type arg2 ;
52787
52788   arg1 = (std::vector< unsigned int > *)jarg1;
52789   arg2 = (std::vector< unsigned int >::size_type)jarg2;
52790   {
52791     try {
52792       (arg1)->reserve(arg2);
52793     } CALL_CATCH_EXCEPTION();
52794   }
52795
52796 }
52797
52798
52799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
52800   void * jresult ;
52801   std::vector< unsigned int > *result = 0 ;
52802
52803   {
52804     try {
52805       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
52806     } CALL_CATCH_EXCEPTION(0);
52807   }
52808
52809   jresult = (void *)result;
52810   return jresult;
52811 }
52812
52813
52814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
52815   void * jresult ;
52816   std::vector< unsigned int > *arg1 = 0 ;
52817   std::vector< unsigned int > *result = 0 ;
52818
52819   arg1 = (std::vector< unsigned int > *)jarg1;
52820   if (!arg1) {
52821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52822     return 0;
52823   }
52824   {
52825     try {
52826       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
52827     } CALL_CATCH_EXCEPTION(0);
52828   }
52829
52830   jresult = (void *)result;
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
52836   void * jresult ;
52837   int arg1 ;
52838   std::vector< unsigned int > *result = 0 ;
52839
52840   arg1 = (int)jarg1;
52841   {
52842     try {
52843       try {
52844         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
52845       }
52846       catch(std::out_of_range &_e) {
52847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52848         return 0;
52849       }
52850
52851     } CALL_CATCH_EXCEPTION(0);
52852   }
52853
52854   jresult = (void *)result;
52855   return jresult;
52856 }
52857
52858
52859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
52860   unsigned int jresult ;
52861   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52862   int arg2 ;
52863   unsigned int result;
52864
52865   arg1 = (std::vector< unsigned int > *)jarg1;
52866   arg2 = (int)jarg2;
52867   {
52868     try {
52869       try {
52870         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
52871       }
52872       catch(std::out_of_range &_e) {
52873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52874         return 0;
52875       }
52876
52877     } CALL_CATCH_EXCEPTION(0);
52878   }
52879
52880   jresult = result;
52881   return jresult;
52882 }
52883
52884
52885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
52886   unsigned int jresult ;
52887   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52888   int arg2 ;
52889   unsigned int *result = 0 ;
52890
52891   arg1 = (std::vector< unsigned int > *)jarg1;
52892   arg2 = (int)jarg2;
52893   {
52894     try {
52895       try {
52896         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
52897       }
52898       catch(std::out_of_range &_e) {
52899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52900         return 0;
52901       }
52902
52903     } CALL_CATCH_EXCEPTION(0);
52904   }
52905
52906   jresult = *result;
52907   return jresult;
52908 }
52909
52910
52911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
52912   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52913   int arg2 ;
52914   unsigned int *arg3 = 0 ;
52915   unsigned int temp3 ;
52916
52917   arg1 = (std::vector< unsigned int > *)jarg1;
52918   arg2 = (int)jarg2;
52919   temp3 = (unsigned int)jarg3;
52920   arg3 = &temp3;
52921   {
52922     try {
52923       try {
52924         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
52925       }
52926       catch(std::out_of_range &_e) {
52927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52928         return ;
52929       }
52930
52931     } CALL_CATCH_EXCEPTION();
52932   }
52933
52934 }
52935
52936
52937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
52938   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52939   std::vector< unsigned int > *arg2 = 0 ;
52940
52941   arg1 = (std::vector< unsigned int > *)jarg1;
52942   arg2 = (std::vector< unsigned int > *)jarg2;
52943   if (!arg2) {
52944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52945     return ;
52946   }
52947   {
52948     try {
52949       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
52950     } CALL_CATCH_EXCEPTION();
52951   }
52952
52953 }
52954
52955
52956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52957   void * jresult ;
52958   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52959   int arg2 ;
52960   int arg3 ;
52961   std::vector< unsigned int > *result = 0 ;
52962
52963   arg1 = (std::vector< unsigned int > *)jarg1;
52964   arg2 = (int)jarg2;
52965   arg3 = (int)jarg3;
52966   {
52967     try {
52968       try {
52969         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52970       }
52971       catch(std::out_of_range &_e) {
52972         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52973         return 0;
52974       }
52975       catch(std::invalid_argument &_e) {
52976         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52977         return 0;
52978       }
52979
52980     } CALL_CATCH_EXCEPTION(0);
52981   }
52982
52983   jresult = (void *)result;
52984   return jresult;
52985 }
52986
52987
52988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52989   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52990   int arg2 ;
52991   unsigned int *arg3 = 0 ;
52992   unsigned int temp3 ;
52993
52994   arg1 = (std::vector< unsigned int > *)jarg1;
52995   arg2 = (int)jarg2;
52996   temp3 = (unsigned int)jarg3;
52997   arg3 = &temp3;
52998   {
52999     try {
53000       try {
53001         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
53002       }
53003       catch(std::out_of_range &_e) {
53004         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53005         return ;
53006       }
53007
53008     } CALL_CATCH_EXCEPTION();
53009   }
53010
53011 }
53012
53013
53014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53015   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53016   int arg2 ;
53017   std::vector< unsigned int > *arg3 = 0 ;
53018
53019   arg1 = (std::vector< unsigned int > *)jarg1;
53020   arg2 = (int)jarg2;
53021   arg3 = (std::vector< unsigned int > *)jarg3;
53022   if (!arg3) {
53023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53024     return ;
53025   }
53026   {
53027     try {
53028       try {
53029         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
53030       }
53031       catch(std::out_of_range &_e) {
53032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53033         return ;
53034       }
53035
53036     } CALL_CATCH_EXCEPTION();
53037   }
53038
53039 }
53040
53041
53042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
53043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53044   int arg2 ;
53045
53046   arg1 = (std::vector< unsigned int > *)jarg1;
53047   arg2 = (int)jarg2;
53048   {
53049     try {
53050       try {
53051         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
53052       }
53053       catch(std::out_of_range &_e) {
53054         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53055         return ;
53056       }
53057
53058     } CALL_CATCH_EXCEPTION();
53059   }
53060
53061 }
53062
53063
53064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53065   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53066   int arg2 ;
53067   int arg3 ;
53068
53069   arg1 = (std::vector< unsigned int > *)jarg1;
53070   arg2 = (int)jarg2;
53071   arg3 = (int)jarg3;
53072   {
53073     try {
53074       try {
53075         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
53076       }
53077       catch(std::out_of_range &_e) {
53078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53079         return ;
53080       }
53081       catch(std::invalid_argument &_e) {
53082         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53083         return ;
53084       }
53085
53086     } CALL_CATCH_EXCEPTION();
53087   }
53088
53089 }
53090
53091
53092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
53093   void * jresult ;
53094   unsigned int *arg1 = 0 ;
53095   int arg2 ;
53096   unsigned int temp1 ;
53097   std::vector< unsigned int > *result = 0 ;
53098
53099   temp1 = (unsigned int)jarg1;
53100   arg1 = &temp1;
53101   arg2 = (int)jarg2;
53102   {
53103     try {
53104       try {
53105         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
53106       }
53107       catch(std::out_of_range &_e) {
53108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53109         return 0;
53110       }
53111
53112     } CALL_CATCH_EXCEPTION(0);
53113   }
53114
53115   jresult = (void *)result;
53116   return jresult;
53117 }
53118
53119
53120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
53121   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53122
53123   arg1 = (std::vector< unsigned int > *)jarg1;
53124   {
53125     try {
53126       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
53127     } CALL_CATCH_EXCEPTION();
53128   }
53129
53130 }
53131
53132
53133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53134   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53135   int arg2 ;
53136   int arg3 ;
53137
53138   arg1 = (std::vector< unsigned int > *)jarg1;
53139   arg2 = (int)jarg2;
53140   arg3 = (int)jarg3;
53141   {
53142     try {
53143       try {
53144         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53145       }
53146       catch(std::out_of_range &_e) {
53147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53148         return ;
53149       }
53150       catch(std::invalid_argument &_e) {
53151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53152         return ;
53153       }
53154
53155     } CALL_CATCH_EXCEPTION();
53156   }
53157
53158 }
53159
53160
53161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53163   int arg2 ;
53164   std::vector< unsigned int > *arg3 = 0 ;
53165
53166   arg1 = (std::vector< unsigned int > *)jarg1;
53167   arg2 = (int)jarg2;
53168   arg3 = (std::vector< unsigned int > *)jarg3;
53169   if (!arg3) {
53170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
53171     return ;
53172   }
53173   {
53174     try {
53175       try {
53176         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
53177       }
53178       catch(std::out_of_range &_e) {
53179         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53180         return ;
53181       }
53182
53183     } CALL_CATCH_EXCEPTION();
53184   }
53185
53186 }
53187
53188
53189 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
53190   bool jresult ;
53191   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53192   unsigned int *arg2 = 0 ;
53193   unsigned int temp2 ;
53194   bool result;
53195
53196   arg1 = (std::vector< unsigned int > *)jarg1;
53197   temp2 = (unsigned int)jarg2;
53198   arg2 = &temp2;
53199   {
53200     try {
53201       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
53202     } CALL_CATCH_EXCEPTION(0);
53203   }
53204
53205   jresult = result;
53206   return jresult;
53207 }
53208
53209
53210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
53211   int jresult ;
53212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53213   unsigned int *arg2 = 0 ;
53214   unsigned int temp2 ;
53215   int result;
53216
53217   arg1 = (std::vector< unsigned int > *)jarg1;
53218   temp2 = (unsigned int)jarg2;
53219   arg2 = &temp2;
53220   {
53221     try {
53222       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
53223     } CALL_CATCH_EXCEPTION(0);
53224   }
53225
53226   jresult = result;
53227   return jresult;
53228 }
53229
53230
53231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
53232   int jresult ;
53233   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53234   unsigned int *arg2 = 0 ;
53235   unsigned int temp2 ;
53236   int result;
53237
53238   arg1 = (std::vector< unsigned int > *)jarg1;
53239   temp2 = (unsigned int)jarg2;
53240   arg2 = &temp2;
53241   {
53242     try {
53243       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
53244     } CALL_CATCH_EXCEPTION(0);
53245   }
53246
53247   jresult = result;
53248   return jresult;
53249 }
53250
53251
53252 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
53253   bool jresult ;
53254   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53255   unsigned int *arg2 = 0 ;
53256   unsigned int temp2 ;
53257   bool result;
53258
53259   arg1 = (std::vector< unsigned int > *)jarg1;
53260   temp2 = (unsigned int)jarg2;
53261   arg2 = &temp2;
53262   {
53263     try {
53264       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
53265     } CALL_CATCH_EXCEPTION(0);
53266   }
53267
53268   jresult = result;
53269   return jresult;
53270 }
53271
53272
53273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
53274   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
53275
53276   arg1 = (std::vector< unsigned int > *)jarg1;
53277   {
53278     try {
53279       delete arg1;
53280     } CALL_CATCH_EXCEPTION();
53281   }
53282
53283 }
53284
53285
53286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
53287   void * jresult ;
53288   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53289
53290   {
53291     try {
53292       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
53293     } CALL_CATCH_EXCEPTION(0);
53294   }
53295
53296   jresult = (void *)result;
53297   return jresult;
53298 }
53299
53300
53301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
53302   void * jresult ;
53303   unsigned int arg1 ;
53304   Dali::Actor arg2 ;
53305   Dali::Actor *argp2 ;
53306   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53307
53308   arg1 = (unsigned int)jarg1;
53309   argp2 = (Dali::Actor *)jarg2;
53310   if (!argp2) {
53311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53312     return 0;
53313   }
53314   arg2 = *argp2;
53315   {
53316     try {
53317       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
53318     } CALL_CATCH_EXCEPTION(0);
53319   }
53320
53321   jresult = (void *)result;
53322   return jresult;
53323 }
53324
53325
53326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
53327   void * jresult ;
53328   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53329   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53330
53331   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53332   if (!arg1) {
53333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53334     return 0;
53335   }
53336   {
53337     try {
53338       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
53339     } CALL_CATCH_EXCEPTION(0);
53340   }
53341
53342   jresult = (void *)result;
53343   return jresult;
53344 }
53345
53346
53347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
53348   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53349   unsigned int arg2 ;
53350
53351   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53352   arg2 = (unsigned int)jarg2;
53353   if (arg1) (arg1)->first = arg2;
53354 }
53355
53356
53357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
53358   unsigned int jresult ;
53359   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53360   unsigned int result;
53361
53362   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53363   result = (unsigned int) ((arg1)->first);
53364   jresult = result;
53365   return jresult;
53366 }
53367
53368
53369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
53370   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53371   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
53372
53373   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53374   arg2 = (Dali::Actor *)jarg2;
53375   if (arg1) (arg1)->second = *arg2;
53376 }
53377
53378
53379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
53380   void * jresult ;
53381   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53382   Dali::Actor *result = 0 ;
53383
53384   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53385   result = (Dali::Actor *)& ((arg1)->second);
53386   jresult = (void *)result;
53387   return jresult;
53388 }
53389
53390
53391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
53392   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
53393
53394   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53395   {
53396     try {
53397       delete arg1;
53398     } CALL_CATCH_EXCEPTION();
53399   }
53400
53401 }
53402
53403
53404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
53405   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53406
53407   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53408   {
53409     try {
53410       (arg1)->clear();
53411     } CALL_CATCH_EXCEPTION();
53412   }
53413
53414 }
53415
53416
53417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
53418   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53419   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
53420
53421   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53422   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
53423   if (!arg2) {
53424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53425     return ;
53426   }
53427   {
53428     try {
53429       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
53430     } CALL_CATCH_EXCEPTION();
53431   }
53432
53433 }
53434
53435
53436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
53437   unsigned long jresult ;
53438   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53439   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
53440
53441   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53442   {
53443     try {
53444       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
53445     } CALL_CATCH_EXCEPTION(0);
53446   }
53447
53448   jresult = (unsigned long)result;
53449   return jresult;
53450 }
53451
53452
53453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
53454   unsigned long jresult ;
53455   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53456   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
53457
53458   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53459   {
53460     try {
53461       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
53462     } CALL_CATCH_EXCEPTION(0);
53463   }
53464
53465   jresult = (unsigned long)result;
53466   return jresult;
53467 }
53468
53469
53470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
53471   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53472   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
53473
53474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53475   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
53476   {
53477     try {
53478       (arg1)->reserve(arg2);
53479     } CALL_CATCH_EXCEPTION();
53480   }
53481
53482 }
53483
53484
53485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
53486   void * jresult ;
53487   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53488
53489   {
53490     try {
53491       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
53492     } CALL_CATCH_EXCEPTION(0);
53493   }
53494
53495   jresult = (void *)result;
53496   return jresult;
53497 }
53498
53499
53500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
53501   void * jresult ;
53502   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
53503   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53504
53505   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53506   if (!arg1) {
53507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53508     return 0;
53509   }
53510   {
53511     try {
53512       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);
53513     } CALL_CATCH_EXCEPTION(0);
53514   }
53515
53516   jresult = (void *)result;
53517   return jresult;
53518 }
53519
53520
53521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
53522   void * jresult ;
53523   int arg1 ;
53524   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53525
53526   arg1 = (int)jarg1;
53527   {
53528     try {
53529       try {
53530         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);
53531       }
53532       catch(std::out_of_range &_e) {
53533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53534         return 0;
53535       }
53536
53537     } CALL_CATCH_EXCEPTION(0);
53538   }
53539
53540   jresult = (void *)result;
53541   return jresult;
53542 }
53543
53544
53545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
53546   void * jresult ;
53547   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53548   int arg2 ;
53549   std::pair< unsigned int,Dali::Actor > result;
53550
53551   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53552   arg2 = (int)jarg2;
53553   {
53554     try {
53555       try {
53556         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
53557       }
53558       catch(std::out_of_range &_e) {
53559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53560         return 0;
53561       }
53562
53563     } CALL_CATCH_EXCEPTION(0);
53564   }
53565
53566   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
53567   return jresult;
53568 }
53569
53570
53571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
53572   void * jresult ;
53573   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53574   int arg2 ;
53575   std::pair< unsigned int,Dali::Actor > *result = 0 ;
53576
53577   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53578   arg2 = (int)jarg2;
53579   {
53580     try {
53581       try {
53582         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
53583       }
53584       catch(std::out_of_range &_e) {
53585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53586         return 0;
53587       }
53588
53589     } CALL_CATCH_EXCEPTION(0);
53590   }
53591
53592   jresult = (void *)result;
53593   return jresult;
53594 }
53595
53596
53597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53598   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53599   int arg2 ;
53600   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
53601
53602   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53603   arg2 = (int)jarg2;
53604   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
53605   if (!arg3) {
53606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53607     return ;
53608   }
53609   {
53610     try {
53611       try {
53612         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);
53613       }
53614       catch(std::out_of_range &_e) {
53615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53616         return ;
53617       }
53618
53619     } CALL_CATCH_EXCEPTION();
53620   }
53621
53622 }
53623
53624
53625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
53626   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53627   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
53628
53629   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53630   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
53631   if (!arg2) {
53632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53633     return ;
53634   }
53635   {
53636     try {
53637       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);
53638     } CALL_CATCH_EXCEPTION();
53639   }
53640
53641 }
53642
53643
53644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53645   void * jresult ;
53646   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53647   int arg2 ;
53648   int arg3 ;
53649   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53650
53651   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53652   arg2 = (int)jarg2;
53653   arg3 = (int)jarg3;
53654   {
53655     try {
53656       try {
53657         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);
53658       }
53659       catch(std::out_of_range &_e) {
53660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53661         return 0;
53662       }
53663       catch(std::invalid_argument &_e) {
53664         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53665         return 0;
53666       }
53667
53668     } CALL_CATCH_EXCEPTION(0);
53669   }
53670
53671   jresult = (void *)result;
53672   return jresult;
53673 }
53674
53675
53676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53677   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53678   int arg2 ;
53679   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
53680
53681   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53682   arg2 = (int)jarg2;
53683   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
53684   if (!arg3) {
53685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53686     return ;
53687   }
53688   {
53689     try {
53690       try {
53691         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);
53692       }
53693       catch(std::out_of_range &_e) {
53694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53695         return ;
53696       }
53697
53698     } CALL_CATCH_EXCEPTION();
53699   }
53700
53701 }
53702
53703
53704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53705   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53706   int arg2 ;
53707   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53708
53709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53710   arg2 = (int)jarg2;
53711   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53712   if (!arg3) {
53713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53714     return ;
53715   }
53716   {
53717     try {
53718       try {
53719         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);
53720       }
53721       catch(std::out_of_range &_e) {
53722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53723         return ;
53724       }
53725
53726     } CALL_CATCH_EXCEPTION();
53727   }
53728
53729 }
53730
53731
53732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
53733   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53734   int arg2 ;
53735
53736   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53737   arg2 = (int)jarg2;
53738   {
53739     try {
53740       try {
53741         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
53742       }
53743       catch(std::out_of_range &_e) {
53744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53745         return ;
53746       }
53747
53748     } CALL_CATCH_EXCEPTION();
53749   }
53750
53751 }
53752
53753
53754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53755   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53756   int arg2 ;
53757   int arg3 ;
53758
53759   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53760   arg2 = (int)jarg2;
53761   arg3 = (int)jarg3;
53762   {
53763     try {
53764       try {
53765         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
53766       }
53767       catch(std::out_of_range &_e) {
53768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53769         return ;
53770       }
53771       catch(std::invalid_argument &_e) {
53772         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53773         return ;
53774       }
53775
53776     } CALL_CATCH_EXCEPTION();
53777   }
53778
53779 }
53780
53781
53782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
53783   void * jresult ;
53784   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53785   int arg2 ;
53786   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53787
53788   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53789   if (!arg1) {
53790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53791     return 0;
53792   }
53793   arg2 = (int)jarg2;
53794   {
53795     try {
53796       try {
53797         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);
53798       }
53799       catch(std::out_of_range &_e) {
53800         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53801         return 0;
53802       }
53803
53804     } CALL_CATCH_EXCEPTION(0);
53805   }
53806
53807   jresult = (void *)result;
53808   return jresult;
53809 }
53810
53811
53812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
53813   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53814
53815   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53816   {
53817     try {
53818       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
53819     } CALL_CATCH_EXCEPTION();
53820   }
53821
53822 }
53823
53824
53825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53826   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53827   int arg2 ;
53828   int arg3 ;
53829
53830   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53831   arg2 = (int)jarg2;
53832   arg3 = (int)jarg3;
53833   {
53834     try {
53835       try {
53836         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53837       }
53838       catch(std::out_of_range &_e) {
53839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53840         return ;
53841       }
53842       catch(std::invalid_argument &_e) {
53843         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53844         return ;
53845       }
53846
53847     } CALL_CATCH_EXCEPTION();
53848   }
53849
53850 }
53851
53852
53853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53854   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53855   int arg2 ;
53856   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53857
53858   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53859   arg2 = (int)jarg2;
53860   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53861   if (!arg3) {
53862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53863     return ;
53864   }
53865   {
53866     try {
53867       try {
53868         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);
53869       }
53870       catch(std::out_of_range &_e) {
53871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53872         return ;
53873       }
53874
53875     } CALL_CATCH_EXCEPTION();
53876   }
53877
53878 }
53879
53880
53881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
53882   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53883
53884   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53885   {
53886     try {
53887       delete arg1;
53888     } CALL_CATCH_EXCEPTION();
53889   }
53890
53891 }
53892
53893
53894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
53895   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53896
53897   arg1 = (std::vector< Dali::Actor > *)jarg1;
53898   {
53899     try {
53900       (arg1)->clear();
53901     } CALL_CATCH_EXCEPTION();
53902   }
53903
53904 }
53905
53906
53907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
53908   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53909   Dali::Actor *arg2 = 0 ;
53910
53911   arg1 = (std::vector< Dali::Actor > *)jarg1;
53912   arg2 = (Dali::Actor *)jarg2;
53913   if (!arg2) {
53914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53915     return ;
53916   }
53917   {
53918     try {
53919       (arg1)->push_back((Dali::Actor const &)*arg2);
53920     } CALL_CATCH_EXCEPTION();
53921   }
53922
53923 }
53924
53925
53926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
53927   unsigned long jresult ;
53928   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53929   std::vector< Dali::Actor >::size_type result;
53930
53931   arg1 = (std::vector< Dali::Actor > *)jarg1;
53932   {
53933     try {
53934       result = ((std::vector< Dali::Actor > const *)arg1)->size();
53935     } CALL_CATCH_EXCEPTION(0);
53936   }
53937
53938   jresult = (unsigned long)result;
53939   return jresult;
53940 }
53941
53942
53943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
53944   unsigned long jresult ;
53945   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53946   std::vector< Dali::Actor >::size_type result;
53947
53948   arg1 = (std::vector< Dali::Actor > *)jarg1;
53949   {
53950     try {
53951       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
53952     } CALL_CATCH_EXCEPTION(0);
53953   }
53954
53955   jresult = (unsigned long)result;
53956   return jresult;
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
53961   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53962   std::vector< Dali::Actor >::size_type arg2 ;
53963
53964   arg1 = (std::vector< Dali::Actor > *)jarg1;
53965   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53966   {
53967     try {
53968       (arg1)->reserve(arg2);
53969     } CALL_CATCH_EXCEPTION();
53970   }
53971
53972 }
53973
53974
53975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53976   void * jresult ;
53977   std::vector< Dali::Actor > *result = 0 ;
53978
53979   {
53980     try {
53981       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53982     } CALL_CATCH_EXCEPTION(0);
53983   }
53984
53985   jresult = (void *)result;
53986   return jresult;
53987 }
53988
53989
53990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53991   void * jresult ;
53992   std::vector< Dali::Actor > *arg1 = 0 ;
53993   std::vector< Dali::Actor > *result = 0 ;
53994
53995   arg1 = (std::vector< Dali::Actor > *)jarg1;
53996   if (!arg1) {
53997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53998     return 0;
53999   }
54000   {
54001     try {
54002       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
54003     } CALL_CATCH_EXCEPTION(0);
54004   }
54005
54006   jresult = (void *)result;
54007   return jresult;
54008 }
54009
54010
54011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
54012   void * jresult ;
54013   int arg1 ;
54014   std::vector< Dali::Actor > *result = 0 ;
54015
54016   arg1 = (int)jarg1;
54017   {
54018     try {
54019       try {
54020         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
54021       }
54022       catch(std::out_of_range &_e) {
54023         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54024         return 0;
54025       }
54026
54027     } CALL_CATCH_EXCEPTION(0);
54028   }
54029
54030   jresult = (void *)result;
54031   return jresult;
54032 }
54033
54034
54035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
54036   void * jresult ;
54037   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54038   int arg2 ;
54039   Dali::Actor result;
54040
54041   arg1 = (std::vector< Dali::Actor > *)jarg1;
54042   arg2 = (int)jarg2;
54043   {
54044     try {
54045       try {
54046         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
54047       }
54048       catch(std::out_of_range &_e) {
54049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54050         return 0;
54051       }
54052
54053     } CALL_CATCH_EXCEPTION(0);
54054   }
54055
54056   jresult = new Dali::Actor((const Dali::Actor &)result);
54057   return jresult;
54058 }
54059
54060
54061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
54062   void * jresult ;
54063   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54064   int arg2 ;
54065   Dali::Actor *result = 0 ;
54066
54067   arg1 = (std::vector< Dali::Actor > *)jarg1;
54068   arg2 = (int)jarg2;
54069   {
54070     try {
54071       try {
54072         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
54073       }
54074       catch(std::out_of_range &_e) {
54075         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54076         return 0;
54077       }
54078
54079     } CALL_CATCH_EXCEPTION(0);
54080   }
54081
54082   jresult = (void *)result;
54083   return jresult;
54084 }
54085
54086
54087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
54088   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54089   int arg2 ;
54090   Dali::Actor *arg3 = 0 ;
54091
54092   arg1 = (std::vector< Dali::Actor > *)jarg1;
54093   arg2 = (int)jarg2;
54094   arg3 = (Dali::Actor *)jarg3;
54095   if (!arg3) {
54096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54097     return ;
54098   }
54099   {
54100     try {
54101       try {
54102         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
54103       }
54104       catch(std::out_of_range &_e) {
54105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54106         return ;
54107       }
54108
54109     } CALL_CATCH_EXCEPTION();
54110   }
54111
54112 }
54113
54114
54115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
54116   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54117   std::vector< Dali::Actor > *arg2 = 0 ;
54118
54119   arg1 = (std::vector< Dali::Actor > *)jarg1;
54120   arg2 = (std::vector< Dali::Actor > *)jarg2;
54121   if (!arg2) {
54122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54123     return ;
54124   }
54125   {
54126     try {
54127       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
54128     } CALL_CATCH_EXCEPTION();
54129   }
54130
54131 }
54132
54133
54134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
54135   void * jresult ;
54136   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54137   int arg2 ;
54138   int arg3 ;
54139   std::vector< Dali::Actor > *result = 0 ;
54140
54141   arg1 = (std::vector< Dali::Actor > *)jarg1;
54142   arg2 = (int)jarg2;
54143   arg3 = (int)jarg3;
54144   {
54145     try {
54146       try {
54147         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
54148       }
54149       catch(std::out_of_range &_e) {
54150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54151         return 0;
54152       }
54153       catch(std::invalid_argument &_e) {
54154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54155         return 0;
54156       }
54157
54158     } CALL_CATCH_EXCEPTION(0);
54159   }
54160
54161   jresult = (void *)result;
54162   return jresult;
54163 }
54164
54165
54166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
54167   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54168   int arg2 ;
54169   Dali::Actor *arg3 = 0 ;
54170
54171   arg1 = (std::vector< Dali::Actor > *)jarg1;
54172   arg2 = (int)jarg2;
54173   arg3 = (Dali::Actor *)jarg3;
54174   if (!arg3) {
54175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54176     return ;
54177   }
54178   {
54179     try {
54180       try {
54181         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
54182       }
54183       catch(std::out_of_range &_e) {
54184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54185         return ;
54186       }
54187
54188     } CALL_CATCH_EXCEPTION();
54189   }
54190
54191 }
54192
54193
54194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
54195   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54196   int arg2 ;
54197   std::vector< Dali::Actor > *arg3 = 0 ;
54198
54199   arg1 = (std::vector< Dali::Actor > *)jarg1;
54200   arg2 = (int)jarg2;
54201   arg3 = (std::vector< Dali::Actor > *)jarg3;
54202   if (!arg3) {
54203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54204     return ;
54205   }
54206   {
54207     try {
54208       try {
54209         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
54210       }
54211       catch(std::out_of_range &_e) {
54212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54213         return ;
54214       }
54215
54216     } CALL_CATCH_EXCEPTION();
54217   }
54218
54219 }
54220
54221
54222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
54223   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54224   int arg2 ;
54225
54226   arg1 = (std::vector< Dali::Actor > *)jarg1;
54227   arg2 = (int)jarg2;
54228   {
54229     try {
54230       try {
54231         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
54232       }
54233       catch(std::out_of_range &_e) {
54234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54235         return ;
54236       }
54237
54238     } CALL_CATCH_EXCEPTION();
54239   }
54240
54241 }
54242
54243
54244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
54245   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54246   int arg2 ;
54247   int arg3 ;
54248
54249   arg1 = (std::vector< Dali::Actor > *)jarg1;
54250   arg2 = (int)jarg2;
54251   arg3 = (int)jarg3;
54252   {
54253     try {
54254       try {
54255         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
54256       }
54257       catch(std::out_of_range &_e) {
54258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54259         return ;
54260       }
54261       catch(std::invalid_argument &_e) {
54262         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54263         return ;
54264       }
54265
54266     } CALL_CATCH_EXCEPTION();
54267   }
54268
54269 }
54270
54271
54272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
54273   void * jresult ;
54274   Dali::Actor *arg1 = 0 ;
54275   int arg2 ;
54276   std::vector< Dali::Actor > *result = 0 ;
54277
54278   arg1 = (Dali::Actor *)jarg1;
54279   if (!arg1) {
54280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
54281     return 0;
54282   }
54283   arg2 = (int)jarg2;
54284   {
54285     try {
54286       try {
54287         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
54288       }
54289       catch(std::out_of_range &_e) {
54290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54291         return 0;
54292       }
54293
54294     } CALL_CATCH_EXCEPTION(0);
54295   }
54296
54297   jresult = (void *)result;
54298   return jresult;
54299 }
54300
54301
54302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
54303   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54304
54305   arg1 = (std::vector< Dali::Actor > *)jarg1;
54306   {
54307     try {
54308       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
54309     } CALL_CATCH_EXCEPTION();
54310   }
54311
54312 }
54313
54314
54315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
54316   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54317   int arg2 ;
54318   int arg3 ;
54319
54320   arg1 = (std::vector< Dali::Actor > *)jarg1;
54321   arg2 = (int)jarg2;
54322   arg3 = (int)jarg3;
54323   {
54324     try {
54325       try {
54326         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
54327       }
54328       catch(std::out_of_range &_e) {
54329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54330         return ;
54331       }
54332       catch(std::invalid_argument &_e) {
54333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
54334         return ;
54335       }
54336
54337     } CALL_CATCH_EXCEPTION();
54338   }
54339
54340 }
54341
54342
54343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
54344   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54345   int arg2 ;
54346   std::vector< Dali::Actor > *arg3 = 0 ;
54347
54348   arg1 = (std::vector< Dali::Actor > *)jarg1;
54349   arg2 = (int)jarg2;
54350   arg3 = (std::vector< Dali::Actor > *)jarg3;
54351   if (!arg3) {
54352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
54353     return ;
54354   }
54355   {
54356     try {
54357       try {
54358         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
54359       }
54360       catch(std::out_of_range &_e) {
54361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
54362         return ;
54363       }
54364
54365     } CALL_CATCH_EXCEPTION();
54366   }
54367
54368 }
54369
54370
54371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
54372   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
54373
54374   arg1 = (std::vector< Dali::Actor > *)jarg1;
54375   {
54376     try {
54377       delete arg1;
54378     } CALL_CATCH_EXCEPTION();
54379   }
54380
54381 }
54382
54383
54384 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
54385   bool jresult ;
54386   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54387   bool result;
54388
54389   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54390   {
54391     try {
54392       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
54393     } CALL_CATCH_EXCEPTION(0);
54394   }
54395
54396   jresult = result;
54397   return jresult;
54398 }
54399
54400
54401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
54402   unsigned long jresult ;
54403   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54404   std::size_t result;
54405
54406   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54407   {
54408     try {
54409       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
54410     } CALL_CATCH_EXCEPTION(0);
54411   }
54412
54413   jresult = (unsigned long)result;
54414   return jresult;
54415 }
54416
54417
54418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
54419   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54420   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
54421
54422   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54423   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
54424   {
54425     try {
54426       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
54427     } CALL_CATCH_EXCEPTION();
54428   }
54429
54430 }
54431
54432
54433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
54434   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54435   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
54436
54437   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54438   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
54439   {
54440     try {
54441       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
54442     } CALL_CATCH_EXCEPTION();
54443   }
54444
54445 }
54446
54447
54448 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
54449   bool jresult ;
54450   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54451   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
54452   bool result;
54453
54454   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54455   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
54456   if (!arg2) {
54457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
54458     return 0;
54459   }
54460   {
54461     try {
54462       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
54463     } CALL_CATCH_EXCEPTION(0);
54464   }
54465
54466   jresult = result;
54467   return jresult;
54468 }
54469
54470
54471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
54472   void * jresult ;
54473   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
54474
54475   {
54476     try {
54477       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
54478     } CALL_CATCH_EXCEPTION(0);
54479   }
54480
54481   jresult = (void *)result;
54482   return jresult;
54483 }
54484
54485
54486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
54487   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
54488
54489   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
54490   {
54491     try {
54492       delete arg1;
54493     } CALL_CATCH_EXCEPTION();
54494   }
54495
54496 }
54497
54498
54499 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
54500   bool jresult ;
54501   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54502   bool result;
54503
54504   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54505   {
54506     try {
54507       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);
54508     } CALL_CATCH_EXCEPTION(0);
54509   }
54510
54511   jresult = result;
54512   return jresult;
54513 }
54514
54515
54516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
54517   unsigned long jresult ;
54518   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54519   std::size_t result;
54520
54521   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54522   {
54523     try {
54524       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);
54525     } CALL_CATCH_EXCEPTION(0);
54526   }
54527
54528   jresult = (unsigned long)result;
54529   return jresult;
54530 }
54531
54532
54533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
54534   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54535   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
54536
54537   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54538   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
54539   {
54540     try {
54541       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
54542     } CALL_CATCH_EXCEPTION();
54543   }
54544
54545 }
54546
54547
54548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
54549   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54550   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
54551
54552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54553   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
54554   {
54555     try {
54556       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
54557     } CALL_CATCH_EXCEPTION();
54558   }
54559
54560 }
54561
54562
54563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54564   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54565   Dali::Actor arg2 ;
54566   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
54567   Dali::Actor *argp2 ;
54568
54569   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54570   argp2 = (Dali::Actor *)jarg2;
54571   if (!argp2) {
54572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54573     return ;
54574   }
54575   arg2 = *argp2;
54576   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
54577   {
54578     try {
54579       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
54580     } CALL_CATCH_EXCEPTION();
54581   }
54582
54583 }
54584
54585
54586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
54587   void * jresult ;
54588   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
54589
54590   {
54591     try {
54592       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
54593     } CALL_CATCH_EXCEPTION(0);
54594   }
54595
54596   jresult = (void *)result;
54597   return jresult;
54598 }
54599
54600
54601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
54602   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
54603
54604   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
54605   {
54606     try {
54607       delete arg1;
54608     } CALL_CATCH_EXCEPTION();
54609   }
54610
54611 }
54612
54613
54614 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
54615   bool jresult ;
54616   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54617   bool result;
54618
54619   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54620   {
54621     try {
54622       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
54623     } CALL_CATCH_EXCEPTION(0);
54624   }
54625
54626   jresult = result;
54627   return jresult;
54628 }
54629
54630
54631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
54632   unsigned long jresult ;
54633   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54634   std::size_t result;
54635
54636   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54637   {
54638     try {
54639       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
54640     } CALL_CATCH_EXCEPTION(0);
54641   }
54642
54643   jresult = (unsigned long)result;
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
54649   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54650   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
54651
54652   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54653   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
54654   {
54655     try {
54656       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
54657     } CALL_CATCH_EXCEPTION();
54658   }
54659
54660 }
54661
54662
54663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54664   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54665   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
54666
54667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54668   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
54669   {
54670     try {
54671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
54672     } CALL_CATCH_EXCEPTION();
54673   }
54674
54675 }
54676
54677
54678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54679   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54680   Dali::Actor arg2 ;
54681   Dali::Actor arg3 ;
54682   Dali::Actor *argp2 ;
54683   Dali::Actor *argp3 ;
54684
54685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54686   argp2 = (Dali::Actor *)jarg2;
54687   if (!argp2) {
54688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54689     return ;
54690   }
54691   arg2 = *argp2;
54692   argp3 = (Dali::Actor *)jarg3;
54693   if (!argp3) {
54694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54695     return ;
54696   }
54697   arg3 = *argp3;
54698   {
54699     try {
54700       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
54701     } CALL_CATCH_EXCEPTION();
54702   }
54703
54704 }
54705
54706
54707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
54708   void * jresult ;
54709   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
54710
54711   {
54712     try {
54713       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
54714     } CALL_CATCH_EXCEPTION(0);
54715   }
54716
54717   jresult = (void *)result;
54718   return jresult;
54719 }
54720
54721
54722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
54723   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
54724
54725   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54726   {
54727     try {
54728       delete arg1;
54729     } CALL_CATCH_EXCEPTION();
54730   }
54731
54732 }
54733
54734
54735 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
54736   bool jresult ;
54737   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54738   bool result;
54739
54740   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54741   {
54742     try {
54743       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54744     } CALL_CATCH_EXCEPTION(0);
54745   }
54746
54747   jresult = result;
54748   return jresult;
54749 }
54750
54751
54752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
54753   unsigned long jresult ;
54754   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54755   std::size_t result;
54756
54757   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54758   {
54759     try {
54760       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54761     } CALL_CATCH_EXCEPTION(0);
54762   }
54763
54764   jresult = (unsigned long)result;
54765   return jresult;
54766 }
54767
54768
54769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
54770   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54771   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54772
54773   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54774   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54775   {
54776     try {
54777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
54778     } CALL_CATCH_EXCEPTION();
54779   }
54780
54781 }
54782
54783
54784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54785   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54786   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54787
54788   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54789   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54790   {
54791     try {
54792       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54793     } CALL_CATCH_EXCEPTION();
54794   }
54795
54796 }
54797
54798
54799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
54800   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54801   Dali::Actor arg2 ;
54802   bool arg3 ;
54803   Dali::Actor *argp2 ;
54804
54805   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54806   argp2 = (Dali::Actor *)jarg2;
54807   if (!argp2) {
54808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54809     return ;
54810   }
54811   arg2 = *argp2;
54812   arg3 = jarg3 ? true : false;
54813   {
54814     try {
54815       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
54816     } CALL_CATCH_EXCEPTION();
54817   }
54818
54819 }
54820
54821
54822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
54823   void * jresult ;
54824   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
54825
54826   {
54827     try {
54828       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
54829     } CALL_CATCH_EXCEPTION(0);
54830   }
54831
54832   jresult = (void *)result;
54833   return jresult;
54834 }
54835
54836
54837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
54838   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54839
54840   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54841   {
54842     try {
54843       delete arg1;
54844     } CALL_CATCH_EXCEPTION();
54845   }
54846
54847 }
54848
54849
54850 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
54851   bool jresult ;
54852   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54853   bool result;
54854
54855   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54856   {
54857     try {
54858       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);
54859     } CALL_CATCH_EXCEPTION(0);
54860   }
54861
54862   jresult = result;
54863   return jresult;
54864 }
54865
54866
54867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
54868   unsigned long jresult ;
54869   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54870   std::size_t result;
54871
54872   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54873   {
54874     try {
54875       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);
54876     } CALL_CATCH_EXCEPTION(0);
54877   }
54878
54879   jresult = (unsigned long)result;
54880   return jresult;
54881 }
54882
54883
54884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
54885   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54886   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54887
54888   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54889   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54890   {
54891     try {
54892       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
54893     } CALL_CATCH_EXCEPTION();
54894   }
54895
54896 }
54897
54898
54899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54900   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54901   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54902
54903   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54904   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54905   {
54906     try {
54907       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
54908     } CALL_CATCH_EXCEPTION();
54909   }
54910
54911 }
54912
54913
54914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54915   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54916   Dali::Toolkit::StyleManager arg2 ;
54917   Dali::StyleChange::Type arg3 ;
54918   Dali::Toolkit::StyleManager *argp2 ;
54919
54920   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54921   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
54922   if (!argp2) {
54923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
54924     return ;
54925   }
54926   arg2 = *argp2;
54927   arg3 = (Dali::StyleChange::Type)jarg3;
54928   {
54929     try {
54930       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
54931     } CALL_CATCH_EXCEPTION();
54932   }
54933
54934 }
54935
54936
54937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
54938   void * jresult ;
54939   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
54940
54941   {
54942     try {
54943       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
54944     } CALL_CATCH_EXCEPTION(0);
54945   }
54946
54947   jresult = (void *)result;
54948   return jresult;
54949 }
54950
54951
54952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
54953   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54954
54955   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54956   {
54957     try {
54958       delete arg1;
54959     } CALL_CATCH_EXCEPTION();
54960   }
54961
54962 }
54963
54964
54965 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54966   bool jresult ;
54967   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54968   bool result;
54969
54970   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54971   {
54972     try {
54973       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54974     } CALL_CATCH_EXCEPTION(0);
54975   }
54976
54977   jresult = result;
54978   return jresult;
54979 }
54980
54981
54982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54983   unsigned long jresult ;
54984   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54985   std::size_t result;
54986
54987   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54988   {
54989     try {
54990       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54991     } CALL_CATCH_EXCEPTION(0);
54992   }
54993
54994   jresult = (unsigned long)result;
54995   return jresult;
54996 }
54997
54998
54999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
55000   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55001   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55002
55003   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55004   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55005   {
55006     try {
55007       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
55008     } CALL_CATCH_EXCEPTION();
55009   }
55010
55011 }
55012
55013
55014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
55015   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55016   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
55017
55018   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55019   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
55020   {
55021     try {
55022       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
55023     } CALL_CATCH_EXCEPTION();
55024   }
55025
55026 }
55027
55028
55029 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
55030   bool jresult ;
55031   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55032   Dali::Toolkit::Button arg2 ;
55033   Dali::Toolkit::Button *argp2 ;
55034   bool result;
55035
55036   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55037   argp2 = (Dali::Toolkit::Button *)jarg2;
55038   if (!argp2) {
55039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
55040     return 0;
55041   }
55042   arg2 = *argp2;
55043   {
55044     try {
55045       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
55046     } CALL_CATCH_EXCEPTION(0);
55047   }
55048
55049   jresult = result;
55050   return jresult;
55051 }
55052
55053
55054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
55055   void * jresult ;
55056   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
55057
55058   {
55059     try {
55060       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
55061     } CALL_CATCH_EXCEPTION(0);
55062   }
55063
55064   jresult = (void *)result;
55065   return jresult;
55066 }
55067
55068
55069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
55070   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
55071
55072   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
55073   {
55074     try {
55075       delete arg1;
55076     } CALL_CATCH_EXCEPTION();
55077   }
55078
55079 }
55080
55081
55082 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
55083   bool jresult ;
55084   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55085   bool result;
55086
55087   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55088   {
55089     try {
55090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
55091     } CALL_CATCH_EXCEPTION(0);
55092   }
55093
55094   jresult = result;
55095   return jresult;
55096 }
55097
55098
55099 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
55100   unsigned long jresult ;
55101   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55102   std::size_t result;
55103
55104   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55105   {
55106     try {
55107       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
55108     } CALL_CATCH_EXCEPTION(0);
55109   }
55110
55111   jresult = (unsigned long)result;
55112   return jresult;
55113 }
55114
55115
55116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
55117   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55118   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
55119
55120   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55121   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
55122   {
55123     try {
55124       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
55125     } CALL_CATCH_EXCEPTION();
55126   }
55127
55128 }
55129
55130
55131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
55132   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55133   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
55134
55135   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55136   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
55137   {
55138     try {
55139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
55140     } CALL_CATCH_EXCEPTION();
55141   }
55142
55143 }
55144
55145
55146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
55147   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55148   Dali::Toolkit::GaussianBlurView arg2 ;
55149   Dali::Toolkit::GaussianBlurView *argp2 ;
55150
55151   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55152   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
55153   if (!argp2) {
55154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
55155     return ;
55156   }
55157   arg2 = *argp2;
55158   {
55159     try {
55160       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
55161     } CALL_CATCH_EXCEPTION();
55162   }
55163
55164 }
55165
55166
55167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
55168   void * jresult ;
55169   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
55170
55171   {
55172     try {
55173       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
55174     } CALL_CATCH_EXCEPTION(0);
55175   }
55176
55177   jresult = (void *)result;
55178   return jresult;
55179 }
55180
55181
55182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
55183   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
55184
55185   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
55186   {
55187     try {
55188       delete arg1;
55189     } CALL_CATCH_EXCEPTION();
55190   }
55191
55192 }
55193
55194
55195 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
55196   bool jresult ;
55197   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55198   bool result;
55199
55200   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55201   {
55202     try {
55203       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);
55204     } CALL_CATCH_EXCEPTION(0);
55205   }
55206
55207   jresult = result;
55208   return jresult;
55209 }
55210
55211
55212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
55213   unsigned long jresult ;
55214   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55215   std::size_t result;
55216
55217   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55218   {
55219     try {
55220       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);
55221     } CALL_CATCH_EXCEPTION(0);
55222   }
55223
55224   jresult = (unsigned long)result;
55225   return jresult;
55226 }
55227
55228
55229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
55230   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55231   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
55232
55233   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55234   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
55235   {
55236     try {
55237       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
55238     } CALL_CATCH_EXCEPTION();
55239   }
55240
55241 }
55242
55243
55244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
55245   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55246   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
55247
55248   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55249   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
55250   {
55251     try {
55252       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
55253     } CALL_CATCH_EXCEPTION();
55254   }
55255
55256 }
55257
55258
55259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) {
55260   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55261   Dali::Toolkit::PageTurnView arg2 ;
55262   unsigned int arg3 ;
55263   bool arg4 ;
55264   Dali::Toolkit::PageTurnView *argp2 ;
55265
55266   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55267   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
55268   if (!argp2) {
55269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
55270     return ;
55271   }
55272   arg2 = *argp2;
55273   arg3 = (unsigned int)jarg3;
55274   arg4 = jarg4 ? true : false;
55275   {
55276     try {
55277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
55278     } CALL_CATCH_EXCEPTION();
55279   }
55280
55281 }
55282
55283
55284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
55285   void * jresult ;
55286   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
55287
55288   {
55289     try {
55290       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
55291     } CALL_CATCH_EXCEPTION(0);
55292   }
55293
55294   jresult = (void *)result;
55295   return jresult;
55296 }
55297
55298
55299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
55300   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
55301
55302   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
55303   {
55304     try {
55305       delete arg1;
55306     } CALL_CATCH_EXCEPTION();
55307   }
55308
55309 }
55310
55311
55312 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
55313   bool jresult ;
55314   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55315   bool result;
55316
55317   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55318   {
55319     try {
55320       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
55321     } CALL_CATCH_EXCEPTION(0);
55322   }
55323
55324   jresult = result;
55325   return jresult;
55326 }
55327
55328
55329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
55330   unsigned long jresult ;
55331   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55332   std::size_t result;
55333
55334   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55335   {
55336     try {
55337       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
55338     } CALL_CATCH_EXCEPTION(0);
55339   }
55340
55341   jresult = (unsigned long)result;
55342   return jresult;
55343 }
55344
55345
55346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
55347   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55348   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
55349
55350   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55351   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
55352   {
55353     try {
55354       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
55355     } CALL_CATCH_EXCEPTION();
55356   }
55357 }
55358
55359
55360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
55361   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55362   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
55363
55364   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55365   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
55366   {
55367     try {
55368       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
55369     } CALL_CATCH_EXCEPTION();
55370   }
55371 }
55372
55373
55374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
55375   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55376   Dali::Toolkit::PageTurnView arg2 ;
55377   Dali::Toolkit::PageTurnView *argp2 ;
55378
55379   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55380   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
55381   if (!argp2) {
55382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
55383     return ;
55384   }
55385   arg2 = *argp2;
55386   {
55387     try {
55388       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
55389     } CALL_CATCH_EXCEPTION();
55390   }
55391 }
55392
55393
55394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
55395   void * jresult ;
55396   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
55397
55398   {
55399     try {
55400       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
55401     } CALL_CATCH_EXCEPTION(0);
55402   }
55403
55404   jresult = (void *)result;
55405   return jresult;
55406 }
55407
55408
55409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
55410   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
55411
55412   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
55413   {
55414     try {
55415       delete arg1;
55416     } CALL_CATCH_EXCEPTION();
55417   }
55418
55419 }
55420
55421
55422 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
55423   bool jresult ;
55424   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55425   bool result;
55426
55427   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55428   {
55429     try {
55430       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
55431     } CALL_CATCH_EXCEPTION(0);
55432   }
55433
55434   jresult = result;
55435   return jresult;
55436 }
55437
55438
55439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
55440   unsigned long jresult ;
55441   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55442   std::size_t result;
55443
55444   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55445   {
55446     try {
55447       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
55448     } CALL_CATCH_EXCEPTION(0);
55449   }
55450
55451   jresult = (unsigned long)result;
55452   return jresult;
55453 }
55454
55455
55456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55457   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55458   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
55459
55460   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55461   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
55462   {
55463     try {
55464       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
55465     } CALL_CATCH_EXCEPTION();
55466   }
55467
55468 }
55469
55470
55471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55472   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55473   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
55474
55475   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55476   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
55477   {
55478     try {
55479       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55480     } CALL_CATCH_EXCEPTION();
55481   }
55482
55483 }
55484
55485
55486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
55487   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55488   Dali::Toolkit::ProgressBar arg2 ;
55489   float arg3 ;
55490   float arg4 ;
55491   Dali::Toolkit::ProgressBar *argp2 ;
55492
55493   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55494   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
55495   if (!argp2) {
55496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
55497     return ;
55498   }
55499   arg2 = *argp2;
55500   arg3 = (float)jarg3;
55501   arg4 = (float)jarg4;
55502   {
55503     try {
55504       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
55505     } CALL_CATCH_EXCEPTION();
55506   }
55507
55508 }
55509
55510
55511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
55512   void * jresult ;
55513   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
55514
55515   {
55516     try {
55517       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
55518     } CALL_CATCH_EXCEPTION(0);
55519   }
55520
55521   jresult = (void *)result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
55527   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
55528
55529   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
55530   {
55531     try {
55532       delete arg1;
55533     } CALL_CATCH_EXCEPTION();
55534   }
55535
55536 }
55537
55538
55539 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
55540   bool jresult ;
55541   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55542   bool result;
55543
55544   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55545   {
55546     try {
55547       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);
55548     } CALL_CATCH_EXCEPTION(0);
55549   }
55550
55551   jresult = result;
55552   return jresult;
55553 }
55554
55555
55556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
55557   unsigned long jresult ;
55558   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55559   std::size_t result;
55560
55561   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55562   {
55563     try {
55564       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);
55565     } CALL_CATCH_EXCEPTION(0);
55566   }
55567
55568   jresult = (unsigned long)result;
55569   return jresult;
55570 }
55571
55572
55573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
55574   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55575   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
55576
55577   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55578   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
55579   {
55580     try {
55581       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55582     } CALL_CATCH_EXCEPTION();
55583   }
55584
55585 }
55586
55587
55588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
55589   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55590   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
55591
55592   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55593   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
55594   {
55595     try {
55596       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55597     } CALL_CATCH_EXCEPTION();
55598   }
55599
55600 }
55601
55602
55603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
55604   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55605   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
55606
55607   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55608   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
55609   if (!arg2) {
55610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
55611     return ;
55612   }
55613   {
55614     try {
55615       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
55616     } CALL_CATCH_EXCEPTION();
55617   }
55618
55619 }
55620
55621
55622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
55623   void * jresult ;
55624   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
55625
55626   {
55627     try {
55628       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
55629     } CALL_CATCH_EXCEPTION(0);
55630   }
55631
55632   jresult = (void *)result;
55633   return jresult;
55634 }
55635
55636
55637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
55638   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
55639
55640   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
55641   {
55642     try {
55643       delete arg1;
55644     } CALL_CATCH_EXCEPTION();
55645   }
55646
55647 }
55648
55649
55650 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
55651   bool jresult ;
55652   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55653   bool result;
55654
55655   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55656   {
55657     try {
55658       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
55659     } CALL_CATCH_EXCEPTION(0);
55660   }
55661
55662   jresult = result;
55663   return jresult;
55664 }
55665
55666
55667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
55668   unsigned long jresult ;
55669   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55670   std::size_t result;
55671
55672   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55673   {
55674     try {
55675       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
55676     } CALL_CATCH_EXCEPTION(0);
55677   }
55678
55679   jresult = (unsigned long)result;
55680   return jresult;
55681 }
55682
55683
55684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
55685   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55686   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
55687
55688   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55689   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
55690   {
55691     try {
55692       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55693     } CALL_CATCH_EXCEPTION();
55694   }
55695
55696 }
55697
55698
55699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
55700   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55701   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
55702
55703   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55704   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
55705   {
55706     try {
55707       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55708     } CALL_CATCH_EXCEPTION();
55709   }
55710
55711 }
55712
55713
55714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
55715   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55716   Dali::Vector2 *arg2 = 0 ;
55717
55718   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55719   arg2 = (Dali::Vector2 *)jarg2;
55720   if (!arg2) {
55721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
55722     return ;
55723   }
55724   {
55725     try {
55726       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
55727     } CALL_CATCH_EXCEPTION();
55728   }
55729
55730 }
55731
55732
55733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
55734   void * jresult ;
55735   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
55736
55737   {
55738     try {
55739       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
55740     } CALL_CATCH_EXCEPTION(0);
55741   }
55742
55743   jresult = (void *)result;
55744   return jresult;
55745 }
55746
55747
55748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
55749   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55750
55751   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55752   {
55753     try {
55754       delete arg1;
55755     } CALL_CATCH_EXCEPTION();
55756   }
55757
55758 }
55759
55760
55761
55762 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
55763   bool jresult ;
55764   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55765   bool result;
55766
55767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55768   {
55769     try {
55770       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *)arg1);
55771     } CALL_CATCH_EXCEPTION(0);
55772   }
55773
55774   jresult = result;
55775   return jresult;
55776 }
55777
55778
55779 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
55780   unsigned long jresult ;
55781   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55782   std::size_t result;
55783
55784   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55785   {
55786     try {
55787       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *)arg1);
55788     } CALL_CATCH_EXCEPTION(0);
55789   }
55790
55791   jresult = (unsigned long)result;
55792   return jresult;
55793 }
55794
55795
55796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
55797   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55798   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55799
55800   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55801   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55802   {
55803     try {
55804       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55805     } CALL_CATCH_EXCEPTION();
55806   }
55807
55808 }
55809
55810
55811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
55812   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55813   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55814
55815   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55816   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55817   {
55818     try {
55819       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55820     } CALL_CATCH_EXCEPTION();
55821   }
55822
55823 }
55824
55825
55826 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55827   bool jresult ;
55828   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55829   Dali::Toolkit::Control arg2 ;
55830   Dali::KeyEvent *arg3 = 0 ;
55831   Dali::Toolkit::Control *argp2 ;
55832   bool result;
55833
55834   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55835   argp2 = (Dali::Toolkit::Control *)jarg2;
55836   if (!argp2) {
55837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55838     return 0;
55839   }
55840   arg2 = *argp2;
55841   arg3 = (Dali::KeyEvent *)jarg3;
55842   if (!arg3) {
55843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55844     return 0;
55845   }
55846   {
55847     try {
55848       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::KeyEvent const &)*arg3);
55849     } CALL_CATCH_EXCEPTION(0);
55850   }
55851
55852   jresult = result;
55853   return jresult;
55854 }
55855
55856
55857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
55858   void * jresult ;
55859   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
55860
55861   {
55862     try {
55863       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
55864     } CALL_CATCH_EXCEPTION(0);
55865   }
55866
55867   jresult = (void *)result;
55868   return jresult;
55869 }
55870
55871
55872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
55873   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55874
55875   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55876   {
55877     try {
55878       delete arg1;
55879     } CALL_CATCH_EXCEPTION();
55880   }
55881
55882 }
55883
55884
55885 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
55886   bool jresult ;
55887   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55888   bool result;
55889
55890   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55891   {
55892     try {
55893       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55894     } CALL_CATCH_EXCEPTION(0);
55895   }
55896
55897   jresult = result;
55898   return jresult;
55899 }
55900
55901
55902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
55903   unsigned long jresult ;
55904   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55905   std::size_t result;
55906
55907   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55908   {
55909     try {
55910       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55911     } CALL_CATCH_EXCEPTION(0);
55912   }
55913
55914   jresult = (unsigned long)result;
55915   return jresult;
55916 }
55917
55918
55919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
55920   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55921   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55922
55923   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55924   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55925   {
55926     try {
55927       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
55928     } CALL_CATCH_EXCEPTION();
55929   }
55930
55931 }
55932
55933
55934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
55935   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55936   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55937
55938   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55939   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55940   {
55941     try {
55942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
55943     } CALL_CATCH_EXCEPTION();
55944   }
55945
55946 }
55947
55948
55949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
55950   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55951   Dali::Toolkit::Control arg2 ;
55952   Dali::Toolkit::Control *argp2 ;
55953
55954   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55955   argp2 = (Dali::Toolkit::Control *)jarg2;
55956   if (!argp2) {
55957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55958     return ;
55959   }
55960   arg2 = *argp2;
55961   {
55962     try {
55963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55964     } CALL_CATCH_EXCEPTION();
55965   }
55966
55967 }
55968
55969
55970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55971   void * jresult ;
55972   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55973
55974   {
55975     try {
55976       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55977     } CALL_CATCH_EXCEPTION(0);
55978   }
55979
55980   jresult = (void *)result;
55981   return jresult;
55982 }
55983
55984
55985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55986   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55987
55988   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55989   {
55990     try {
55991       delete arg1;
55992     } CALL_CATCH_EXCEPTION();
55993   }
55994
55995 }
55996
55997
55998 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55999   bool jresult ;
56000   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56001   bool result;
56002
56003   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56004   {
56005     try {
56006       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
56007     } CALL_CATCH_EXCEPTION(0);
56008   }
56009
56010   jresult = result;
56011   return jresult;
56012 }
56013
56014
56015 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
56016   unsigned long jresult ;
56017   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56018   std::size_t result;
56019
56020   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56021   {
56022     try {
56023       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
56024     } CALL_CATCH_EXCEPTION(0);
56025   }
56026
56027   jresult = (unsigned long)result;
56028   return jresult;
56029 }
56030
56031
56032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
56033   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56034   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
56035
56036   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56037   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
56038   {
56039     try {
56040       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
56041     } CALL_CATCH_EXCEPTION();
56042   }
56043
56044 }
56045
56046
56047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
56048   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56049   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
56050
56051   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56052   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
56053   {
56054     try {
56055       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
56056     } CALL_CATCH_EXCEPTION();
56057   }
56058
56059 }
56060
56061
56062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
56063   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56064   Dali::Toolkit::VideoView *arg2 = 0 ;
56065
56066   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56067   arg2 = (Dali::Toolkit::VideoView *)jarg2;
56068   if (!arg2) {
56069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
56070     return ;
56071   }
56072   {
56073     try {
56074       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
56075     } CALL_CATCH_EXCEPTION();
56076   }
56077
56078 }
56079
56080
56081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
56082   void * jresult ;
56083   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
56084
56085   {
56086     try {
56087       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
56088     } CALL_CATCH_EXCEPTION(0);
56089   }
56090
56091   jresult = (void *)result;
56092   return jresult;
56093 }
56094
56095
56096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
56097   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
56098
56099   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
56100   {
56101     try {
56102       delete arg1;
56103     } CALL_CATCH_EXCEPTION();
56104   }
56105
56106 }
56107
56108
56109 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
56110   bool jresult ;
56111   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56112   bool result;
56113
56114   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56115   {
56116     try {
56117       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
56118     } CALL_CATCH_EXCEPTION(0);
56119   }
56120
56121   jresult = result;
56122   return jresult;
56123 }
56124
56125
56126 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
56127   unsigned long jresult ;
56128   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56129   std::size_t result;
56130
56131   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56132   {
56133     try {
56134       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
56135     } CALL_CATCH_EXCEPTION(0);
56136   }
56137
56138   jresult = (unsigned long)result;
56139   return jresult;
56140 }
56141
56142
56143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
56144   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56145   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
56146
56147   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56148   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
56149   {
56150     try {
56151       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
56152     } CALL_CATCH_EXCEPTION();
56153   }
56154
56155 }
56156
56157
56158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56159   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56160   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
56161
56162   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56163   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
56164   {
56165     try {
56166       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
56167     } CALL_CATCH_EXCEPTION();
56168   }
56169
56170 }
56171
56172
56173 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
56174   bool jresult ;
56175   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56176   Dali::Toolkit::Slider arg2 ;
56177   float arg3 ;
56178   Dali::Toolkit::Slider *argp2 ;
56179   bool result;
56180
56181   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56182   argp2 = (Dali::Toolkit::Slider *)jarg2;
56183   if (!argp2) {
56184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
56185     return 0;
56186   }
56187   arg2 = *argp2;
56188   arg3 = (float)jarg3;
56189   {
56190     try {
56191       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
56192     } CALL_CATCH_EXCEPTION(0);
56193   }
56194
56195   jresult = result;
56196   return jresult;
56197 }
56198
56199
56200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
56201   void * jresult ;
56202   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
56203
56204   {
56205     try {
56206       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
56207     } CALL_CATCH_EXCEPTION(0);
56208   }
56209
56210   jresult = (void *)result;
56211   return jresult;
56212 }
56213
56214
56215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
56216   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
56217
56218   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
56219   {
56220     try {
56221       delete arg1;
56222     } CALL_CATCH_EXCEPTION();
56223   }
56224
56225 }
56226
56227
56228 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
56229   bool jresult ;
56230   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56231   bool result;
56232
56233   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56234   {
56235     try {
56236       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
56237     } CALL_CATCH_EXCEPTION(0);
56238   }
56239
56240   jresult = result;
56241   return jresult;
56242 }
56243
56244
56245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
56246   unsigned long jresult ;
56247   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56248   std::size_t result;
56249
56250   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56251   {
56252     try {
56253       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
56254     } CALL_CATCH_EXCEPTION(0);
56255   }
56256
56257   jresult = (unsigned long)result;
56258   return jresult;
56259 }
56260
56261
56262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
56263   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56264   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
56265
56266   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56267   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
56268   {
56269     try {
56270       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
56271     } CALL_CATCH_EXCEPTION();
56272   }
56273
56274 }
56275
56276
56277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
56278   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56279   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
56280
56281   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56282   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
56283   {
56284     try {
56285       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
56286     } CALL_CATCH_EXCEPTION();
56287   }
56288
56289 }
56290
56291
56292 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
56293   bool jresult ;
56294   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56295   Dali::Toolkit::Slider arg2 ;
56296   int arg3 ;
56297   Dali::Toolkit::Slider *argp2 ;
56298   bool result;
56299
56300   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56301   argp2 = (Dali::Toolkit::Slider *)jarg2;
56302   if (!argp2) {
56303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
56304     return 0;
56305   }
56306   arg2 = *argp2;
56307   arg3 = (int)jarg3;
56308   {
56309     try {
56310       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
56311     } CALL_CATCH_EXCEPTION(0);
56312   }
56313
56314   jresult = result;
56315   return jresult;
56316 }
56317
56318
56319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
56320   void * jresult ;
56321   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
56322
56323   {
56324     try {
56325       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
56326     } CALL_CATCH_EXCEPTION(0);
56327   }
56328
56329   jresult = (void *)result;
56330   return jresult;
56331 }
56332
56333
56334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
56335   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
56336
56337   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
56338   {
56339     try {
56340       delete arg1;
56341     } CALL_CATCH_EXCEPTION();
56342   }
56343
56344 }
56345
56346
56347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
56348   void * jresult ;
56349   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56350
56351   {
56352     try {
56353       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
56354     } CALL_CATCH_EXCEPTION(0);
56355   }
56356
56357   jresult = (void *)result;
56358   return jresult;
56359 }
56360
56361
56362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
56363   void * jresult ;
56364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
56365   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56366
56367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
56368   {
56369     try {
56370       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
56371     } CALL_CATCH_EXCEPTION(0);
56372   }
56373
56374   jresult = (void *)result;
56375   return jresult;
56376 }
56377
56378
56379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
56380   void * jresult ;
56381   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
56382   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56383
56384   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56385   if (!arg1) {
56386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
56387     return 0;
56388   }
56389   {
56390     try {
56391       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
56392     } CALL_CATCH_EXCEPTION(0);
56393   }
56394
56395   jresult = (void *)result;
56396   return jresult;
56397 }
56398
56399
56400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
56401   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56402
56403   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56404   {
56405     try {
56406       delete arg1;
56407     } CALL_CATCH_EXCEPTION();
56408   }
56409
56410 }
56411
56412
56413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
56414   void * jresult ;
56415   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56416   Dali::Toolkit::Ruler *result = 0 ;
56417
56418   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56419   {
56420     try {
56421       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
56422     } CALL_CATCH_EXCEPTION(0);
56423   }
56424
56425   jresult = (void *)result;
56426   return jresult;
56427 }
56428
56429
56430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
56431   void * jresult ;
56432   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56433   Dali::Toolkit::Ruler *result = 0 ;
56434
56435   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56436   {
56437     try {
56438       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
56439     } CALL_CATCH_EXCEPTION(0);
56440   }
56441
56442   jresult = (void *)result;
56443   return jresult;
56444 }
56445
56446
56447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
56448   void * jresult ;
56449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56450   Dali::Toolkit::Ruler *result = 0 ;
56451
56452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56453   {
56454     try {
56455       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
56456     } CALL_CATCH_EXCEPTION(0);
56457   }
56458
56459   jresult = (void *)result;
56460   return jresult;
56461 }
56462
56463
56464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
56465   void * jresult ;
56466   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56467   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
56468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56469
56470   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56471   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
56472   if (!arg2) {
56473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
56474     return 0;
56475   }
56476   {
56477     try {
56478       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
56479     } CALL_CATCH_EXCEPTION(0);
56480   }
56481
56482   jresult = (void *)result;
56483   return jresult;
56484 }
56485
56486
56487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
56488   void * jresult ;
56489   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56490   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
56491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
56492
56493   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56494   arg2 = (Dali::Toolkit::Ruler *)jarg2;
56495   {
56496     try {
56497       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
56498     } CALL_CATCH_EXCEPTION(0);
56499   }
56500
56501   jresult = (void *)result;
56502   return jresult;
56503 }
56504
56505
56506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
56507   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56508
56509   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56510   {
56511     try {
56512       (arg1)->Reset();
56513     } CALL_CATCH_EXCEPTION();
56514   }
56515
56516 }
56517
56518
56519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
56520   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56521   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
56522
56523   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56524   arg2 = (Dali::Toolkit::Ruler *)jarg2;
56525   {
56526     try {
56527       (arg1)->Reset(arg2);
56528     } CALL_CATCH_EXCEPTION();
56529   }
56530
56531 }
56532
56533
56534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
56535   void * jresult ;
56536   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56537   Dali::Toolkit::Ruler *result = 0 ;
56538
56539   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56540   {
56541     try {
56542       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
56543     } CALL_CATCH_EXCEPTION(0);
56544   }
56545
56546   jresult = (void *)result;
56547   return jresult;
56548 }
56549
56550
56551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
56552   float jresult ;
56553   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56554   float arg2 ;
56555   float arg3 ;
56556   float result;
56557
56558   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56559   arg2 = (float)jarg2;
56560   arg3 = (float)jarg3;
56561   {
56562     try {
56563       result = (float)(*arg1)->Snap(arg2,arg3);
56564     } CALL_CATCH_EXCEPTION(0);
56565   }
56566
56567   jresult = result;
56568   return jresult;
56569 }
56570
56571
56572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
56573   float jresult ;
56574   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56575   float arg2 ;
56576   float result;
56577
56578   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56579   arg2 = (float)jarg2;
56580   {
56581     try {
56582       result = (float)(*arg1)->Snap(arg2);
56583     } CALL_CATCH_EXCEPTION(0);
56584   }
56585
56586   jresult = result;
56587   return jresult;
56588 }
56589
56590
56591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) {
56592   float jresult ;
56593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56594   unsigned int arg2 ;
56595   unsigned int *arg3 = 0 ;
56596   bool arg4 ;
56597   float result;
56598
56599   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56600   arg2 = (unsigned int)jarg2;
56601   arg3 = (unsigned int *)jarg3;
56602   arg4 = jarg4 ? true : false;
56603   {
56604     try {
56605       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
56606     } CALL_CATCH_EXCEPTION(0);
56607   }
56608
56609   jresult = result;
56610   return jresult;
56611 }
56612
56613
56614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) {
56615   unsigned int jresult ;
56616   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56617   float arg2 ;
56618   bool arg3 ;
56619   unsigned int result;
56620
56621   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56622   arg2 = (float)jarg2;
56623   arg3 = jarg3 ? true : false;
56624   {
56625     try {
56626       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
56627     } CALL_CATCH_EXCEPTION(0);
56628   }
56629
56630   jresult = result;
56631   return jresult;
56632 }
56633
56634
56635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
56636   unsigned int jresult ;
56637   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56638   unsigned int result;
56639
56640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56641   {
56642     try {
56643       result = (unsigned int)(*arg1)->GetTotalPages();
56644     } CALL_CATCH_EXCEPTION(0);
56645   }
56646
56647   jresult = result;
56648   return jresult;
56649 }
56650
56651
56652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
56653   int jresult ;
56654   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56655   Dali::Toolkit::Ruler::RulerType result;
56656
56657   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56658   {
56659     try {
56660       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
56661     } CALL_CATCH_EXCEPTION(0);
56662   }
56663
56664   jresult = (int)result;
56665   return jresult;
56666 }
56667
56668
56669 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
56670   bool jresult ;
56671   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56672   bool result;
56673
56674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56675   {
56676     try {
56677       result = (bool)(*arg1)->IsEnabled();
56678     } CALL_CATCH_EXCEPTION(0);
56679   }
56680
56681   jresult = result;
56682   return jresult;
56683 }
56684
56685
56686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
56687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56688
56689   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56690   {
56691     try {
56692       (*arg1)->Enable();
56693     } CALL_CATCH_EXCEPTION();
56694   }
56695
56696 }
56697
56698
56699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
56700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56701
56702   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56703   {
56704     try {
56705       (*arg1)->Disable();
56706     } CALL_CATCH_EXCEPTION();
56707   }
56708
56709 }
56710
56711
56712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
56713   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56714   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
56715   Dali::Toolkit::RulerDomain *argp2 ;
56716
56717   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56718   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
56719   if (!argp2) {
56720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
56721     return ;
56722   }
56723   arg2 = *argp2;
56724   {
56725     try {
56726       (*arg1)->SetDomain(arg2);
56727     } CALL_CATCH_EXCEPTION();
56728   }
56729
56730 }
56731
56732
56733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
56734   void * jresult ;
56735   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56736   Dali::Toolkit::RulerDomain *result = 0 ;
56737
56738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56739   {
56740     try {
56741       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
56742     } CALL_CATCH_EXCEPTION(0);
56743   }
56744
56745   jresult = (void *)result;
56746   return jresult;
56747 }
56748
56749
56750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
56751   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56752
56753   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56754   {
56755     try {
56756       (*arg1)->DisableDomain();
56757     } CALL_CATCH_EXCEPTION();
56758   }
56759
56760 }
56761
56762
56763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
56764   float jresult ;
56765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56766   float arg2 ;
56767   float arg3 ;
56768   float arg4 ;
56769   float result;
56770
56771   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56772   arg2 = (float)jarg2;
56773   arg3 = (float)jarg3;
56774   arg4 = (float)jarg4;
56775   {
56776     try {
56777       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
56778     } CALL_CATCH_EXCEPTION(0);
56779   }
56780
56781   jresult = result;
56782   return jresult;
56783 }
56784
56785
56786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
56787   float jresult ;
56788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56789   float arg2 ;
56790   float arg3 ;
56791   float result;
56792
56793   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56794   arg2 = (float)jarg2;
56795   arg3 = (float)jarg3;
56796   {
56797     try {
56798       result = (float)(*arg1)->Clamp(arg2,arg3);
56799     } CALL_CATCH_EXCEPTION(0);
56800   }
56801
56802   jresult = result;
56803   return jresult;
56804 }
56805
56806
56807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
56808   float jresult ;
56809   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56810   float arg2 ;
56811   float result;
56812
56813   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56814   arg2 = (float)jarg2;
56815   {
56816     try {
56817       result = (float)(*arg1)->Clamp(arg2);
56818     } CALL_CATCH_EXCEPTION(0);
56819   }
56820
56821   jresult = result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
56827   float jresult ;
56828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56829   float arg2 ;
56830   float arg3 ;
56831   float arg4 ;
56832   Dali::Toolkit::ClampState *arg5 = 0 ;
56833   float result;
56834
56835   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56836   arg2 = (float)jarg2;
56837   arg3 = (float)jarg3;
56838   arg4 = (float)jarg4;
56839   arg5 = (Dali::Toolkit::ClampState *)jarg5;
56840   if (!arg5) {
56841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56842     return 0;
56843   }
56844   {
56845     try {
56846       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
56847     } CALL_CATCH_EXCEPTION(0);
56848   }
56849
56850   jresult = result;
56851   return jresult;
56852 }
56853
56854
56855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
56856   float jresult ;
56857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56858   float arg2 ;
56859   float arg3 ;
56860   float arg4 ;
56861   float arg5 ;
56862   float result;
56863
56864   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56865   arg2 = (float)jarg2;
56866   arg3 = (float)jarg3;
56867   arg4 = (float)jarg4;
56868   arg5 = (float)jarg5;
56869   {
56870     try {
56871       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
56872     } CALL_CATCH_EXCEPTION(0);
56873   }
56874
56875   jresult = result;
56876   return jresult;
56877 }
56878
56879
56880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
56881   float jresult ;
56882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56883   float arg2 ;
56884   float arg3 ;
56885   float arg4 ;
56886   float result;
56887
56888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56889   arg2 = (float)jarg2;
56890   arg3 = (float)jarg3;
56891   arg4 = (float)jarg4;
56892   {
56893     try {
56894       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
56895     } CALL_CATCH_EXCEPTION(0);
56896   }
56897
56898   jresult = result;
56899   return jresult;
56900 }
56901
56902
56903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
56904   float jresult ;
56905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56906   float arg2 ;
56907   float arg3 ;
56908   float result;
56909
56910   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56911   arg2 = (float)jarg2;
56912   arg3 = (float)jarg3;
56913   {
56914     try {
56915       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
56916     } CALL_CATCH_EXCEPTION(0);
56917   }
56918
56919   jresult = result;
56920   return jresult;
56921 }
56922
56923
56924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
56925   float jresult ;
56926   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56927   float arg2 ;
56928   float result;
56929
56930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56931   arg2 = (float)jarg2;
56932   {
56933     try {
56934       result = (float)(*arg1)->SnapAndClamp(arg2);
56935     } CALL_CATCH_EXCEPTION(0);
56936   }
56937
56938   jresult = result;
56939   return jresult;
56940 }
56941
56942
56943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
56944   float jresult ;
56945   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56946   float arg2 ;
56947   float arg3 ;
56948   float arg4 ;
56949   float arg5 ;
56950   Dali::Toolkit::ClampState *arg6 = 0 ;
56951   float result;
56952
56953   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56954   arg2 = (float)jarg2;
56955   arg3 = (float)jarg3;
56956   arg4 = (float)jarg4;
56957   arg5 = (float)jarg5;
56958   arg6 = (Dali::Toolkit::ClampState *)jarg6;
56959   if (!arg6) {
56960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56961     return 0;
56962   }
56963   {
56964     try {
56965       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56966     } CALL_CATCH_EXCEPTION(0);
56967   }
56968
56969   jresult = result;
56970   return jresult;
56971 }
56972
56973
56974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56976
56977   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56978   {
56979     try {
56980       (*arg1)->Reference();
56981     } CALL_CATCH_EXCEPTION();
56982   }
56983
56984 }
56985
56986
56987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56989
56990   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56991   {
56992     try {
56993       (*arg1)->Unreference();
56994     } CALL_CATCH_EXCEPTION();
56995   }
56996
56997 }
56998
56999
57000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
57001   int jresult ;
57002   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
57003   int result;
57004
57005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
57006   {
57007     try {
57008       result = (int)(*arg1)->ReferenceCount();
57009     } CALL_CATCH_EXCEPTION(0);
57010   }
57011
57012   jresult = result;
57013   return jresult;
57014 }
57015
57016
57017 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
57018   bool jresult ;
57019   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57020   bool result;
57021
57022   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57023   {
57024     try {
57025       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57026     } CALL_CATCH_EXCEPTION(0);
57027   }
57028
57029   jresult = result;
57030   return jresult;
57031 }
57032
57033
57034 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
57035   unsigned long jresult ;
57036   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57037   std::size_t result;
57038
57039   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57040   {
57041     try {
57042       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
57043     } CALL_CATCH_EXCEPTION(0);
57044   }
57045
57046   jresult = (unsigned long)result;
57047   return jresult;
57048 }
57049
57050
57051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
57052   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57053   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57054
57055   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57056   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57057   {
57058     try {
57059       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
57060     } CALL_CATCH_EXCEPTION();
57061   }
57062
57063 }
57064
57065
57066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
57067   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57068   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
57069
57070   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57071   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
57072   {
57073     try {
57074       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
57075     } CALL_CATCH_EXCEPTION();
57076   }
57077
57078 }
57079
57080
57081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
57082   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57083   Dali::Toolkit::Control arg2 ;
57084   Dali::Toolkit::Control *argp2 ;
57085
57086   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57087   argp2 = (Dali::Toolkit::Control *)jarg2;
57088   if (!argp2) {
57089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
57090     return ;
57091   }
57092   arg2 = *argp2;
57093   {
57094     try {
57095       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
57096     } CALL_CATCH_EXCEPTION();
57097   }
57098
57099 }
57100
57101
57102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
57103   void * jresult ;
57104   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
57105
57106   {
57107     try {
57108       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
57109     } CALL_CATCH_EXCEPTION(0);
57110   }
57111
57112   jresult = (void *)result;
57113   return jresult;
57114 }
57115
57116
57117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
57118   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
57119
57120   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
57121   {
57122     try {
57123       delete arg1;
57124     } CALL_CATCH_EXCEPTION();
57125   }
57126
57127 }
57128
57129 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
57130   Dali::RefObject *result = NULL;
57131
57132   if (arg1)
57133   {
57134     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
57135   }
57136   return result;
57137 }
57138
57139 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
57140     return (Dali::RefObject *)jarg1;
57141 }
57142
57143 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
57144     return (Dali::SignalObserver *)jarg1;
57145 }
57146
57147 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
57148     return (Dali::ConnectionTrackerInterface *)jarg1;
57149 }
57150
57151 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
57152     return (Dali::BaseHandle *)jarg1;
57153 }
57154
57155 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
57156     return (Dali::BaseHandle *)jarg1;
57157 }
57158
57159 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
57160     return (Dali::BaseHandle *)jarg1;
57161 }
57162
57163 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
57164     return (Dali::BaseHandle *)jarg1;
57165 }
57166
57167 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
57168     return (Dali::BaseHandle *)jarg1;
57169 }
57170
57171 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
57172     return (Dali::BaseHandle *)jarg1;
57173 }
57174
57175 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
57176     return (Dali::BaseHandle *)jarg1;
57177 }
57178
57179 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
57180     return (Dali::BaseHandle *)jarg1;
57181 }
57182
57183 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
57184     return (Dali::BaseHandle *)jarg1;
57185 }
57186
57187 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
57188     return (Dali::BaseHandle *)jarg1;
57189 }
57190
57191 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
57192     return (Dali::BaseHandle *)jarg1;
57193 }
57194
57195 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
57196     return (Dali::BaseHandle *)jarg1;
57197 }
57198
57199 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
57200     return (Dali::Handle *)jarg1;
57201 }
57202
57203 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
57204     return (Dali::Handle *)jarg1;
57205 }
57206
57207 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
57208     return (Dali::BaseHandle *)jarg1;
57209 }
57210
57211 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
57212     return (Dali::BaseHandle *)jarg1;
57213 }
57214
57215 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
57216     return (Dali::Handle *)jarg1;
57217 }
57218
57219 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
57220     return (Dali::BaseHandle *)jarg1;
57221 }
57222
57223 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
57224     return (Dali::BaseHandle *)jarg1;
57225 }
57226
57227 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
57228     return (Dali::BaseHandle *)jarg1;
57229 }
57230
57231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
57232     return (Dali::BaseHandle *)jarg1;
57233 }
57234
57235 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
57236     return (Dali::BaseHandle *)jarg1;
57237 }
57238
57239 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
57240     return (Dali::Handle *)jarg1;
57241 }
57242
57243 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
57244     return (Dali::GestureDetector *)jarg1;
57245 }
57246
57247 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
57248     return (Dali::Gesture *)jarg1;
57249 }
57250
57251 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
57252     return (Dali::Handle *)jarg1;
57253 }
57254
57255 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
57256     return (Dali::Actor *)jarg1;
57257 }
57258
57259 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
57260     return (Dali::RefObject *)jarg1;
57261 }
57262
57263 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
57264     return (Dali::Actor *)jarg1;
57265 }
57266
57267 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
57268     return (Dali::GestureDetector *)jarg1;
57269 }
57270
57271 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
57272     return (Dali::Gesture *)jarg1;
57273 }
57274
57275 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
57276     return (Dali::GestureDetector *)jarg1;
57277 }
57278
57279 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
57280     return (Dali::Gesture *)jarg1;
57281 }
57282
57283 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
57284     return (Dali::GestureDetector *)jarg1;
57285 }
57286
57287 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
57288     return (Dali::Gesture *)jarg1;
57289 }
57290
57291 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
57292     return (Dali::BaseHandle *)jarg1;
57293 }
57294
57295 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
57296     return (Dali::Handle *)jarg1;
57297 }
57298
57299 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
57300     return (Dali::Handle *)jarg1;
57301 }
57302
57303 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
57304     return (Dali::Handle *)jarg1;
57305 }
57306
57307 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
57308     return (Dali::RefObject *)jarg1;
57309 }
57310
57311 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
57312     return (Dali::Actor *)jarg1;
57313 }
57314
57315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
57316     return (Dali::BaseHandle *)jarg1;
57317 }
57318
57319 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
57320     return (Dali::BaseHandle *)jarg1;
57321 }
57322
57323 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
57324     return (Dali::BaseHandle *)jarg1;
57325 }
57326
57327 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
57328     return (Dali::CustomActorImpl *)jarg1;
57329 }
57330
57331 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
57332     return (Dali::CustomActor *)jarg1;
57333 }
57334
57335 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
57336     return (Dali::BaseHandle *)jarg1;
57337 }
57338
57339 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
57340     return (Dali::Toolkit::Control *)jarg1;
57341 }
57342
57343 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
57344     return (Dali::Toolkit::Control *)jarg1;
57345 }
57346
57347 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
57348     return (Dali::Toolkit::Button *)jarg1;
57349 }
57350
57351 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
57352     return (Dali::Toolkit::Button *)jarg1;
57353 }
57354
57355 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
57356     return (Dali::Toolkit::Button *)jarg1;
57357 }
57358
57359 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
57360     return (Dali::Toolkit::Control *)jarg1;
57361 }
57362
57363 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
57364     return (Dali::Toolkit::Control *)jarg1;
57365 }
57366
57367 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
57368     return (Dali::Toolkit::Control *)jarg1;
57369 }
57370
57371 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
57372     return (Dali::Toolkit::Control *)jarg1;
57373 }
57374
57375 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
57376     return (Dali::Toolkit::Control *)jarg1;
57377 }
57378
57379 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
57380     return (Dali::RefObject *)jarg1;
57381 }
57382
57383 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
57384     return (Dali::Toolkit::Scrollable *)jarg1;
57385 }
57386
57387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
57388     return (Dali::BaseHandle *)jarg1;
57389 }
57390
57391 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
57392     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
57393 }
57394
57395 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
57396     return (Dali::RefObject *)jarg1;
57397 }
57398
57399 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
57400     return (Dali::Toolkit::Ruler *)jarg1;
57401 }
57402
57403 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
57404     return (Dali::Toolkit::Ruler *)jarg1;
57405 }
57406
57407 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
57408     return (Dali::Toolkit::Scrollable *)jarg1;
57409 }
57410
57411 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
57412     return (Dali::Toolkit::Control *)jarg1;
57413 }
57414
57415
57416 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
57417     return (Dali::Toolkit::Control *)jarg1;
57418 }
57419
57420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
57421     return (Dali::BaseHandle *)jarg1;
57422 }
57423
57424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
57425     return (Dali::BaseHandle *)jarg1;
57426 }
57427
57428 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
57429     return (Dali::Toolkit::Control *)jarg1;
57430 }
57431
57432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
57433     return (Dali::Toolkit::Control *)jarg1;
57434 }
57435
57436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) {
57437     return (Dali::Toolkit::Control *)jarg1;
57438 }
57439
57440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
57441     return (Dali::Toolkit::Control *)jarg1;
57442 }
57443
57444 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
57445     return (Dali::Toolkit::Control *)jarg1;
57446 }
57447
57448 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
57449     return (Dali::Toolkit::Control *)jarg1;
57450 }
57451
57452 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
57453     return (Dali::Toolkit::Control *)jarg1;
57454 }
57455
57456 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
57457     return (Dali::Toolkit::PageTurnView *)jarg1;
57458 }
57459
57460 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
57461     return (Dali::Toolkit::PageTurnView *)jarg1;
57462 }
57463
57464 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
57465     return (Dali::Toolkit::Button *)jarg1;
57466 }
57467
57468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
57469     return (Dali::BaseHandle *)jarg1;
57470 }
57471
57472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
57473     return (Dali::BaseHandle *)jarg1;
57474 }
57475
57476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
57477     return (Dali::BaseHandle *)jarg1;
57478 }
57479
57480 /*
57481  * Widget binding
57482  */
57483 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
57484     return (Dali::BaseHandle *)jarg1;
57485 }
57486
57487 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
57488     return (Dali::BaseObject *)jarg1;
57489 }
57490
57491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
57492   void * jresult ;
57493   Dali::Widget result;
57494
57495   {
57496     try {
57497       result = Dali::Widget::New();
57498     } CALL_CATCH_EXCEPTION(0);
57499   }
57500
57501   jresult = new Dali::Widget((const Dali::Widget &)result);
57502   return jresult;
57503 }
57504
57505
57506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
57507   void * jresult ;
57508   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
57509   Dali::Widget result;
57510
57511   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57512
57513   if (!arg1) {
57514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
57515     return 0;
57516   }
57517   {
57518     try {
57519       jresult = new Dali::Widget(arg1);
57520     } CALL_CATCH_EXCEPTION(0);
57521   }
57522   return jresult;
57523 }
57524
57525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
57526   void * jresult ;
57527   Dali::Widget *result = 0 ;
57528
57529   {
57530     try {
57531       result = (Dali::Widget *)new Dali::Widget();
57532     } CALL_CATCH_EXCEPTION(0);
57533   }
57534   jresult = (void *)result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
57540   void * jresult ;
57541   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
57542   Dali::Widget *arg2 = 0 ;
57543   Dali::Widget *result = 0 ;
57544
57545   arg1 = (Dali::Widget *)jarg1;
57546   arg2 = (Dali::Widget *)jarg2;
57547   if (!arg2) {
57548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
57549     return 0;
57550   }
57551   {
57552     try {
57553       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
57554     } CALL_CATCH_EXCEPTION(0);
57555   }
57556   jresult = (void *)result;
57557   return jresult;
57558 }
57559
57560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
57561   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
57562
57563   arg1 = (Dali::Widget *)jarg1;
57564   {
57565     try {
57566       delete arg1;
57567     } CALL_CATCH_EXCEPTION();
57568   }
57569 }
57570
57571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
57572   void * jresult ;
57573   SwigDirector_WidgetImpl* result;
57574   {
57575     try {
57576       result = new SwigDirector_WidgetImpl();
57577     } CALL_CATCH_EXCEPTION(0);
57578   }
57579   jresult = result;
57580   return jresult;
57581 }
57582
57583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
57584   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57585   std::string *arg2 = 0 ;
57586   Dali::Window arg3 ;
57587   Dali::Window *argp3 ;
57588
57589   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57590   if (!jarg2) {
57591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57592     return ;
57593   }
57594   std::string arg2_str(jarg2);
57595   arg2 = &arg2_str;
57596   argp3 = (Dali::Window *)jarg3;
57597   if (!argp3) {
57598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57599     return ;
57600   }
57601   arg3 = *argp3;
57602   {
57603     try {
57604       (arg1)->OnCreate((std::string const &)*arg2,arg3);
57605     } CALL_CATCH_EXCEPTION();
57606   }
57607 }
57608
57609
57610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
57611   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57612   std::string *arg2 = 0 ;
57613   Dali::Window arg3 ;
57614   Dali::Window *argp3 ;
57615
57616   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57617   if (!jarg2) {
57618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57619     return ;
57620   }
57621   std::string arg2_str(jarg2);
57622   arg2 = &arg2_str;
57623   argp3 = (Dali::Window *)jarg3;
57624   if (!argp3) {
57625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57626     return ;
57627   }
57628   arg3 = *argp3;
57629   {
57630     try {
57631       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
57632     } CALL_CATCH_EXCEPTION();
57633   }
57634 }
57635
57636
57637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
57638   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57639   std::string *arg2 = 0 ;
57640   Dali::Widget::Termination arg3 ;
57641
57642   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57643   if (!jarg2) {
57644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57645     return ;
57646   }
57647   std::string arg2_str(jarg2);
57648   arg2 = &arg2_str;
57649   arg3 = (Dali::Widget::Termination)jarg3;
57650   {
57651     try {
57652       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
57653     } CALL_CATCH_EXCEPTION();
57654   }
57655 }
57656
57657
57658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57659   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57660   std::string *arg2 = 0 ;
57661   Dali::Widget::Termination arg3 ;
57662
57663   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57664   if (!jarg2) {
57665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57666     return ;
57667   }
57668   std::string arg2_str(jarg2);
57669   arg2 = &arg2_str;
57670   arg3 = (Dali::Widget::Termination)jarg3;
57671   {
57672     try {
57673       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
57674     } CALL_CATCH_EXCEPTION();
57675   }
57676 }
57677
57678
57679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
57680   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57681
57682   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57683   {
57684     try {
57685       (arg1)->OnPause();
57686     } CALL_CATCH_EXCEPTION();
57687   }
57688 }
57689
57690
57691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
57692   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57693
57694   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57695   {
57696     try {
57697       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
57698     } CALL_CATCH_EXCEPTION();
57699   }
57700 }
57701
57702
57703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
57704   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57705
57706   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57707   {
57708     try {
57709       (arg1)->OnResume();
57710     } CALL_CATCH_EXCEPTION();
57711   }
57712 }
57713
57714
57715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
57716   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57717
57718   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57719   {
57720     try {
57721       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
57722     } CALL_CATCH_EXCEPTION();
57723   }
57724 }
57725
57726
57727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
57728   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57729   Dali::Window arg2 ;
57730   Dali::Window *argp2 ;
57731
57732   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57733   argp2 = (Dali::Window *)jarg2;
57734   if (!argp2) {
57735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57736     return ;
57737   }
57738   arg2 = *argp2;
57739   {
57740     try {
57741       (arg1)->OnResize(arg2);
57742     } CALL_CATCH_EXCEPTION();
57743   }
57744 }
57745
57746
57747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
57748   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57749   Dali::Window arg2 ;
57750   Dali::Window *argp2 ;
57751
57752   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57753   argp2 = (Dali::Window *)jarg2;
57754   if (!argp2) {
57755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57756     return ;
57757   }
57758   arg2 = *argp2;
57759   {
57760     try {
57761       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
57762     } CALL_CATCH_EXCEPTION();
57763   }
57764 }
57765
57766
57767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
57768   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57769   std::string *arg2 = 0 ;
57770   int arg3 ;
57771
57772   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57773   if (!jarg2) {
57774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57775     return ;
57776   }
57777   std::string arg2_str(jarg2);
57778   arg2 = &arg2_str;
57779   arg3 = (int)jarg3;
57780   {
57781     try {
57782       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
57783     } CALL_CATCH_EXCEPTION();
57784   }
57785 }
57786
57787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57788   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57789   std::string *arg2 = 0 ;
57790   int arg3 ;
57791
57792   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57793   if (!jarg2) {
57794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57795     return ;
57796   }
57797   std::string arg2_str(jarg2);
57798   arg2 = &arg2_str;
57799   arg3 = (int)jarg3;
57800   {
57801     try {
57802       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
57803     } CALL_CATCH_EXCEPTION();
57804   }
57805 }
57806
57807
57808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57809   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57810   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57811   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57812
57813   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57814   arg2 = (Dali::SlotObserver *)jarg2;
57815   arg3 = (Dali::CallbackBase *)jarg3;
57816   {
57817     try {
57818       (arg1)->SignalConnected(arg2,arg3);
57819     } CALL_CATCH_EXCEPTION();
57820   }
57821 }
57822
57823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57824   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57825   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57826   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57827
57828   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57829   arg2 = (Dali::SlotObserver *)jarg2;
57830   arg3 = (Dali::CallbackBase *)jarg3;
57831   {
57832     try {
57833       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
57834     } CALL_CATCH_EXCEPTION();
57835   }
57836 }
57837
57838
57839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
57840   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57841   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57842   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57843
57844   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57845   arg2 = (Dali::SlotObserver *)jarg2;
57846   arg3 = (Dali::CallbackBase *)jarg3;
57847   {
57848     try {
57849       (arg1)->SignalDisconnected(arg2,arg3);
57850     } CALL_CATCH_EXCEPTION();
57851   }
57852 }
57853
57854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57855   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57856   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57857   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57858
57859   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57860   arg2 = (Dali::SlotObserver *)jarg2;
57861   arg3 = (Dali::CallbackBase *)jarg3;
57862   {
57863     try {
57864       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
57865     } CALL_CATCH_EXCEPTION();
57866   }
57867 }
57868
57869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
57870   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57871   std::string *arg2 = 0 ;
57872
57873   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57874   if (!jarg2) {
57875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57876     return ;
57877   }
57878   std::string arg2_str(jarg2);
57879   arg2 = &arg2_str;
57880   {
57881     try {
57882       (arg1)->SetContentInfo((std::string const &)*arg2);
57883     } CALL_CATCH_EXCEPTION();
57884   }
57885 }
57886
57887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
57888   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
57889   bool flag;
57890
57891   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
57892   flag = jflag ? true : false;
57893   {
57894     try {
57895       (widget)->SetUsingKeyEvent(flag);
57896     } CALL_CATCH_EXCEPTION();
57897   }
57898 }
57899
57900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
57901   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57902   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
57903
57904   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57905   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
57906   {
57907     try {
57908       (arg1)->SetImpl(arg2);
57909     } CALL_CATCH_EXCEPTION();
57910   }
57911 }
57912
57913
57914 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) {
57915   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
57916   if (director) {
57917     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
57918   }
57919 }
57920
57921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
57922   void * jresult ;
57923   Dali::Widget *arg1 = 0 ;
57924   SwigDirector_WidgetImpl *result = 0 ;
57925
57926   arg1 = (Dali::Widget *)jarg1;
57927   if (!arg1) {
57928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
57929     return 0;
57930   }
57931   {
57932     try {
57933       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
57934     } CALL_CATCH_EXCEPTION(0);
57935   }
57936   jresult = (void*) result;
57937   return jresult;
57938 }
57939
57940
57941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
57942   void * jresult ;
57943   int *arg1 = (int *) 0 ;
57944   char ***arg2 ;
57945   std::string *arg3 = 0 ;
57946   Dali::WidgetApplication result;
57947   {
57948     int index = 0;
57949     int length = 0;
57950     char *retPtr;
57951     char *nextPtr;
57952     argWidgetC = jarg1;
57953     argWidgetV = new char*[jarg1 + 1];
57954
57955     retPtr = strtok_r( jarg2, " ", &nextPtr);
57956     if( retPtr )
57957     {
57958       length = strlen(retPtr);
57959     }
57960     argWidgetV[index] = new char[length + 1];
57961     if( retPtr )
57962     {
57963       strncpy(argWidgetV[index], retPtr, length);
57964     }
57965     argWidgetV[index][length] = '\0';
57966     index++;
57967
57968     while (index < jarg1)
57969     {
57970       length = 0;
57971       retPtr = strtok_r(NULL, " ", &nextPtr);
57972       if( retPtr )
57973       {
57974         length = strlen(retPtr);
57975       }
57976       argWidgetV[index] = new char[length + 1];
57977       if( retPtr )
57978       {
57979         strncpy(argWidgetV[index], retPtr, length);
57980       }
57981       argWidgetV[index][length] = '\0';
57982       index++;
57983     }
57984
57985     argWidgetV[jarg1] = NULL;
57986     argWidgetC = jarg1;
57987
57988     arg1 = &argWidgetC;
57989     arg2 = &argWidgetV;
57990   }
57991
57992   if (!jarg3) {
57993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57994     return 0;
57995   }
57996   std::string arg3_str(jarg3);
57997   arg3 = &arg3_str;
57998   {
57999     try {
58000       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
58001     } CALL_CATCH_EXCEPTION(0);
58002   }
58003   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
58004   return jresult;
58005 }
58006
58007
58008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
58009   void * jresult ;
58010   Dali::WidgetApplication *result = 0 ;
58011
58012   {
58013     try {
58014       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
58015     } CALL_CATCH_EXCEPTION(0);
58016   }
58017   jresult = (void *)result;
58018   return jresult;
58019 }
58020
58021
58022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
58023   void * jresult ;
58024   Dali::WidgetApplication *arg1 = 0 ;
58025   Dali::WidgetApplication *result = 0 ;
58026
58027   arg1 = (Dali::WidgetApplication *)jarg1;
58028   if (!arg1) {
58029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
58030     return 0;
58031   }
58032   {
58033     try {
58034       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
58035     } CALL_CATCH_EXCEPTION(0);
58036   }
58037   jresult = (void *)result;
58038   return jresult;
58039 }
58040
58041
58042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
58043   void * jresult ;
58044   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58045   Dali::WidgetApplication *arg2 = 0 ;
58046   Dali::WidgetApplication *result = 0 ;
58047
58048   arg1 = (Dali::WidgetApplication *)jarg1;
58049   arg2 = (Dali::WidgetApplication *)jarg2;
58050   if (!arg2) {
58051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
58052     return 0;
58053   }
58054   {
58055     try {
58056       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
58057     } CALL_CATCH_EXCEPTION(0);
58058   }
58059   jresult = (void *)result;
58060   return jresult;
58061 }
58062
58063
58064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
58065   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58066
58067   arg1 = (Dali::WidgetApplication *)jarg1;
58068   {
58069     try {
58070       delete arg1;
58071       if( argWidgetV )
58072       {
58073         // free string data
58074         for( int i=0; i < argWidgetC+1; i++)
58075         {
58076           delete [] argWidgetV[i];
58077         }
58078         delete [] argWidgetV;
58079       }
58080     } CALL_CATCH_EXCEPTION();
58081   }
58082 }
58083
58084
58085 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
58086 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
58087
58088 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
58089 {
58090   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
58091   return *widget;
58092 }
58093
58094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
58095   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
58096   std::string *arg2 = 0 ;
58097
58098   arg1 = (Dali::WidgetApplication *)jarg1;
58099   if (!jarg2) {
58100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58101     return ;
58102   }
58103   std::string arg2_str(*jarg2);
58104   arg2 = &arg2_str;
58105
58106   if(!_CSharpCreateWidgetFunction)
58107   {
58108     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
58109   }
58110
58111   {
58112     try {
58113       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
58114     } CALL_CATCH_EXCEPTION();
58115   }
58116   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
58117 }
58118
58119
58120 //for PixelBuffer and ImageLoading
58121
58122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
58123     return (Dali::BaseHandle *)jarg1;
58124 }
58125
58126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
58127   void * jresult ;
58128   unsigned int arg1 ;
58129   unsigned int arg2 ;
58130   Dali::Pixel::Format arg3 ;
58131   Dali::Devel::PixelBuffer result;
58132
58133   arg1 = (unsigned int)jarg1;
58134   arg2 = (unsigned int)jarg2;
58135   arg3 = (Dali::Pixel::Format)jarg3;
58136   {
58137     try {
58138       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
58139     } CALL_CATCH_EXCEPTION(0);
58140   }
58141   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58142   return jresult;
58143 }
58144
58145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
58146   void * jresult ;
58147   Dali::Devel::PixelBuffer *result = 0 ;
58148
58149   {
58150     try {
58151       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
58152     } CALL_CATCH_EXCEPTION(0);
58153   }
58154   jresult = (void *)result;
58155   return jresult;
58156 }
58157
58158
58159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
58160   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58161
58162   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58163   {
58164     try {
58165       delete arg1;
58166     } CALL_CATCH_EXCEPTION();
58167   }
58168 }
58169
58170
58171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
58172   void * jresult ;
58173   Dali::Devel::PixelBuffer *arg1 = 0 ;
58174   Dali::Devel::PixelBuffer *result = 0 ;
58175
58176   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58177   if (!arg1) {
58178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
58179     return 0;
58180   }
58181   {
58182     try {
58183       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
58184     } CALL_CATCH_EXCEPTION(0);
58185   }
58186   jresult = (void *)result;
58187   return jresult;
58188 }
58189
58190
58191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
58192   void * jresult ;
58193   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58194   Dali::Devel::PixelBuffer *arg2 = 0 ;
58195   Dali::Devel::PixelBuffer *result = 0 ;
58196
58197   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58198   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
58199   if (!arg2) {
58200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
58201     return 0;
58202   }
58203   {
58204     try {
58205       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
58206     } CALL_CATCH_EXCEPTION(0);
58207   }
58208   jresult = (void *)result;
58209   return jresult;
58210 }
58211
58212
58213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
58214   void * jresult ;
58215   Dali::Devel::PixelBuffer *arg1 = 0 ;
58216   Dali::PixelData result;
58217
58218   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58219   if (!arg1) {
58220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
58221     return 0;
58222   }
58223   {
58224     try {
58225       result = Dali::Devel::PixelBuffer::Convert(*arg1);
58226     } CALL_CATCH_EXCEPTION(0);
58227   }
58228   jresult = new Dali::PixelData((const Dali::PixelData &)result);
58229   return jresult;
58230 }
58231
58232
58233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
58234   void * jresult ;
58235   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58236   Dali::PixelData result;
58237
58238   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58239   {
58240     try {
58241       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
58242     } CALL_CATCH_EXCEPTION(0);
58243   }
58244   jresult = new Dali::PixelData((const Dali::PixelData &)result);
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
58250   void * jresult ;
58251   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58252   unsigned char *result = 0 ;
58253
58254   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58255   {
58256     try {
58257       result = (unsigned char *)(arg1)->GetBuffer();
58258     } CALL_CATCH_EXCEPTION(0);
58259   }
58260    jresult = (void *)result;
58261    return jresult;
58262 }
58263
58264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
58265   unsigned int jresult ;
58266   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58267   unsigned int result;
58268
58269   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58270   {
58271     try {
58272       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
58273     } CALL_CATCH_EXCEPTION(0);
58274   }
58275   jresult = result;
58276   return jresult;
58277 }
58278
58279
58280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
58281   unsigned int jresult ;
58282   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58283   unsigned int result;
58284
58285   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58286   {
58287     try {
58288       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
58289     } CALL_CATCH_EXCEPTION(0);
58290   }
58291   jresult = result;
58292   return jresult;
58293 }
58294
58295
58296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
58297   int jresult ;
58298   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58299   Dali::Pixel::Format result;
58300
58301   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58302   {
58303     try {
58304       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
58305     } CALL_CATCH_EXCEPTION(0);
58306   }
58307   jresult = (int)result;
58308   return jresult;
58309 }
58310
58311
58312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
58313   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58314   Dali::Devel::PixelBuffer arg2 ;
58315   float arg3 ;
58316   bool arg4 ;
58317   Dali::Devel::PixelBuffer *argp2 ;
58318
58319   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58320   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58321   if (!argp2) {
58322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58323     return ;
58324   }
58325   arg2 = *argp2;
58326   arg3 = (float)jarg3;
58327   arg4 = jarg4 ? true : false;
58328   {
58329     try {
58330       (arg1)->ApplyMask(arg2,arg3,arg4);
58331     } CALL_CATCH_EXCEPTION();
58332   }
58333 }
58334
58335
58336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
58337   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58338   Dali::Devel::PixelBuffer arg2 ;
58339   float arg3 ;
58340   Dali::Devel::PixelBuffer *argp2 ;
58341
58342   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58343   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58344   if (!argp2) {
58345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58346     return ;
58347   }
58348   arg2 = *argp2;
58349   arg3 = (float)jarg3;
58350   {
58351     try {
58352       (arg1)->ApplyMask(arg2,arg3);
58353     } CALL_CATCH_EXCEPTION();
58354   }
58355 }
58356
58357
58358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
58359   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58360   Dali::Devel::PixelBuffer arg2 ;
58361   Dali::Devel::PixelBuffer *argp2 ;
58362
58363   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58364   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
58365   if (!argp2) {
58366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
58367     return ;
58368   }
58369   arg2 = *argp2;
58370   {
58371     try {
58372       (arg1)->ApplyMask(arg2);
58373     } CALL_CATCH_EXCEPTION();
58374   }
58375 }
58376
58377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
58378   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58379   float arg2 ;
58380
58381   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58382   arg2 = (float)jarg2;
58383   {
58384     try {
58385       (arg1)->ApplyGaussianBlur(arg2);
58386     } CALL_CATCH_EXCEPTION();
58387   }
58388 }
58389
58390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
58391   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58392   uint16_t arg2 ;
58393   uint16_t arg3 ;
58394   uint16_t arg4 ;
58395   uint16_t arg5 ;
58396
58397   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58398   arg2 = (uint16_t)jarg2;
58399   arg3 = (uint16_t)jarg3;
58400   arg4 = (uint16_t)jarg4;
58401   arg5 = (uint16_t)jarg5;
58402   {
58403     try {
58404       (arg1)->Crop(arg2,arg3,arg4,arg5);
58405     } CALL_CATCH_EXCEPTION();
58406   }
58407 }
58408
58409
58410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
58411   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58412   uint16_t arg2 ;
58413   uint16_t arg3 ;
58414
58415   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58416   arg2 = (uint16_t)jarg2;
58417   arg3 = (uint16_t)jarg3;
58418   {
58419     try {
58420       (arg1)->Resize(arg2,arg3);
58421     } CALL_CATCH_EXCEPTION();
58422   }
58423 }
58424
58425 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
58426   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58427   Dali::Degree * arg2 ;
58428
58429   bool result = false;
58430
58431   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58432   arg2 = (Dali::Degree *)jarg2;
58433   {
58434     try {
58435       result = (arg1)->Rotate(*arg2);
58436     } CALL_CATCH_EXCEPTION(false);
58437   }
58438   return result;
58439 }
58440
58441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
58442   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
58443   uint32_t result = 0;
58444
58445   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
58446   {
58447     try {
58448       result = (arg1)->GetBrightness();
58449     } CALL_CATCH_EXCEPTION(0);
58450   }
58451   return result;
58452 }
58453
58454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
58455   void * jresult ;
58456   std::string *arg1 = 0 ;
58457   Dali::ImageDimensions arg2 ;
58458   Dali::FittingMode::Type arg3 ;
58459   Dali::SamplingMode::Type arg4 ;
58460   bool arg5 ;
58461   Dali::ImageDimensions *argp2 ;
58462   Dali::Devel::PixelBuffer result;
58463
58464   if (!jarg1) {
58465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58466     return 0;
58467   }
58468   std::string arg1_str(jarg1);
58469   arg1 = &arg1_str;
58470   argp2 = (Dali::ImageDimensions *)jarg2;
58471   if (!argp2) {
58472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58473     return 0;
58474   }
58475   arg2 = *argp2;
58476   arg3 = (Dali::FittingMode::Type)jarg3;
58477   arg4 = (Dali::SamplingMode::Type)jarg4;
58478   arg5 = jarg5 ? true : false;
58479   {
58480     try {
58481       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
58482     } CALL_CATCH_EXCEPTION(0);
58483   }
58484   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
58490   void * jresult ;
58491   std::string *arg1 = 0 ;
58492   Dali::ImageDimensions arg2 ;
58493   Dali::FittingMode::Type arg3 ;
58494   Dali::SamplingMode::Type arg4 ;
58495   Dali::ImageDimensions *argp2 ;
58496   Dali::Devel::PixelBuffer result;
58497
58498   if (!jarg1) {
58499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58500     return 0;
58501   }
58502   std::string arg1_str(jarg1);
58503   arg1 = &arg1_str;
58504   argp2 = (Dali::ImageDimensions *)jarg2;
58505   if (!argp2) {
58506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58507     return 0;
58508   }
58509   arg2 = *argp2;
58510   arg3 = (Dali::FittingMode::Type)jarg3;
58511   arg4 = (Dali::SamplingMode::Type)jarg4;
58512   {
58513     try {
58514       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
58515     } CALL_CATCH_EXCEPTION(0);
58516   }
58517   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58518   return jresult;
58519 }
58520
58521
58522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58523   void * jresult ;
58524   std::string *arg1 = 0 ;
58525   Dali::ImageDimensions arg2 ;
58526   Dali::FittingMode::Type arg3 ;
58527   Dali::ImageDimensions *argp2 ;
58528   Dali::Devel::PixelBuffer result;
58529
58530   if (!jarg1) {
58531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58532     return 0;
58533   }
58534   std::string arg1_str(jarg1);
58535   arg1 = &arg1_str;
58536   argp2 = (Dali::ImageDimensions *)jarg2;
58537   if (!argp2) {
58538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58539     return 0;
58540   }
58541   arg2 = *argp2;
58542   arg3 = (Dali::FittingMode::Type)jarg3;
58543   {
58544     try {
58545       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
58546     } CALL_CATCH_EXCEPTION(0);
58547   }
58548   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58549   return jresult;
58550 }
58551
58552
58553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
58554   void * jresult ;
58555   std::string *arg1 = 0 ;
58556   Dali::ImageDimensions arg2 ;
58557   Dali::ImageDimensions *argp2 ;
58558   Dali::Devel::PixelBuffer result;
58559
58560   if (!jarg1) {
58561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58562     return 0;
58563   }
58564   std::string arg1_str(jarg1);
58565   arg1 = &arg1_str;
58566   argp2 = (Dali::ImageDimensions *)jarg2;
58567   if (!argp2) {
58568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58569     return 0;
58570   }
58571   arg2 = *argp2;
58572   {
58573     try {
58574       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
58575     } CALL_CATCH_EXCEPTION(0);
58576   }
58577   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58578   return jresult;
58579 }
58580
58581
58582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
58583   void * jresult ;
58584   std::string *arg1 = 0 ;
58585   Dali::Devel::PixelBuffer result;
58586
58587   if (!jarg1) {
58588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58589     return 0;
58590   }
58591   std::string arg1_str(jarg1);
58592   arg1 = &arg1_str;
58593   {
58594     try {
58595       result = Dali::LoadImageFromFile((std::string const &)*arg1);
58596     } CALL_CATCH_EXCEPTION(0);
58597   }
58598   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58599   return jresult;
58600 }
58601
58602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
58603   void * jresult ;
58604   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
58605   Dali::ImageDimensions arg2 ;
58606   Dali::FittingMode::Type arg3 ;
58607   Dali::SamplingMode::Type arg4 ;
58608   bool arg5 ;
58609   Dali::ImageDimensions *argp2 ;
58610   Dali::Devel::PixelBuffer result;
58611
58612   if (!jarg1) {
58613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
58614     return 0;
58615   }
58616   arg1 = (Dali::Vector<uint8_t> *)jarg1;
58617   argp2 = (Dali::ImageDimensions *)jarg2;
58618   if (!argp2) {
58619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58620     return 0;
58621   }
58622   arg2 = *argp2;
58623   arg3 = (Dali::FittingMode::Type)jarg3;
58624   arg4 = (Dali::SamplingMode::Type)jarg4;
58625   arg5 = jarg5 ? true : false;
58626   {
58627     try {
58628       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
58629     } CALL_CATCH_EXCEPTION(0);
58630   }
58631   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58632   return jresult;
58633 }
58634
58635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
58636   void * jresult ;
58637   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
58638   Dali::ImageDimensions arg2 ;
58639   Dali::FittingMode::Type arg3 ;
58640   Dali::SamplingMode::Type arg4 ;
58641   Dali::ImageDimensions *argp2 ;
58642   Dali::Devel::PixelBuffer result;
58643
58644   if (!jarg1) {
58645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
58646     return 0;
58647   }
58648   arg1 = (Dali::Vector<uint8_t> *)jarg1;
58649   argp2 = (Dali::ImageDimensions *)jarg2;
58650   if (!argp2) {
58651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58652     return 0;
58653   }
58654   arg2 = *argp2;
58655   arg3 = (Dali::FittingMode::Type)jarg3;
58656   arg4 = (Dali::SamplingMode::Type)jarg4;
58657   {
58658     try {
58659       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
58660     } CALL_CATCH_EXCEPTION(0);
58661   }
58662   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58663   return jresult;
58664 }
58665
58666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
58667   void * jresult ;
58668   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
58669   Dali::ImageDimensions arg2 ;
58670   Dali::FittingMode::Type arg3 ;
58671   Dali::ImageDimensions *argp2 ;
58672   Dali::Devel::PixelBuffer result;
58673
58674   if (!jarg1) {
58675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
58676     return 0;
58677   }
58678   arg1 = (Dali::Vector<uint8_t> *)jarg1;
58679   argp2 = (Dali::ImageDimensions *)jarg2;
58680   if (!argp2) {
58681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58682     return 0;
58683   }
58684   arg2 = *argp2;
58685   arg3 = (Dali::FittingMode::Type)jarg3;
58686   {
58687     try {
58688       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
58689     } CALL_CATCH_EXCEPTION(0);
58690   }
58691   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58692   return jresult;
58693 }
58694
58695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
58696   void * jresult ;
58697   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
58698   Dali::ImageDimensions arg2 ;
58699   Dali::ImageDimensions *argp2 ;
58700   Dali::Devel::PixelBuffer result;
58701
58702   if (!jarg1) {
58703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
58704     return 0;
58705   }
58706   arg1 = (Dali::Vector<uint8_t> *)jarg1;
58707   argp2 = (Dali::ImageDimensions *)jarg2;
58708   if (!argp2) {
58709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58710     return 0;
58711   }
58712   arg2 = *argp2;
58713   {
58714     try {
58715       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
58716     } CALL_CATCH_EXCEPTION(0);
58717   }
58718   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58719   return jresult;
58720 }
58721
58722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
58723   void * jresult ;
58724   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
58725   Dali::Devel::PixelBuffer result;
58726
58727   if (!jarg1) {
58728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
58729     return 0;
58730   }
58731   arg1 = (Dali::Vector<uint8_t> *)jarg1;
58732   {
58733     try {
58734       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
58735     } CALL_CATCH_EXCEPTION(0);
58736   }
58737   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58738   return jresult;
58739 }
58740
58741
58742
58743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
58744   void * jresult ;
58745   std::string *arg1 = 0 ;
58746   Dali::ImageDimensions arg2 ;
58747   Dali::FittingMode::Type arg3 ;
58748   Dali::SamplingMode::Type arg4 ;
58749   bool arg5 ;
58750   Dali::ImageDimensions *argp2 ;
58751   Dali::ImageDimensions result;
58752
58753   if (!jarg1) {
58754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58755     return 0;
58756   }
58757   std::string arg1_str(jarg1);
58758   arg1 = &arg1_str;
58759   argp2 = (Dali::ImageDimensions *)jarg2;
58760   if (!argp2) {
58761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58762     return 0;
58763   }
58764   arg2 = *argp2;
58765   arg3 = (Dali::FittingMode::Type)jarg3;
58766   arg4 = (Dali::SamplingMode::Type)jarg4;
58767   arg5 = jarg5 ? true : false;
58768   {
58769     try {
58770       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
58771     } CALL_CATCH_EXCEPTION(0);
58772   }
58773   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58774   return jresult;
58775 }
58776
58777
58778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
58779   void * jresult ;
58780   std::string *arg1 = 0 ;
58781   Dali::ImageDimensions arg2 ;
58782   Dali::FittingMode::Type arg3 ;
58783   Dali::SamplingMode::Type arg4 ;
58784   Dali::ImageDimensions *argp2 ;
58785   Dali::ImageDimensions result;
58786
58787   if (!jarg1) {
58788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58789     return 0;
58790   }
58791   std::string arg1_str(jarg1);
58792   arg1 = &arg1_str;
58793   argp2 = (Dali::ImageDimensions *)jarg2;
58794   if (!argp2) {
58795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58796     return 0;
58797   }
58798   arg2 = *argp2;
58799   arg3 = (Dali::FittingMode::Type)jarg3;
58800   arg4 = (Dali::SamplingMode::Type)jarg4;
58801   {
58802     try {
58803       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
58804     } CALL_CATCH_EXCEPTION(0);
58805   }
58806   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58807   return jresult;
58808 }
58809
58810
58811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58812   void * jresult ;
58813   std::string *arg1 = 0 ;
58814   Dali::ImageDimensions arg2 ;
58815   Dali::FittingMode::Type arg3 ;
58816   Dali::ImageDimensions *argp2 ;
58817   Dali::ImageDimensions result;
58818
58819   if (!jarg1) {
58820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58821     return 0;
58822   }
58823   std::string arg1_str(jarg1);
58824   arg1 = &arg1_str;
58825   argp2 = (Dali::ImageDimensions *)jarg2;
58826   if (!argp2) {
58827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58828     return 0;
58829   }
58830   arg2 = *argp2;
58831   arg3 = (Dali::FittingMode::Type)jarg3;
58832   {
58833     try {
58834       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
58835     } CALL_CATCH_EXCEPTION(0);
58836   }
58837   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58838   return jresult;
58839 }
58840
58841
58842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
58843   void * jresult ;
58844   std::string *arg1 = 0 ;
58845   Dali::ImageDimensions arg2 ;
58846   Dali::ImageDimensions *argp2 ;
58847   Dali::ImageDimensions result;
58848
58849   if (!jarg1) {
58850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58851     return 0;
58852   }
58853   std::string arg1_str(jarg1);
58854   arg1 = &arg1_str;
58855   argp2 = (Dali::ImageDimensions *)jarg2;
58856   if (!argp2) {
58857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58858     return 0;
58859   }
58860   arg2 = *argp2;
58861   {
58862     try {
58863       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
58864     } CALL_CATCH_EXCEPTION(0);
58865   }
58866   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58867   return jresult;
58868 }
58869
58870
58871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
58872   void * jresult ;
58873   std::string *arg1 = 0 ;
58874   Dali::ImageDimensions result;
58875
58876   if (!jarg1) {
58877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58878     return 0;
58879   }
58880   std::string arg1_str(jarg1);
58881   arg1 = &arg1_str;
58882   {
58883     try {
58884       result = Dali::GetClosestImageSize((std::string const &)*arg1);
58885     } CALL_CATCH_EXCEPTION(0);
58886   }
58887   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58888   return jresult;
58889 }
58890
58891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
58892   void * jresult ;
58893   std::string *arg1 = 0 ;
58894   bool arg2 ;
58895   Dali::ImageDimensions result;
58896
58897   if (!jarg1) {
58898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58899     return 0;
58900   }
58901   std::string arg1_str(jarg1);
58902   arg1 = &arg1_str;
58903   arg2 = jarg2 ? true : false;
58904   {
58905     try {
58906       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
58907     } CALL_CATCH_EXCEPTION(0);
58908   }
58909   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58910   return jresult;
58911 }
58912
58913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
58914   void * jresult ;
58915   std::string *arg1 = 0 ;
58916   Dali::ImageDimensions arg2 ;
58917   Dali::FittingMode::Type arg3 ;
58918   Dali::SamplingMode::Type arg4 ;
58919   bool arg5 ;
58920   Dali::ImageDimensions *argp2 ;
58921   Dali::Devel::PixelBuffer result;
58922
58923   if (!jarg1) {
58924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58925     return 0;
58926   }
58927   std::string arg1_str(jarg1);
58928   arg1 = &arg1_str;
58929   argp2 = (Dali::ImageDimensions *)jarg2;
58930   if (!argp2) {
58931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58932     return 0;
58933   }
58934   arg2 = *argp2;
58935   arg3 = (Dali::FittingMode::Type)jarg3;
58936   arg4 = (Dali::SamplingMode::Type)jarg4;
58937   arg5 = jarg5 ? true : false;
58938   {
58939     try {
58940       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
58941     } CALL_CATCH_EXCEPTION(0);
58942   }
58943   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58944   return jresult;
58945 }
58946
58947
58948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
58949   void * jresult ;
58950   std::string *arg1 = 0 ;
58951   Dali::ImageDimensions arg2 ;
58952   Dali::FittingMode::Type arg3 ;
58953   Dali::SamplingMode::Type arg4 ;
58954   Dali::ImageDimensions *argp2 ;
58955   Dali::Devel::PixelBuffer result;
58956
58957   if (!jarg1) {
58958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58959     return 0;
58960   }
58961   std::string arg1_str(jarg1);
58962   arg1 = &arg1_str;
58963   argp2 = (Dali::ImageDimensions *)jarg2;
58964   if (!argp2) {
58965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58966     return 0;
58967   }
58968   arg2 = *argp2;
58969   arg3 = (Dali::FittingMode::Type)jarg3;
58970   arg4 = (Dali::SamplingMode::Type)jarg4;
58971   {
58972     try {
58973       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
58974     } CALL_CATCH_EXCEPTION(0);
58975   }
58976   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58977   return jresult;
58978 }
58979
58980
58981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58982   void * jresult ;
58983   std::string *arg1 = 0 ;
58984   Dali::ImageDimensions arg2 ;
58985   Dali::FittingMode::Type arg3 ;
58986   Dali::ImageDimensions *argp2 ;
58987   Dali::Devel::PixelBuffer result;
58988
58989   if (!jarg1) {
58990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58991     return 0;
58992   }
58993   std::string arg1_str(jarg1);
58994   arg1 = &arg1_str;
58995   argp2 = (Dali::ImageDimensions *)jarg2;
58996   if (!argp2) {
58997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58998     return 0;
58999   }
59000   arg2 = *argp2;
59001   arg3 = (Dali::FittingMode::Type)jarg3;
59002   {
59003     try {
59004       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
59005     } CALL_CATCH_EXCEPTION(0);
59006   }
59007   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59008   return jresult;
59009 }
59010
59011
59012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
59013   void * jresult ;
59014   std::string *arg1 = 0 ;
59015   Dali::ImageDimensions arg2 ;
59016   Dali::ImageDimensions *argp2 ;
59017   Dali::Devel::PixelBuffer result;
59018
59019   if (!jarg1) {
59020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59021     return 0;
59022   }
59023   std::string arg1_str(jarg1);
59024   arg1 = &arg1_str;
59025   argp2 = (Dali::ImageDimensions *)jarg2;
59026   if (!argp2) {
59027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
59028     return 0;
59029   }
59030   arg2 = *argp2;
59031   {
59032     try {
59033       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
59034     } CALL_CATCH_EXCEPTION(0);
59035   }
59036   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
59042   void * jresult ;
59043   std::string *arg1 = 0 ;
59044   Dali::Devel::PixelBuffer result;
59045
59046   if (!jarg1) {
59047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59048     return 0;
59049   }
59050   std::string arg1_str(jarg1);
59051   arg1 = &arg1_str;
59052   {
59053     try {
59054       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
59055     } CALL_CATCH_EXCEPTION(0);
59056   }
59057   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
59058   return jresult;
59059 }
59060
59061 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
59062   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
59063   char * jresult = SWIG_csharp_string_callback((const char *)result);
59064   return jresult;
59065 }
59066
59067 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
59068   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
59069   return result;
59070 }
59071
59072 struct NativeImageSourcePtrHandle
59073 {
59074   NativeImageSourcePtr Ptr;
59075 };
59076
59077 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
59078 {
59079   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59080   return (NativeImageInterface*)(arg1);
59081 }
59082
59083 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
59084 {
59085   void* jresult;
59086   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
59087   {
59088     try {
59089       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
59090     }
59091     catch (std::out_of_range & e) {
59092       {
59093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59094       };
59095     }
59096     catch (std::exception & e) {
59097       {
59098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59099       };
59100     }
59101     catch (Dali::DaliException e) {
59102       {
59103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59104       };
59105     }
59106     catch (...) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59109       };
59110     }
59111   }
59112   jresult = (void *)handle;
59113   return jresult;
59114 }
59115
59116 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
59117 {
59118   void* jresult;
59119   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
59120   jresult = (void*)( handle->Ptr.Get() );
59121   return jresult;
59122 }
59123
59124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
59125   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
59126   {
59127     try {
59128       delete arg1;
59129     }
59130     catch (std::out_of_range & e) {
59131       {
59132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
59133       };
59134     }
59135     catch (std::exception & e) {
59136       {
59137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
59138       };
59139     }
59140     catch (Dali::DaliException e) {
59141       {
59142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
59143       };
59144     }
59145     catch (...) {
59146       {
59147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
59148       };
59149     }
59150   }
59151 }
59152
59153 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
59154 {
59155   void* jresult;
59156   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59157   uint16_t* arg2 = (uint16_t*)(jarg2);
59158   uint16_t* arg3 = (uint16_t*)(jarg3);
59159   uint16_t* arg4 = (uint16_t*)(jarg4);
59160   {
59161     try {
59162       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
59163     }
59164     catch (std::out_of_range & e) {
59165       {
59166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59167       };
59168     }
59169     catch (std::exception & e) {
59170       {
59171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59172       };
59173     }
59174     catch (Dali::DaliException e) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59177       };
59178     }
59179     catch (...) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59182       };
59183     }
59184   }
59185   return jresult;
59186 }
59187
59188 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
59189 {
59190   bool jresult;
59191   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
59192
59193   {
59194     try {
59195       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
59196     }
59197     catch (std::out_of_range & e) {
59198       {
59199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59200       };
59201     }
59202     catch (std::exception & e) {
59203       {
59204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59205       };
59206     }
59207     catch (Dali::DaliException e) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59210       };
59211     }
59212     catch (...) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59215       };
59216     }
59217   }
59218   return jresult;
59219 }
59220
59221 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
59222 {
59223   Dali::Toolkit::ImageUrl result;
59224   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
59225   void *jresult;
59226
59227   if (!nativeImageSource)
59228   {
59229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
59230     return 0;
59231   }
59232   {
59233     try
59234     {
59235       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
59236     }
59237     catch (std::out_of_range& e)
59238     {
59239       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59240       return 0;
59241     }
59242     catch (std::exception& e)
59243     {
59244       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59245       return 0;
59246     }
59247     catch (Dali::DaliException e)
59248     {
59249       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59250       return 0;
59251     }
59252     catch (...)
59253     {
59254       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59255       return 0;
59256     }
59257   }
59258
59259   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
59260   return jresult;
59261 }
59262
59263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
59264 {
59265   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
59266
59267   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
59268   {
59269     try
59270     {
59271       delete imageUrl;
59272     }
59273     catch (std::out_of_range& e)
59274     {
59275       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59276       return;
59277     }
59278     catch (std::exception& e)
59279     {
59280       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59281       return;
59282     }
59283     catch (Dali::DaliException e)
59284     {
59285       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59286       return;
59287     }
59288     catch (...)
59289     {
59290       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59291       return;
59292     }
59293   }
59294 }
59295
59296 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
59297 {
59298   char *jresult;
59299   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
59300   std::string result;
59301
59302   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
59303   {
59304     try
59305     {
59306       result = imageUrl->GetUrl();
59307     }
59308     catch (std::out_of_range& e)
59309     {
59310       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
59311       return 0;
59312     }
59313     catch (std::exception& e)
59314     {
59315       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
59316       return 0;
59317     }
59318     catch (Dali::DaliException e)
59319     {
59320       SWIG_CSharpException(SWIG_UnknownError, e.condition);
59321       return 0;
59322     }
59323     catch (...)
59324     {
59325       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
59326       return 0;
59327     }
59328   }
59329
59330   jresult = SWIG_csharp_string_callback((&result)->c_str());
59331   return jresult;
59332 }
59333
59334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
59335   Dali::Actor *arg1 = (Dali::Actor *) 0;
59336   Dali::Vector2 maximumSize;
59337   Dali::Vector2 minimumSize;
59338   Dali::Vector3 naturalSize;
59339   bool widthForHeight;
59340   float result;
59341   {
59342     try {
59343       arg1 = (Dali::Actor *)jarg1;
59344       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
59345       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
59346       naturalSize = arg1->GetNaturalSize();
59347       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
59348
59349       float baseWidth;
59350       if (widthForHeight)
59351       {
59352         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
59353         baseWidth = arg1->GetWidthForHeight(baseHeight);
59354       }
59355       else
59356       {
59357         baseWidth = naturalSize.width;
59358       }
59359
59360       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
59361       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
59362     } CALL_CATCH_EXCEPTION(0);
59363   }
59364
59365   return result;
59366 }
59367
59368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
59369   Dali::Actor *arg1 = (Dali::Actor *) 0;
59370   Dali::Vector2 maximumSize;
59371   Dali::Vector2 minimumSize;
59372   Dali::Vector3 naturalSize;
59373   bool heightForWidth;
59374   float result;
59375   {
59376     try {
59377       arg1 = (Dali::Actor *)jarg1;
59378       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
59379       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
59380       naturalSize = arg1->GetNaturalSize();
59381       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
59382
59383       float baseHeight;
59384       if (heightForWidth)
59385       {
59386         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
59387         baseHeight = arg1->GetHeightForWidth(baseWidth);
59388       }
59389       else
59390       {
59391         baseHeight = naturalSize.height;
59392       }
59393
59394       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
59395       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
59396     } CALL_CATCH_EXCEPTION(0);
59397   }
59398
59399   return result;
59400 }
59401
59402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() {
59403   int jresult ;
59404   int result;
59405
59406   result = (int)Dali::Vector< Dali::Vector2 >::BaseType;
59407   jresult = (int)result;
59408   return jresult;
59409 }
59410
59411
59412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() {
59413   void * jresult ;
59414   Dali::Vector< Dali::Vector2 > *result = 0 ;
59415
59416   {
59417     try {
59418       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >();
59419     } CALL_CATCH_EXCEPTION(0);
59420   }
59421
59422   jresult = (void *)result;
59423   return jresult;
59424 }
59425
59426
59427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) {
59428   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59429
59430   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59431   {
59432     try {
59433       delete arg1;
59434     } CALL_CATCH_EXCEPTION();
59435   }
59436 }
59437
59438
59439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) {
59440   void * jresult ;
59441   Dali::Vector< Dali::Vector2 > *arg1 = 0 ;
59442   Dali::Vector< Dali::Vector2 > *result = 0 ;
59443
59444   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59445   if (!arg1) {
59446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
59447     return 0;
59448   }
59449   {
59450     try {
59451       result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1);
59452     } CALL_CATCH_EXCEPTION(0);
59453   }
59454
59455   jresult = (void *)result;
59456   return jresult;
59457 }
59458
59459
59460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) {
59461   void * jresult ;
59462   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59463   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
59464   Dali::Vector< Dali::Vector2 > *result = 0 ;
59465
59466   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59467   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
59468   if (!arg2) {
59469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0);
59470     return 0;
59471   }
59472   {
59473     try {
59474       result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2);
59475     } CALL_CATCH_EXCEPTION(0);
59476   }
59477
59478   jresult = (void *)result;
59479   return jresult;
59480 }
59481
59482
59483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) {
59484   void * jresult ;
59485   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59486   Dali::Vector< Dali::Vector2 >::Iterator result;
59487
59488   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59489   {
59490     try {
59491       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin();
59492     } CALL_CATCH_EXCEPTION(0);
59493   }
59494
59495   jresult = (void *)result;
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) {
59501   void * jresult ;
59502   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59503   Dali::Vector< Dali::Vector2 >::Iterator result;
59504
59505   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59506   {
59507     try {
59508       result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End();
59509     } CALL_CATCH_EXCEPTION(0);
59510   }
59511
59512   jresult = (void *)result;
59513   return jresult;
59514 }
59515
59516
59517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
59518   void * jresult ;
59519   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59520   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
59521   Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ;
59522
59523   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59524   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
59525   {
59526     try {
59527       result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2);
59528     } CALL_CATCH_EXCEPTION(0);
59529   }
59530
59531   jresult = (void *)result;
59532   return jresult;
59533 }
59534
59535
59536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) {
59537   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59538   Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ;
59539
59540   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59541   arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2;
59542   if (!arg2) {
59543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
59544     return ;
59545   }
59546   {
59547     try {
59548       (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2);
59549     } CALL_CATCH_EXCEPTION();
59550   }
59551 }
59552
59553
59554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
59555   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59556   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59557   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
59558
59559   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59560   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
59561   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
59562   if (!arg3) {
59563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0);
59564     return ;
59565   }
59566   {
59567     try {
59568       (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
59569     } CALL_CATCH_EXCEPTION();
59570   }
59571 }
59572
59573
59574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
59575   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59576   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59577   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59578   Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59579
59580   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59581   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
59582   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
59583   arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4;
59584   {
59585     try {
59586       (arg1)->Insert(arg2,arg3,arg4);
59587     } CALL_CATCH_EXCEPTION();
59588   }
59589 }
59590
59591
59592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) {
59593   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59594   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
59595
59596   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59597   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
59598   {
59599     try {
59600       (arg1)->Reserve(arg2);
59601     } CALL_CATCH_EXCEPTION();
59602   }
59603 }
59604
59605
59606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
59607   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59608   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
59609
59610   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59611   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
59612   {
59613     try {
59614       (arg1)->Resize(arg2);
59615     } CALL_CATCH_EXCEPTION();
59616   }
59617 }
59618
59619
59620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
59621   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59622   Dali::Vector< Dali::Vector2 >::SizeType arg2 ;
59623   Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ;
59624
59625   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59626   arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2;
59627   arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3;
59628   if (!arg3) {
59629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
59630     return ;
59631   }
59632   {
59633     try {
59634       (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3);
59635     } CALL_CATCH_EXCEPTION();
59636   }
59637 }
59638
59639
59640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) {
59641   void * jresult ;
59642   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59643   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59644   Dali::Vector< Dali::Vector2 >::Iterator result;
59645
59646   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59647   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
59648   {
59649     try {
59650       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2);
59651     } CALL_CATCH_EXCEPTION(0);
59652   }
59653
59654   jresult = (void *)result;
59655   return jresult;
59656 }
59657
59658
59659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
59660   void * jresult ;
59661   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59662   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59663   Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59664   Dali::Vector< Dali::Vector2 >::Iterator result;
59665
59666   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59667   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
59668   arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3;
59669   {
59670     try {
59671       result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3);
59672     } CALL_CATCH_EXCEPTION(0);
59673   }
59674
59675   jresult = (void *)result;
59676   return jresult;
59677 }
59678
59679
59680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) {
59681   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59682   Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ;
59683
59684   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59685   arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2;
59686   {
59687     try {
59688       (arg1)->Remove(arg2);
59689     } CALL_CATCH_EXCEPTION();
59690   }
59691 }
59692
59693
59694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) {
59695   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59696   Dali::Vector< Dali::Vector2 > *arg2 = 0 ;
59697
59698   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59699   arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2;
59700   if (!arg2) {
59701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0);
59702     return ;
59703   }
59704   {
59705     try {
59706       (arg1)->Swap(*arg2);
59707     } CALL_CATCH_EXCEPTION();
59708   }
59709 }
59710
59711
59712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) {
59713   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59714
59715   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59716   {
59717     try {
59718       (arg1)->Clear();
59719     } CALL_CATCH_EXCEPTION();
59720   }
59721 }
59722
59723
59724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) {
59725   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59726
59727   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59728   {
59729     try {
59730       (arg1)->Release();
59731     } CALL_CATCH_EXCEPTION();
59732   }
59733 }
59734
59735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) {
59736   Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ;
59737   int size;
59738
59739   arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1;
59740   {
59741     try {
59742       size = (arg1)->Size();
59743     } CALL_CATCH_EXCEPTION(0);
59744   }
59745
59746   return size;
59747 }
59748
59749 #ifdef __cplusplus
59750 }
59751 #endif
59752